Find All Possible Stable Binary Arrays I - Practice Coding Problems

Find All Possible Stable Binary Arrays I - Problem

You are tasked with counting the number of stable binary arrays that can be constructed given specific constraints.

Given three positive integers zero, one, and limit, you need to find how many different binary arrays satisfy these conditions:

The array contains exactly zero occurrences of digit 0
The array contains exactly one occurrences of digit 1
No subarray longer than limit can consist entirely of the same digit (ensuring balance)

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

Return the count modulo 10⁹ + 7 since the result can be extremely large.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: Two valid arrays: [0,1] and [1,0]. Both have exactly 1 zero and 1 one, and no consecutive runs exceed limit=2.

example_2.py — Multiple Options

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

› Output: 0

💡 Note: Need exactly 1 zero and 3 ones, but limit=1 means no consecutive identical elements. Impossible to place 3 ones without violating the constraint.

example_3.py — Higher Limit

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

› Output: 6

💡 Note: Valid arrangements: [0,0,1,1], [0,1,0,1], [0,1,1,0], [1,0,0,1], [1,0,1,0], [1,1,0,0]. All satisfy the consecutive constraint with limit=3.

Visualization

Tap to expand

Understanding the Visualization

Start Fresh

Begin with empty array, knowing we need exactly 'zero' 0s and 'one' 1s

Make Choices

At each position, decide whether to place 0 or 1 based on remaining quota

Check Constraints

Ensure we don't exceed 'limit' consecutive identical elements

Count Valid Paths

Sum all possible ways to complete the array satisfying all conditions

Key Takeaway

🎯 Key Insight: By tracking state (remaining elements, last placed, consecutive count) we can count valid arrangements without explicitly generating them, achieving optimal O(zero × one × limit) complexity.

Time & Space Complexity

Time Complexity

⏱️

O(zero × one × limit)

Each unique state (zeros_left, ones_left, last_element, consecutive) is computed once

✓ Linear Growth

Space Complexity

O(zero × one × limit)

Memoization table stores results for all possible states

⚡ Linearithmic Space

Constraints

1 ≤ zero, one ≤ 1000
1 ≤ limit ≤ zero + one
The answer should be returned modulo 10⁹ + 7

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses dynamic programming with memoization to count valid stable binary arrays. The key insight is tracking the state as (remaining_zeros, remaining_ones, last_element, consecutive_count) and building the count incrementally rather than generating actual arrays. Time complexity: O(zero × one × limit).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(zero × one × limit)	O(zero × one × limit)	Use memoized recursion to count valid arrangements efficiently

Dynamic Programming with Memoization — Algorithm Steps

Define DP state: dp(zeros_left, ones_left, last_element, consecutive_count)
Base case: when zeros_left = ones_left = 0, return 1 (valid arrangement found)
For each state, try placing 0 or 1 based on remaining counts and consecutive constraint
Use memoization to avoid recalculating the same states
Sum all valid paths and return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with dp(2,2,-1,0) - need 2 zeros, 2 ones

First Decisions

Choose to place 0 or 1 as first element

State Transitions

Each choice updates remaining counts and consecutive tracking

Memoization

Store computed results to avoid redundant calculations

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXSIZE 10000

typedef struct {
    char key[50];
    long long value;
} HashEntry;

HashEntry memo[MAXSIZE];
int memoSize = 0;

long long findMemo(const char* key) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(const char* key, long long value) {
    if (memoSize < MAXSIZE) {
        strcpy(memo[memoSize].key, key);
        memo[memoSize].value = value;
        memoSize++;
    }
}

long long dp(int zerosLeft, int onesLeft, int lastDigit, int consecutive, int limit) {
    if (zerosLeft == 0 && onesLeft == 0) {
        return 1;
    }
    
    if (zerosLeft < 0 || onesLeft < 0) {
        return 0;
    }
    
    char state[50];
    sprintf(state, "%d,%d,%d,%d", zerosLeft, onesLeft, lastDigit, consecutive);
    
    long long cached = findMemo(state);
    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(state, result);
    return result;
}

long long numberOfStableArrays(int zero, int one, int limit) {
    memoSize = 0;
    return dp(zero, one, -1, 0, limit);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(zero × one × limit)

Each unique state (zeros_left, ones_left, last_element, consecutive) is computed once

✓ Linear Growth

Space Complexity

O(zero × one × limit)

Memoization table stores results for all possible states

⚡ Linearithmic Space

Constraints

1 ≤ zero, one ≤ 1000
1 ≤ limit ≤ zero + one
The answer should be returned modulo 10⁹ + 7

23.5K Views

Medium Frequency

~25 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 with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler