计算通过执行 K 次循环移位将字符串S 转换为 T 的方法数

给定两个字符串S 和 T以及一个数字K ，任务是计算通过执行K 个循环移位将字符串S转换为字符串T的方法的数量。

The cyclic shift is defined as the string S can be split into two non-empty parts X + Y and in one operation we can transform S to Y + X from X + Y.

注意：由于 count 可能非常大，因此请打印模10 ⁹ + 7的答案。
例子：

Input: S = “ab”, T = “ab”, K = 2 
Output: 1 
Explanation: 
The only way to do this is to convert [ab to ba] in the first move and then [ba to ab] in the second move. 
Input: S = “ababab”, T = “ababab”, K = 1 
Output: 2 
Explanation: 
One possible way to convert S to T in one move is [ab | abab] -> [ababab], the second way is [abab | ab] -> [ababab]. So there are total two ways. 
 

方法：这个问题可以用动态规划解决。如果最后我们在字符串T处，让我们称循环移位为‘good’ ，反之亦然为‘bad’ 。以下是步骤：

1. 预先计算好(由 a 表示)和坏(由 b 表示)循环移位的数量。
2. 初始化两个 dp 数组，使得dp1[i]表示在i 次移动中达到良好移动的方法数，而dp2[i]表示在i 移动中达到不良移动的方法数。
3. 对于转换，我们只关心先前的状态，即第(i – 1) 个状态，这个问题的答案是dp1[K] 。
4. 因此，在i 次移动中达到良好状态的方法数等于在i-1 次移动中达到良好移动的方法数乘以(a-1) (因为最后一次移动也很好)
5. 因此，在i-1 移动中达到坏移动的方法数量乘以(a) (因为下一步可以是任何好的移动)。

以下是好班和坏班的递推关系：

So for good shifts we have: 
$dp1[i]= dp1[i-1]*(a-1) + dp2[i-1]*a$
Similarly, for bad shifts we have: 
$dp2[i]=dp1[i-1]*b + dp2[i-1]*(b-1)$
 

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
#define mod 10000000007
 
// Function to count number of ways to
// convert string S to string T by
// performing K cyclic shifts
long long countWays(string s, string t,
                    int k)
{
    // Calculate length of string
    int n = s.size();
 
    // 'a' is no of good cyclic shifts
    // 'b' is no of bad cyclic shifts
    int a = 0, b = 0;
 
    // Iterate in the string
    for (int i = 0; i < n; i++) {
 
        string p = s.substr(i, n - i)
                + s.substr(0, i);
 
        // Precompute the number of good
        // and bad cyclic shifts
        if (p == t)
            a++;
        else
            b++;
    }
 
    // Initialize two dp arrays
    // dp1[i] to store the no of ways to
    // get to a good shift in i moves
 
    // dp2[i] to store the no of ways to
    // get to a bad shift in i moves
    vector dp1(k + 1), dp2(k + 1);
 
    if (s == t) {
        dp1[0] = 1;
        dp2[0] = 0;
    }
    else {
        dp1[0] = 0;
        dp2[0] = 1;
    }
 
    // Calculate good and bad shifts
    for (int i = 1; i <= k; i++) {
 
        dp1[i]
            = ((dp1[i - 1] * (a - 1)) % mod
            + (dp2[i - 1] * a) % mod)
            % mod;
 
        dp2[i]
            = ((dp1[i - 1] * (b)) % mod
            + (dp2[i - 1] * (b - 1)) % mod)
            % mod;
    }
 
    // Return the required number of ways
    return dp1[k];
}
 
// Driver Code
int main()
{
    // Given Strings
    string S = "ab", T = "ab";
 
    // Given K shifts required
    int K = 2;
 
    // Function Call
    cout << countWays(S, T, K);
    return 0;
}

Java

// Java program for above approach
class GFG{
     
static long mod = 10000000007L;
 
// Function to count number of ways to
// convert string S to string T by
// performing K cyclic shifts
static long countWays(String s, String t,
                    int k)
{
     
    // Calculate length of string
    int n = s.length();
 
    // 'a' is no of good cyclic shifts
    // 'b' is no of bad cyclic shifts
    int a = 0, b = 0;
 
    // Iterate in the string
    for(int i = 0; i < n; i++)
    {
    String p = s.substring(i, n - i) +
                s.substring(0, i);
         
    // Precompute the number of good
    // and bad cyclic shifts
    if (p == t)
        a++;
    else
        b++;
    }
 
    // Initialize two dp arrays
    // dp1[i] to store the no of ways to
    // get to a good shift in i moves
 
    // dp2[i] to store the no of ways to
    // get to a bad shift in i moves
    long dp1[] = new long[k + 1];
    long dp2[] = new long[k + 1];
 
    if (s == t)
    {
        dp1[0] = 1;
        dp2[0] = 0;
    }
    else
    {
        dp1[0] = 0;
        dp2[0] = 1;
    }
 
    // Calculate good and bad shifts
    for(int i = 1; i <= k; i++)
    {
    dp1[i] = ((dp1[i - 1] * (a - 1)) % mod +
                (dp2[i - 1] * a) % mod) % mod;
    dp2[i] = ((dp1[i - 1] * (b)) % mod +
                (dp2[i - 1] * (b - 1)) % mod) % mod;
    }
 
    // Return the required number of ways
    return dp1[k];
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given Strings
    String S = "ab", T = "ab";
 
    // Given K shifts required
    int K = 2;
 
    // Function Call
    System.out.print(countWays(S, T, K));
}
}
 
// This code is contributed by Pratima Pandey

Python3

# Python3 program for the above approach
mod = 1000000007
 
# Function to count number of ways
# to convert string S to string T by
# performing K cyclic shifts
def countWays(s, t, k):
     
    # Calculate length of string
    n = len(s)
     
    # a is no. of good cyclic shifts
    # b is no. of bad cyclic shifts
    a = 0
    b = 0
     
    # Iterate in string
    for i in range(n):
        p = s[i : n - i + 1] + s[: i + 1]
         
        # Precompute the number of good
        # and bad cyclic shifts
        if(p == t):
            a += 1
        else:
            b += 1
             
    # Initialize two dp arrays
    # dp1[i] to store the no of ways to
    # get to a goof shift in i moves
     
    # dp2[i] to store the no of ways to
    # get to a bad shift in i moves
    dp1 = [0] * (k + 1)
    dp2 = [0] * (k + 1)
     
    if(s == t):
        dp1[0] = 1
        dp2[0] = 0
    else:
        dp1[0] = 0
        dp2[0] = 1
         
    # Calculate good and bad shifts    
    for i in range(1, k + 1):
        dp1[i] = ((dp1[i - 1] * (a - 1)) % mod +
                (dp2[i - 1] * a) % mod) % mod
 
        dp2[i] = ((dp1[i - 1] * (b)) % mod +
                (dp2[i - 1] * (b - 1)) % mod) % mod
                     
    # Return the required number of ways
    return(dp1[k])
     
# Driver Code
 
# Given Strings
S = 'ab'
T = 'ab'
 
# Given K shifts required
K = 2
 
# Function call
print(countWays(S, T, K))
 
# This code is contributed by Arjun Saini

C#

// C# program for the above approach
using System;
 
class GFG{
     
static long mod = 10000000007L;
 
// Function to count number of ways to
// convert string S to string T by
// performing K cyclic shifts
static long countWays(string s, string t,
                      int k)
{
     
    // Calculate length of string
    int n = s.Length;
 
    // 'a' is no of good cyclic shifts
    // 'b' is no of bad cyclic shifts
    int a = 0, b = 0;
 
    // Iterate in the string
    for(int i = 0; i < n; i++)
    {
        string p = s.Substring(i, n - i) +
                   s.Substring(0, i);
         
        // Precompute the number of good
        // and bad cyclic shifts
        if (p == t)
            a++;
        else
            b++;
    }
 
    // Initialize two dp arrays
    // dp1[i] to store the no of ways to
    // get to a good shift in i moves
 
    // dp2[i] to store the no of ways to
    // get to a bad shift in i moves
    long []dp1 = new long[k + 1];
    long []dp2 = new long[k + 1];
 
    if (s == t)
    {
        dp1[0] = 1;
        dp2[0] = 0;
    }
    else
    {
        dp1[0] = 0;
        dp2[0] = 1;
    }
 
    // Calculate good and bad shifts
    for(int i = 1; i <= k; i++)
    {
        dp1[i] = ((dp1[i - 1] * (a - 1)) % mod +
                  (dp2[i - 1] * a) % mod) % mod;
        dp2[i] = ((dp1[i - 1] * (b)) % mod +
                  (dp2[i - 1] * (b - 1)) % mod) % mod;
    }
 
    // Return the required number of ways
    return dp1[k];
}
 
// Driver code
public static void Main(string[] args)
{
     
    // Given Strings
    string S = "ab", T = "ab";
 
    // Given K shifts required
    int K = 2;
 
    // Function call
    Console.Write(countWays(S, T, K));
}
}
 
// This code is contributed by rutvik_56

Javascript

 
// JavaScript program for the above approach
 
let mod = 10000000007;
 
// Function to count number of ways to
// convert string S to string T by
// performing K cyclic shifts
function countWays(s, t, k)
{
     
    // Calculate length of string
    let n = s.length;
 
    // 'a' is no of good cyclic shifts
    // 'b' is no of bad cyclic shifts
    let a = 0, b = 0;
 
    // Iterate in the string
    for(let i = 0; i < n; i++)
    {
    let p = s.substr(i, n - i) +
                s.substr(0, i);
         
    // Precompute the number of good
    // and bad cyclic shifts
    if (p == t)
        a++;
    else
        b++;
    }
 
    // Initialize two dp arrays
    // dp1[i] to store the no of ways to
    // get to a good shift in i moves
 
    // dp2[i] to store the no of ways to
    // get to a bad shift in i moves
    let dp1 = Array.from({length: k+1}, (_, i) => 0);
    let dp2 = Array.from({length: k+1}, (_, i) => 0);
 
    if (s == t)
    {
        dp1[0] = 1;
        dp2[0] = 0;
    }
    else
    {
        dp1[0] = 0;
        dp2[0] = 1;
    }
 
    // Calculate good and bad shifts
    for(let i = 1; i <= k; i++)
    {
    dp1[i] = ((dp1[i - 1] * (a - 1)) % mod +
                (dp2[i - 1] * a) % mod) % mod;
    dp2[i] = ((dp1[i - 1] * (b)) % mod +
                (dp2[i - 1] * (b - 1)) % mod) % mod;
    }
 
    // Return the required number of ways
    return dp1[k];
}
 
// Driver Code
 
    // Given Strings
    let S = "ab", T = "ab";
 
    // Given K shifts required
    let K = 2;
 
    // Function Call
    document.write(countWays(S, T, K));
 

输出：

1

时间复杂度： O(N)
辅助空间： O(K)