We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Find All Possible Stable Binary Arrays II

Difficulty: Hard

Problem Description

You are given 3 positive integers zero, one, and limit. A binary array arr is called stable if:

  • The number of occurrences of 0 in arr is exactly zero.
  • The number of occurrences of 1 in arr is exactly one.
  • Each subarray of arr with a size greater than limit must contain both 0 and 1.

Return the total number of stable binary arrays. Since the answer may be very large, return it modulo 10^9 + 7.

Key Insights

  • A valid stable binary array must have zero number of 0s and one number of 1s.
  • The placement of 0s and 1s must ensure that any subarray larger than limit contains at least one 0 and one 1.
  • Dynamic programming can be leveraged to count the number of valid configurations of the array.

Space and Time Complexity

Time Complexity: O(zero * one)
Space Complexity: O(zero + one)

Solution

We can use dynamic programming to solve this problem. We define a DP table where dp[i][j] represents the number of ways to arrange i 0s and j 1s such that the stability condition is met. The key steps include:

  1. Iterating through all possible counts of 0s and 1s.
  2. Using combinatorial logic to place 0s and 1s while ensuring the subarray condition is satisfied.
  3. Applying modulo 10^9 + 7 to handle large numbers.

Code Solutions

def countStableArrays(zero: int, one: int, limit: int) -> int:
    MOD = 10**9 + 7
    dp = [[0] * (one + 1) for _ in range(zero + 1)]
    
    # Base case
    dp[0][0] = 1
    
    for i in range(zero + 1):
        for j in range(one + 1):
            # Skip the base case
            if i == 0 and j == 0:
                continue
            
            # Consider placing a 0
            if i > 0:
                dp[i][j] = dp[i-1][j] * (j + 1) % MOD
            
            # Consider placing a 1
            if j > 0:
                dp[i][j] = (dp[i][j] + dp[i][j-1] * (i + 1)) % MOD
            
            # Ensure the limit condition
            if i + j > limit:
                dp[i][j] = (dp[i][j] - dp[max(i - limit, 0)][j] + MOD) % MOD
                dp[i][j] = (dp[i][j] - dp[i][max(j - limit, 0)] + MOD) % MOD
    
    return dp[zero][one]

# Example usage
result = countStableArrays(3, 3, 2)
print(result)  # Output: 14
← Back to All Questions