给定一个字符X和一个长度为N的字符串Y ，任务是找到通过在X的左右两端附加字符来将X转换为Y的方法。请注意，如果左右追加的顺序不同或序列相同，则任何两种方式都被认为是不同的，那么追加的字符也不同，即，左追加后跟右追加与右追加后跟左追加不同附加。由于答案可能很大，因此请打印最终答案MOD(10 9 + 7)。
例子：
Input: X = ‘a’, Y = “xxay”
Output: 3
All possible ways are:
- Left append ‘x’ (“xa”), left append ‘x’ (“xxa”), right append y(“xxay”).
- Left append ‘x’ (“xa”), right append y(“xay”), left append ‘x’ (“xxay”).
- Right append y(“ay”), left append ‘x’ (“xay”), left append ‘x’ (“xxay”).
Input: X = ‘a’, Y = “cd”
Output: 0
方法1：解决此问题的一种方法是使用动态编程。
- 初始化变量ans = 0，mod = 1000000007。
- 对于所有使Y [i] = X的索引’i’，将答案更新为ans =(ans + dp [i] [i])％mod。
在这里， dp [l] [r]是从子字符串Y [l…r]生成Y的方法的数量。
重复关系将是：
dp[l][r] = (dp[l][r + 1] + dp[l – 1][r]) % mod
该方法的时间复杂度将为O(N 2 )。
方法2：
- 初始化变量ans = 0，mod = 1000000007。
- 对于所有使Y [i] = X的索引i ，将答案更新为ans =(ans + F(i))％mod ，其中F(i)=(((N – 1)！)/(i！*(N –我– 1)！))％mod 。
产生上述公式的原因：尝试查找问题的答案，找到(p的L数)和(q的R数)的排列数，其中L和R分别为左追加和右追加运算。
答案是(p + q)！ /(p！* q！) 。对于每个有效的i ，只需找到i Ls和N – i – 1 Rs的排列数。
这种方法的时间复杂度将是O(N) 。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
const int MOD = 1000000007;
// Function to find the modular-inverse
long long modInv(long long a, long long p = MOD - 2)
{
long long s = 1;
// While power > 1
while (p != 1) {
// Updating s and a
if (p % 2)
s = (s * a) % MOD;
a = (a * a) % MOD;
// Updating power
p /= 2;
}
// Return the final answer
return (a * s) % MOD;
}
// Function to return the count of ways
long long findCnt(char x, string y)
{
// To store the final answer
long long ans = 0;
// To store pre-computed factorials
long long fact[y.size() + 1] = { 1 };
// Computing factorials
for (long long i = 1; i <= y.size(); i++)
fact[i] = (fact[i - 1] * i) % MOD;
// Loop to find the occurrences of x
// and update the ans
for (long long i = 0; i < y.size(); i++) {
if (y[i] == x) {
ans += (modInv(fact[i])
* modInv(fact[y.size() - i - 1]))
% MOD;
ans %= MOD;
}
}
// Multiplying the answer by (n - 1)!
ans *= fact[(y.size() - 1)];
ans %= MOD;
// Return the final answer
return ans;
}
// Driver code
int main()
{
char x = 'a';
string y = "xxayy";
cout << findCnt(x, y);
return 0;
} Java
// Java implementation of the approach
class GFG
{
final static int MOD = 1000000007;
// Function to find the modular-inverse
static long modInv(long a)
{
long p = MOD - 2;
long s = 1;
// While power > 1
while (p != 1)
{
// Updating s and a
if (p % 2 == 1)
s = (s * a) % MOD;
a = (a * a) % MOD;
// Updating power
p /= 2;
}
// Return the final answer
return (a * s) % MOD;
}
// Function to return the count of ways
static long findCnt(char x, String y)
{
// To store the final answer
long ans = 0;
// To store pre-computed factorials
long fact[] = new long[y.length() + 1];
for(int i = 0; i < y.length() + 1; i++)
fact[i] = 1;
// Computing factorials
for (int i = 1; i <= y.length(); i++)
fact[i] = (fact[i - 1] * i) % MOD;
// Loop to find the occurrences of x
// and update the ans
for (int i = 0; i < y.length(); i++)
{
if (y.charAt(i) == x)
{
ans += (modInv(fact[i])
* modInv(fact[y.length() - i - 1])) % MOD;
ans %= MOD;
}
}
// Multiplying the answer by (n - 1)!
ans *= fact[(y.length() - 1)];
ans %= MOD;
// Return the final answer
return ans;
}
// Driver code
public static void main (String[] args)
{
char x = 'a';
String y = "xxayy";
System.out.println(findCnt(x, y));
}
}
// This code is contributed by AnkitRai01Python3
# Python3 implementation of the approach
MOD = 1000000007;
# Function to find the modular-inverse
def modInv(a, p = MOD - 2) :
s = 1;
# While power > 1
while (p != 1) :
# Updating s and a
if (p % 2) :
s = (s * a) % MOD;
a = (a * a) % MOD;
# Updating power
p //= 2;
# Return the final answer
return (a * s) % MOD;
# Function to return the count of ways
def findCnt(x, y) :
# To store the final answer
ans = 0;
# To store pre-computed factorials
fact = [1]*(len(y) + 1) ;
# Computing factorials
for i in range(1,len(y)) :
fact[i] = (fact[i - 1] * i) % MOD;
# Loop to find the occurrences of x
# and update the ans
for i in range(len(y)) :
if (y[i] == x) :
ans += (modInv(fact[i]) *
modInv(fact[len(y)- i - 1])) % MOD;
ans %= MOD;
# Multiplying the answer by (n - 1)!
ans *= fact[(len(y) - 1)];
ans %= MOD;
# Return the final answer
return ans;
# Driver code
if __name__ == "__main__" :
x = 'a';
y = "xxayy";
print(findCnt(x, y));
# This code is contributed by AnkitRai01C#
// C# implementation of the approach
using System;
class GFG
{
static int MOD = 1000000007;
// Function to find the modular-inverse
static long modInv(long a)
{
long p = MOD - 2;
long s = 1;
// While power > 1
while (p != 1)
{
// Updating s and a
if (p % 2 == 1)
s = (s * a) % MOD;
a = (a * a) % MOD;
// Updating power
p /= 2;
}
// Return the final answer
return (a * s) % MOD;
}
// Function to return the count of ways
static long findCnt(char x, String y)
{
// To store the final answer
long ans = 0;
// To store pre-computed factorials
long []fact = new long[y.Length + 1];
for(int i = 0; i < y.Length + 1; i++)
fact[i] = 1;
// Computing factorials
for (int i = 1; i <= y.Length; i++)
fact[i] = (fact[i - 1] * i) % MOD;
// Loop to find the occurrences of x
// and update the ans
for (int i = 0; i < y.Length; i++)
{
if (y[i] == x)
{
ans += (modInv(fact[i])
* modInv(fact[y.Length - i - 1])) % MOD;
ans %= MOD;
}
}
// Multiplying the answer by (n - 1)!
ans *= fact[(y.Length - 1)];
ans %= MOD;
// Return the final answer
return ans;
}
// Driver code
public static void Main ()
{
char x = 'a';
string y = "xxayy";
Console.WriteLine(findCnt(x, y));
}
}
// This code is contributed by AnkitRai01输出：
6