📜  将字符X转换为字符串Y的方法数量

📅  最后修改于: 2021-04-29 12:04:06             🧑  作者: Mango

给定一个字符X和一个长度为N的字符串Y ,任务是找到通过在X的左右两端附加字符来将X转换为Y的方法。请注意,如果左右追加的顺序不同或序列相同,则任何两种方式都被认为是不同的,那么追加的字符也不同,即,左追加后跟右追加与右追加后跟左追加不同附加。由于答案可能很大,因此请打印最终答案MOD(10 9 + 7)。

例子:

方法1:解决此问题的一种方法是使用动态编程。

  • 初始化变量ans = 0,mod = 1000000007。
  • 对于所有使Y [i] = X的索引’i’,将答案更新为ans =(ans + dp [i] [i])%mod。

在这里, dp [l] [r]是从子字符串Y [l…r]生成Y的方法的数量。
重复关系将是:

该方法的时间复杂度将为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 AnkitRai01


Python3
# 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 AnkitRai01


C#
// 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