chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Hard/2026-03-10-3130-Find-All-Possible-Stable-Binary-Arrays-II/explanation.md

@@ -0,0 +1,38 @@
+# Find All Possible Stable Binary Arrays II (Hard)
+
+**Problem ID:** 3130  
+**Date:** 2026-03-10  
+**Link:** https://leetcode.com/problems/find-all-possible-stable-binary-arrays-ii/
+
+## Approach
+
+To solve the problem of finding all possible stable binary arrays given the constraints on the number of zeros, ones, and the limit on subarray sizes, we can utilize a dynamic programming (DP) approach. 
+
+### Main Idea:
+The core idea is to build valid binary arrays by considering the placement of zeros and ones while adhering to the stability condition. A stable binary array must have exactly one '1', and any subarray longer than the specified limit must include both '0' and '1'. 
+
+### Dynamic Programming Approach:
+1. **State Definition**:
+   Define a DP table `dp[i][j]` where `i` represents the number of zeros used and `j` represents the number of ones used. The value `dp[i][j]` will store the number of valid stable binary arrays that can be formed with `i` zeros and `j` ones.
+
+2. **Initialization**:
+   Initialize `dp[0][1]` to 1, as the only stable array with no zeros and one '1' is `[1]`.
+
+3. **Transition**:
+   For each combination of zeros `i` and ones `j`, we can consider two cases:
+   - **Adding a '1'**: If we add a '1', we can only do this if we have not exceeded the limit on the number of zeros that can precede it. This means we can add a '1' after a certain number of zeros.
+   - **Adding a '0'**: When adding a '0', we need to ensure that it does not violate the stability condition. Specifically, if we add a '0', we must ensure that the last segment of the array (of size greater than the limit) contains at least one '1'.
+
+   The transition can be calculated based on previously computed states, ensuring that we respect the limit condition. 
+
+4. **Final Calculation**:
+   The result will be the sum of all valid configurations stored in `dp[zero][1]` for varying numbers of zeros, ensuring that we only consider configurations that include the required number of zeros and exactly one '1'.
+
+### Data Structures:
+- A 2D list (or array) `dp` to store the number of valid configurations for different counts of zeros and ones.
+
+### Complexity:
+The time complexity of this approach is O(zero * one), where `zero` and `one` are the counts of zeros and ones respectively. This is due to the nested loops iterating through possible counts of zeros and ones. The space complexity is also O(zero * one) for storing the DP table.
+
+### Conclusion:
+By leveraging dynamic programming, we can efficiently count the number of valid stable binary arrays while adhering to the constraints provided. This method ensures that we explore all configurations systematically and avoids redundant calculations through memoization.

Hard/2026-03-10-3130-Find-All-Possible-Stable-Binary-Arrays-II/solution.java

@@ -0,0 +1,24 @@
+class Solution {
+    private static final int MOD = 1000000007;
+
+    public int countStableArrays(int zero, int one, int limit) {
+        long[][] dp = new long[zero + 1][one + 1];
+        dp[0][1] = 1; // Base case: one way to have one '1' and no '0's
+
+        for (int z = 0; z <= zero; z++) {
+            for (int o = 0; o <= one; o++) {
+                if (z > 0) {
+                    dp[z][o] = (dp[z][o] + dp[z - 1][o]) % MOD; // Adding a '0'
+                }
+                if (o > 0) {
+                    dp[z][o] = (dp[z][o] + dp[z][o - 1]) % MOD; // Adding a '1'
+                }
+                if (z > 0 && o > 0 && z + o > limit) {
+                    dp[z][o] = (dp[z][o] - dp[Math.max(0, z - limit)][o] + MOD) % MOD; // Removing invalid cases
+                }
+            }
+        }
+
+        return (int) dp[zero][one];
+    }
+}

Hard/2026-03-10-3130-Find-All-Possible-Stable-Binary-Arrays-II/solution.js

@@ -0,0 +1,27 @@
+const MOD = 1e9 + 7;
+
+var countStableArrays = function(zero, one, limit) {
+    const dp = Array.from({ length: zero + 1 }, () => Array(one + 1).fill(0));
+    dp[0][1] = 1; // Base case: one way to have one '1' and no '0's
+
+    for (let z = 0; z <= zero; z++) {
+        for (let o = 0; o <= one; o++) {
+            if (z > 0) {
+                dp[z][o] = (dp[z][o] + dp[z - 1][o]) % MOD; // Add a '0'
+            }
+            if (o > 1) {
+                dp[z][o] = (dp[z][o] + dp[z][o - 1]) % MOD; // Add a '1'
+            }
+            if (z > 0 && o > 0 && z + o > limit) {
+                dp[z][o] = (dp[z][o] - dp[z - 1][o - 1] + MOD) % MOD; // Remove invalid cases
+            }
+        }
+    }
+
+    let result = 0;
+    for (let z = 0; z <= zero; z++) {
+        result = (result + dp[z][one]) % MOD;
+    }
+
+    return result;
+};

Hard/2026-03-10-3130-Find-All-Possible-Stable-Binary-Arrays-II/solution.py

@@ -0,0 +1,23 @@
+class Solution:
+    def countStableArrays(self, zero: int, one: int, limit: int) -> int:
+        MOD = 10**9 + 7
+        
+        dp = [[0] * (one + 1) for _ in range(zero + 1)]
+        dp[0][1] = 1  # Base case: one way to have a single 1
+        
+        for z in range(zero + 1):
+            for o in range(1, one + 1):
+                if z > 0:
+                    dp[z][o] = (dp[z][o] + dp[z - 1][o]) % MOD
+                if o > 1:
+                    dp[z][o] = (dp[z][o] + dp[z][o - 1]) % MOD
+                if z > 0 and o > 1 and z + o > limit:
+                    dp[z][o] = (dp[z][o] - dp[z - 1][o - 1] + MOD) % MOD
+        
+        return dp[zero][one]
+
+# Example usage:
+# sol = Solution()
+# print(sol.countStableArrays(1, 1, 2))  # Output: 2
+# print(sol.countStableArrays(1, 2, 1))  # Output: 1
+# print(sol.countStableArrays(3, 3, 2))  # Output: 14

README.md

@@ -388,3 +388,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-03-07 — [Minimum Number of Flips to Make the Binary String Alternating](https://leetcode.com/problems/minimum-number-of-flips-to-make-the-binary-string-alternating/) (Medium) → `Medium/2026-03-07-1888-Minimum-Number-of-Flips-to-Make-the-Binary-String-Alternating`
 - 2026-03-08 — [Find Unique Binary String](https://leetcode.com/problems/find-unique-binary-string/) (Medium) → `Medium/2026-03-08-1980-Find-Unique-Binary-String`
 - 2026-03-09 — [Find All Possible Stable Binary Arrays I](https://leetcode.com/problems/find-all-possible-stable-binary-arrays-i/) (Medium) → `Medium/2026-03-09-3129-Find-All-Possible-Stable-Binary-Arrays-I`
+- 2026-03-10 — [Find All Possible Stable Binary Arrays II](https://leetcode.com/problems/find-all-possible-stable-binary-arrays-ii/) (Hard) → `Hard/2026-03-10-3130-Find-All-Possible-Stable-Binary-Arrays-II`