Find All Possible Stable Binary Arrays II

Find All Possible Stable Binary Arrays II - Problem

You are tasked with constructing stable binary arrays - a fascinating combinatorial problem that tests your dynamic programming skills!

Given three positive integers zero, one, and limit, you need to count how many different binary arrays can be formed that satisfy these conditions:

The array contains exactly zero occurrences of 0
The array contains exactly one occurrences of 1
No subarray of length greater than limit can contain only 0s or only 1s (this ensures stability)

The third condition is the key constraint - it prevents long streaks of consecutive identical digits, making the array "stable" by ensuring diversity in longer subsequences.

Return the total number of such stable binary arrays. Since this number can be astronomically large, return it modulo 10⁹ + 7.

Example: If zero=1, one=1, limit=2, valid arrays are [0,1] and [1,0], so the answer is 2.

Input & Output

example_1.py — Basic Case

$ Input: zero = 1, one = 1, limit = 2

› Output: 2

💡 Note: With 1 zero and 1 one, we can form arrays [0,1] and [1,0]. Both are stable since no subarray longer than limit=2 contains only one type of digit. Total: 2 valid arrays.

example_2.py — Longer Array

$ Input: zero = 1, one = 2, limit = 1

› Output: 1

💡 Note: With limit=1, no two consecutive digits can be the same. The only valid arrangement is [0,1,0] - we must alternate. Arrays like [1,1,0] are invalid because '11' exceeds the limit.

example_3.py — Higher Limit

$ Input: zero = 3, one = 3, limit = 2

› Output: 14

💡 Note: With limit=2, we can have at most 2 consecutive 0s or 1s. This allows many more arrangements than alternating, but still prevents long streaks like '000' or '111'.

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with an empty array and full quota of 0s and 1s

Make Valid Choices

At each position, choose 0 or 1 based on remaining quota and consecutive limit

Track Consecutive Count

Monitor how many consecutive identical digits we've placed

Use Memoization

Cache results for identical states to avoid redundant computation

Key Takeaway

🎯 Key Insight: Dynamic programming with state memoization transforms an exponential problem into a polynomial one by tracking only the essential information needed for future decisions.

Time & Space Complexity

Time Complexity

⏱️

O(zero × one × limit)

We have zero×one×2×limit possible states, each computed once

✓ Linear Growth

Space Complexity

O(zero × one × limit)

Memoization table stores results for all possible states

⚡ Linearithmic Space

Constraints

1 ≤ zero, one ≤ 200
1 ≤ limit ≤ 200
Answer must be returned modulo 10⁹ + 7
Array length will be zero + one

Asked in

G Google 28 a Amazon 15 f Meta 12 ⊞ Microsoft 8

The optimal solution uses dynamic programming with memoization to count stable binary arrays. We track states as (zeros_left, ones_left, last_digit, consecutive_count) and recursively explore valid placements of 0s and 1s while respecting the limit constraint. The key insight is that we only need to track the count of consecutive identical digits at the end of our current array, not the entire array structure. This reduces the problem to manageable subproblems with polynomial time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(zero × one × limit)	O(zero × one × limit)	Use memoized recursion to count valid arrangements efficiently
Brute Force (Generate All Arrays)	O((zero+one)! × (zero+one)²)	O((zero+one)!)	Generate all possible binary arrays and check stability condition

Dynamic Programming (Optimal) — Algorithm Steps

Define DP state: dp(zeros_left, ones_left, last_digit, consecutive_count)
Base case: when zeros_left = ones_left = 0, return 1 (valid complete array)
Recursive case: try placing 0 or 1, updating consecutive count
If consecutive count would exceed limit, skip that choice
Use memoization to cache results for identical states

Visualization

Tap to expand

Step-by-Step Walkthrough

Define States

Track (zeros_left, ones_left, last_digit, consecutive_count)

Explore Transitions

From each state, try placing 0 or 1 if valid

Memoize Results

Cache results to avoid recomputation

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MOD 1000000007
#define MAX_STATES 1000000

typedef struct {
    int zerosLeft, onesLeft, lastDigit, consecutive;
    long long result;
} State;

State memo[MAX_STATES];
int memoCount = 0;

long long findMemo(int zerosLeft, int onesLeft, int lastDigit, int consecutive) {
    for (int i = 0; i < memoCount; i++) {
        if (memo[i].zerosLeft == zerosLeft && memo[i].onesLeft == onesLeft &&
            memo[i].lastDigit == lastDigit && memo[i].consecutive == consecutive) {
            return memo[i].result;
        }
    }
    return -1;
}

void addMemo(int zerosLeft, int onesLeft, int lastDigit, int consecutive, long long result) {
    if (memoCount < MAX_STATES) {
        memo[memoCount].zerosLeft = zerosLeft;
        memo[memoCount].onesLeft = onesLeft;
        memo[memoCount].lastDigit = lastDigit;
        memo[memoCount].consecutive = consecutive;
        memo[memoCount].result = result;
        memoCount++;
    }
}

long long dp(int zerosLeft, int onesLeft, int lastDigit, int consecutive, int limit) {
    if (zerosLeft == 0 && onesLeft == 0) {
        return 1;
    }
    
    long long cached = findMemo(zerosLeft, onesLeft, lastDigit, consecutive);
    if (cached != -1) {
        return cached;
    }
    
    long long result = 0;
    
    // Try placing a 0
    if (zerosLeft > 0) {
        if (lastDigit == 0) {
            if (consecutive < limit) {
                result = (result + dp(zerosLeft - 1, onesLeft, 0, consecutive + 1, limit)) % MOD;
            }
        } else {
            result = (result + dp(zerosLeft - 1, onesLeft, 0, 1, limit)) % MOD;
        }
    }
    
    // Try placing a 1
    if (onesLeft > 0) {
        if (lastDigit == 1) {
            if (consecutive < limit) {
                result = (result + dp(zerosLeft, onesLeft - 1, 1, consecutive + 1, limit)) % MOD;
            }
        } else {
            result = (result + dp(zerosLeft, onesLeft - 1, 1, 1, limit)) % MOD;
        }
    }
    
    addMemo(zerosLeft, onesLeft, lastDigit, consecutive, result);
    return result;
}

int numberOfStableArrays(int zero, int one, int limit) {
    memoCount = 0;
    
    long long total = 0;
    
    if (zero > 0) {
        total = (total + dp(zero - 1, one, 0, 1, limit)) % MOD;
    }
    if (one > 0) {
        total = (total + dp(zero, one - 1, 1, 1, limit)) % MOD;
    }
    
    return (int) total;
}

int main() {
    int zero, one, limit;
    scanf("%d %d %d", &zero, &one, &limit);
    printf("%d\n", numberOfStableArrays(zero, one, limit));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(zero × one × limit)

We have zero×one×2×limit possible states, each computed once

✓ Linear Growth

Space Complexity

O(zero × one × limit)

Memoization table stores results for all possible states

⚡ Linearithmic Space

Constraints

1 ≤ zero, one ≤ 200
1 ≤ limit ≤ 200
Answer must be returned modulo 10⁹ + 7
Array length will be zero + one

26.5K Views

Medium Frequency

~35 min Avg. Time

847 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler