chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-03-02-1536-Minimum-Swaps-to-Arrange-a-Binary-Grid/explanation.md

@@ -0,0 +1,31 @@
+# Minimum Swaps to Arrange a Binary Grid (Medium)
+
+**Problem ID:** 1536  
+**Date:** 2026-03-02  
+**Link:** https://leetcode.com/problems/minimum-swaps-to-arrange-a-binary-grid/
+
+## Approach
+
+To solve the problem of finding the minimum number of swaps needed to arrange a binary grid such that all cells above the main diagonal are zeros, we can follow these steps:
+
+### Main Idea:
+The key to solving this problem is to recognize that for each row in the grid, we need to determine how many zeros are at the end of the row. This will help us identify how many rows can be swapped to achieve the desired configuration.
+
+### Approach:
+1. **Count Trailing Zeros**: For each row in the grid, count the number of trailing zeros. This count will determine how far down the row can be moved to achieve a valid configuration. Store these counts in a list.
+
+2. **Determine Valid Rows**: Starting from the top row (index 0) to the bottom row (index n-1), for each row `i`, we need to ensure that there are at least `n - i - 1` zeros available in the rows below it (including itself). This is because for row `i`, we need `n - i - 1` zeros to fill the positions above the main diagonal.
+
+3. **Greedy Swapping**: For each row `i`, find the first row `j` (where `j >= i`) that has enough trailing zeros to satisfy the requirement. If such a row is found, we can swap it to the `i`th position. Count the number of swaps required to bring this row to the `i`th position. If no such row exists, it means it's impossible to make the grid valid, and we return -1.
+
+4. **Repeat**: Continue this process for each row until either the grid is valid or it is determined that it cannot be made valid.
+
+### Data Structures:
+- An array (or list) to store the count of trailing zeros for each row.
+- A loop to iterate through the rows and perform the necessary checks and swaps.
+
+### Complexity:
+- **Time Complexity**: O(n^2) in the worst case, where `n` is the number of rows (or columns) in the grid. This is due to the nested iteration to find rows with sufficient trailing zeros.
+- **Space Complexity**: O(n) for storing the counts of trailing zeros.
+
+By following this structured approach, we can efficiently determine the minimum number of swaps required to make the binary grid valid or conclude that it is impossible.

Medium/2026-03-02-1536-Minimum-Swaps-to-Arrange-a-Binary-Grid/solution.java

@@ -0,0 +1,37 @@
+class Solution {
+    public int minSwaps(int[][] grid) {
+        int n = grid.length;
+        int[] zerosCount = new int[n];
+        
+        for (int i = 0; i < n; i++) {
+            int count = 0;
+            for (int j = n - 1; j >= 0; j--) {
+                if (grid[i][j] == 0) {
+                    count++;
+                } else {
+                    break;
+                }
+            }
+            zerosCount[i] = count;
+        }
+
+        int swaps = 0;
+        for (int i = 0; i < n; i++) {
+            int requiredZeros = n - 1 - i;
+            int j = i;
+            while (j < n && zerosCount[j] < requiredZeros) {
+                j++;
+            }
+            if (j == n) {
+                return -1;
+            }
+            for (int k = j; k > i; k--) {
+                int temp = zerosCount[k];
+                zerosCount[k] = zerosCount[k - 1];
+                zerosCount[k - 1] = temp;
+                swaps++;
+            }
+        }
+        return swaps;
+    }
+}

Medium/2026-03-02-1536-Minimum-Swaps-to-Arrange-a-Binary-Grid/solution.js

@@ -0,0 +1,33 @@
+var minSwaps = function(grid) {
+    const n = grid.length;
+    const zeros = new Array(n).fill(0);
+    
+    for (let i = 0; i < n; i++) {
+        let count = 0;
+        for (let j = n - 1; j >= 0; j--) {
+            if (grid[i][j] === 0) count++;
+            else break;
+        }
+        zeros[i] = count;
+    }
+    
+    let swaps = 0;
+    
+    for (let i = 0; i < n; i++) {
+        let required = n - 1 - i;
+        let j = i;
+        
+        while (j < n && zeros[j] < required) {
+            j++;
+        }
+        
+        if (j === n) return -1;
+        
+        for (let k = j; k > i; k--) {
+            [zeros[k], zeros[k - 1]] = [zeros[k - 1], zeros[k]];
+            swaps++;
+        }
+    }
+    
+    return swaps;
+};

Medium/2026-03-02-1536-Minimum-Swaps-to-Arrange-a-Binary-Grid/solution.py

@@ -0,0 +1,24 @@
+class Solution:
+    def minSwaps(self, grid: List[List[int]]) -> int:
+        n = len(grid)
+        zeros_needed = [0] * n
+        
+        for i in range(n):
+            count = 0
+            for j in range(n):
+                if grid[i][j] == 0:
+                    count += 1
+            zeros_needed[i] = count
+        
+        swaps = 0
+        for i in range(n):
+            if zeros_needed[i] < n - 1 - i:
+                return -1
+            
+            for j in range(i, n):
+                if zeros_needed[j] >= n - 1 - i:
+                    swaps += j - i
+                    zeros_needed[i:j + 1] = [zeros_needed[j]] + zeros_needed[i:j]
+                    break
+        
+        return swaps

README.md

@@ -380,3 +380,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-02-27 — [Minimum Operations to Equalize Binary String](https://leetcode.com/problems/minimum-operations-to-equalize-binary-string/) (Hard) → `Hard/2026-02-27-3666-Minimum-Operations-to-Equalize-Binary-String`
 - 2026-02-28 — [Concatenation of Consecutive Binary Numbers](https://leetcode.com/problems/concatenation-of-consecutive-binary-numbers/) (Medium) → `Medium/2026-02-28-1680-Concatenation-of-Consecutive-Binary-Numbers`
 - 2026-03-01 — [Partitioning Into Minimum Number Of Deci-Binary Numbers](https://leetcode.com/problems/partitioning-into-minimum-number-of-deci-binary-numbers/) (Medium) → `Medium/2026-03-01-1689-Partitioning-Into-Minimum-Number-Of-Deci-Binary-Numbers`
+- 2026-03-02 — [Minimum Swaps to Arrange a Binary Grid](https://leetcode.com/problems/minimum-swaps-to-arrange-a-binary-grid/) (Medium) → `Medium/2026-03-02-1536-Minimum-Swaps-to-Arrange-a-Binary-Grid`