对满足给定属性的从 N 到 M 的所有长度的不同二进制字符串进行计数的查询

给定一个K和一个由 {N, M} 形式的查询组成的矩阵Q[][] ，每个查询的任务是计算从Q[i][0]到Q[的所有长度的可能字符串的数量i][1]满足以下性质：

• 0的频率等于K的倍数。
• 只有当0和1的频率不同时，才称两个字符串不同

由于答案可能非常大，请通过 mod 10 ⁹ + 7计算答案。

例子：

Input: K = 3, Q[][] = {{1, 3}} 
Output: 4 
Explanation: 
All possible strings of length 1 : {“1”} 
All possible strings of length 2 : {“11”} 
All possible strings of length 3 : {“111”, “000”} 
Therefore, a total of 4 strings can be generated.

Input: K = 3, Q[][] = {{1, 4}, {3, 7}} 
Output: 
7 
24 
 

天真的方法：
请按照以下步骤解决问题：

• 初始化一个数组dp[]使得dp[i]表示长度为i 的可能字符串的数量。
• 初始化dp[0] = 1。
• 对于每个^第i^个长度，最多出现两种可能性：
  • 将“1”附加到长度为i – 1的字符串。
  • 将K 0加到所有可能的长度为iK 的字符串中。
• 最后，对于每个查询Q[i] ，打印Q[i][0] <= j <= Q[i][1]的所有dp[j]的总和。

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

有效的方法：
可以使用 Prefix Sum Array 优化上述方法。请按照以下步骤操作：

• 按照上述方法中的步骤更新dp[]数组。
• 计算dp[]数组的前缀和数组。
• 最后，对于每个查询Q[i] ，计算dp[Q[i][1]] – dp[Q[i][0] – 1]并打印结果。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above approach
#include 
using namespace std;
 
const int N = 1e5 + 5;
 
const int MOD = 1000000007;
 
long int dp[N];
 
// Function to calculate the
// count of possible strings
void countStrings(int K,
                  vector > Q)
{
    // Initialize dp[0]
    dp[0] = 1;
 
    // dp[i] represents count of
    // strings of length i
    for (int i = 1; i < N; i++) {
 
        dp[i] = dp[i - 1];
 
        // Add dp[i-k] if i>=k
        if (i >= K)
            dp[i]
                = (dp[i] + dp[i - K]) % MOD;
    }
 
    // Update Prefix Sum Array
    for (int i = 1; i < N; i++) {
        dp[i] = (dp[i] + dp[i - 1]) % MOD;
    }
 
    for (int i = 0; i < Q.size(); i++) {
        long int ans
            = dp[Q[i][1]] - dp[Q[i][0] - 1];
 
        if (ans < 0)
            ans = ans + MOD;
 
        cout << ans << endl;
    }
}
 
// Driver Code
int main()
{
 
    int K = 3;
 
    vector > Q
        = { { 1, 4 }, { 3, 7 } };
 
    countStrings(K, Q);
 
    return 0;
}

Java

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
static int N = (int)(1e5 + 5);
static int MOD = 1000000007;
static int []dp = new int[N];
 
// Function to calculate the
// count of possible Strings
static void countStrings(int K, int[][] Q)
{
     
    // Initialize dp[0]
    dp[0] = 1;
 
    // dp[i] represents count of
    // Strings of length i
    for(int i = 1; i < N; i++)
    {
        dp[i] = dp[i - 1];
 
        // Add dp[i-k] if i>=k
        if (i >= K)
            dp[i] = (dp[i] + dp[i - K]) % MOD;
    }
 
    // Update Prefix Sum Array
    for(int i = 1; i < N; i++)
    {
        dp[i] = (dp[i] + dp[i - 1]) % MOD;
    }
 
    for(int i = 0; i < Q.length; i++)
    {
        int ans = dp[Q[i][1]] - dp[Q[i][0] - 1];
 
        if (ans < 0)
            ans = ans + MOD;
 
        System.out.print(ans + "\n");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int K = 3;
 
    int [][]Q = { { 1, 4 }, { 3, 7 } };
 
    countStrings(K, Q);
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program to implement
# the above approach
N = int(1e5 + 5)
MOD = 1000000007
dp = [0] * N
 
# Function to calculate the
# count of possible strings
def countStrings(K, Q):
 
    # Initialize dp[0]
    dp[0] = 1
 
    # dp[i] represents count of
    # strings of length i
    for i in range(1, N):
        dp[i] = dp[i - 1]
 
        # Add dp[i-k] if i>=k
        if(i >= K):
            dp[i] = (dp[i] + dp[i - K]) % MOD
 
    # Update Prefix Sum Array
    for i in range(1, N):
        dp[i] = (dp[i] + dp[i - 1]) % MOD
 
    for i in range(len(Q)):
        ans = dp[Q[i][1]] - dp[Q[i][0] - 1]
 
        if (ans < 0):
            ans += MOD
             
        print(ans)
 
# Driver Code
K = 3
 
Q = [ [ 1, 4 ], [ 3, 7 ] ]
 
countStrings(K, Q)
 
# This code is contributed by Shivam Singh

C#

// C# program to implement
// the above approach
using System;
class GFG{
  
static int N = (int)(1e5 + 5);
static int MOD = 1000000007;
static int []dp = new int[N];
  
// Function to calculate the
// count of possible Strings
static void countStrings(int K,
                         int[,] Q)
{    
    // Initialize dp[0]
    dp[0] = 1;
  
    // dp[i] represents count of
    // Strings of length i
    for(int i = 1; i < N; i++)
    {
        dp[i] = dp[i - 1];
  
        // Add dp[i-k] if i>=k
        if (i >= K)
            dp[i] = (dp[i] +
                     dp[i - K]) % MOD;
    }
  
    // Update Prefix Sum Array
    for(int i = 1; i < N; i++)
    {
        dp[i] = (dp[i] +
                 dp[i - 1]) % MOD;
    }
  
    for(int i = 0; i < Q.GetLength(0); i++)
    {
        int ans = dp[Q[i, 1]] -
                  dp[Q[i, 0] - 1];
  
        if (ans < 0)
            ans = ans + MOD;
  
        Console.Write(ans + "\n");
    }
}
  
// Driver Code
public static void Main(String[] args)
{
    int K = 3;
    int [,]Q = {{1, 4}, {3, 7}};
    countStrings(K, Q);
}
}
  
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript program to implement
// the above approach
let N = parseInt((1e5 + 5));
let MOD = 1000000007;
let dp = Array(N).fill(0);
 
// Function to calculate the
// count of possible Strings
function countStrings(K, Q)
{
     
    // Initialize dp[0]
    dp[0] = 1;
 
    // dp[i] represents count of
    // Strings of length i
    for(let i = 1; i < N; i++)
    {
        dp[i] = dp[i - 1];
 
        // Add dp[i-k] if i>=k
        if (i >= K)
            dp[i] = (dp[i] + dp[i - K]) % MOD;
    }
 
    // Update Prefix Sum Array
    for(let i = 1; i < N; i++)
    {
        dp[i] = (dp[i] + dp[i - 1]) % MOD;
    }
 
    for(let i = 0; i < Q.length; i++)
    {
        var ans = dp[Q[i][1]] - dp[Q[i][0] - 1];
 
        if (ans < 0)
            ans = ans + MOD;
 
        document.write(ans + "\n");
    }
}
 
// Driver Code
var K = 3;
 
let Q = [ [ 1, 4 ], [ 3, 7 ] ];
 
countStrings(K, Q);
 
// This code is contributed by gauravrajput1
 

输出：

7
24

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。