Count Ways To Build Good Strings

Count Ways To Build Good Strings - Problem

Dynamic Programming Medium

Given the integers zero, one, low, and high, we can construct a string by starting with an empty string, and then at each step perform either of the following:

Append the character '0' zero times.
Append the character '1' one times.

This can be performed any number of times.

A good string is a string constructed by the above process having a length between low and high (inclusive).

Return the number of different good strings that can be constructed satisfying these properties. Since the answer can be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: zero = 1, one = 1, low = 2, high = 3

› Output: 12

💡 Note: We can build strings with the following ways: Length 2 has 4 ways (by adding two 1-character steps), Length 3 has 8 ways (by adding three 1-character steps). Total = 4 + 8 = 12 good strings.

Example 2 — Different Step Sizes

$ Input: zero = 2, one = 3, low = 6, high = 7

› Output: 5

💡 Note: Length 6: '000000' (3×zero), '000111' (zero+one), '111000' (one+zero). Length 7: '0000111' (zero+zero+one), '1110000' (one+zero+zero). Total = 5.

Example 3 — Single Valid Length

$ Input: zero = 1, one = 2, low = 3, high = 3

› Output: 2

💡 Note: Only length 3 is valid: '000' (3×zero), '011' (zero+one). Total = 2 good strings.

Constraints

1 ≤ zero, one ≤ 50
1 ≤ low ≤ high ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 f Meta 18 a Amazon 15

The key insight is that this is a dynamic programming problem where each string length can be reached by adding 'zero' zeros or 'one' ones to shorter strings. Best approach is bottom-up DP with Time: O(high), Space: O(high).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Bottom-Up Dynamic Programming

⏱️ Time: O(high) Space: O(high)

Use bottom-up approach with a DP array where dp[i] represents the number of ways to build strings of length i. Fill the array iteratively from smaller lengths to larger ones.

Memoized Recursion

⏱️ Time: O(high) Space: O(high)

Same recursive approach but store results for each length to avoid redundant calculations. This dramatically improves performance by eliminating overlapping subproblems.

Recursive Brute Force

⏱️ Time: O(2^(high/min(zero,one))) Space: O(high/min(zero,one))

Use recursion to explore all possible ways to build strings by adding 'zero' or 'one' characters at each step. Count strings when their length falls within [low, high] range.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>

int countGoodStrings(int zero, int one, int low, int high) {
    const int MOD = 1000000007;
    static int dp[100001];
    
    // Initialize dp array
    for (int i = 0; i <= high; i++) {
        dp[i] = 0;
    }
    dp[0] = 1;
    
    int result = 0;
    
    for (int i = 1; i <= high; i++) {
        if (i >= zero) {
            dp[i] = (dp[i] + dp[i - zero]) % MOD;
        }
        if (i >= one) {
            dp[i] = (dp[i] + dp[i - one]) % MOD;
        }
        if (i >= low) {
            result = (result + dp[i]) % MOD;
        }
    }
    
    return result;
}

int main() {
    int zero, one, low, high;
    scanf("%d %d %d %d", &zero, &one, &low, &high);
    
    int result = countGoodStrings(zero, one, low, high);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen