chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-01-19-1292-Maximum-Side-Length-of-a-Square-with-Sum-Less-than-or-Equal-to-Threshold/explanation.md

@@ -0,0 +1,36 @@
+# Maximum Side Length of a Square with Sum Less than or Equal to Threshold (Medium)
+
+**Problem ID:** 1292  
+**Date:** 2026-01-19  
+**Link:** https://leetcode.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold/
+
+## Approach
+
+To solve the problem of finding the maximum side length of a square with a sum less than or equal to a given threshold in a matrix, we can employ a combination of prefix sums and binary search.
+
+### Approach:
+
+1. **Prefix Sum Calculation**:
+   - First, we create a prefix sum matrix that allows us to compute the sum of any sub-square in constant time. The prefix sum at position `(i, j)` represents the sum of all elements in the sub-matrix from the top-left corner `(0, 0)` to `(i, j)`.
+   - The prefix sum can be computed using the formula:
+     \[
+     \text{prefix}[i][j] = \text{mat}[i][j] + \text{prefix}[i-1][j] + \text{prefix}[i][j-1] - \text{prefix}[i-1][j-1]
+     \]
+   - This allows us to efficiently calculate the sum of any square sub-matrix.
+
+2. **Binary Search for Maximum Side Length**:
+   - We can use binary search to determine the largest possible side length `k` for which we can find a square of size `k x k` with a sum less than or equal to the threshold.
+   - The search range for `k` is from `0` to `min(m, n)` (the dimensions of the matrix).
+
+3. **Checking Validity of Side Length**:
+   - For each candidate side length `k`, we iterate over all possible top-left corners of `k x k` squares in the matrix. For each position `(i, j)`, we calculate the sum of the square using the prefix sum matrix.
+   - If the sum is less than or equal to the threshold, we can consider `k` as a valid side length.
+
+4. **Complexity**:
+   - The prefix sum computation takes \(O(m \times n)\).
+   - The binary search runs in \(O(\log(\min(m, n)))\) iterations.
+   - For each iteration of the binary search, checking all possible squares of size `k` requires \(O((m-k+1) \times (n-k+1))\), which in the worst case can be approximated as \(O(m \times n)\).
+   - Thus, the overall time complexity is \(O(m \times n \log(\min(m, n)))\).
+
+### Summary:
+The main idea is to utilize a prefix sum matrix to facilitate quick sum calculations of square sub-matrices and to apply binary search to efficiently find the maximum side length of a square that meets the sum constraint. This approach balances preprocessing with efficient querying, making it suitable for the problem's constraints.

Medium/2026-01-19-1292-Maximum-Side-Length-of-a-Square-with-Sum-Less-than-or-Equal-to-Threshold/solution.java

@@ -0,0 +1,35 @@
+class Solution {
+    public int maxSideLength(int[][] mat, int threshold) {
+        int m = mat.length, n = mat[0].length;
+        int[][] prefixSum = new int[m + 1][n + 1];
+
+        // Calculate prefix sums
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                prefixSum[i][j] = mat[i - 1][j - 1] 
+                                 + prefixSum[i - 1][j] 
+                                 + prefixSum[i][j - 1] 
+                                 - prefixSum[i - 1][j - 1];
+            }
+        }
+
+        int maxSide = 0;
+
+        // Check for the maximum side length of the square
+        for (int side = 1; side <= Math.min(m, n); side++) {
+            for (int i = side; i <= m; i++) {
+                for (int j = side; j <= n; j++) {
+                    int total = prefixSum[i][j] 
+                              - prefixSum[i - side][j] 
+                              - prefixSum[i][j - side] 
+                              + prefixSum[i - side][j - side];
+                    if (total <= threshold) {
+                        maxSide = side;
+                    }
+                }
+            }
+        }
+
+        return maxSide;
+    }
+}

Medium/2026-01-19-1292-Maximum-Side-Length-of-a-Square-with-Sum-Less-than-or-Equal-to-Threshold/solution.js

@@ -0,0 +1,36 @@
+var maxSideLength = function(mat, threshold) {
+    const m = mat.length, n = mat[0].length;
+    const prefixSum = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            prefixSum[i][j] = mat[i - 1][j - 1] + prefixSum[i - 1][j] + prefixSum[i][j - 1] - prefixSum[i - 1][j - 1];
+        }
+    }
+    
+    let left = 0, right = Math.min(m, n);
+    
+    while (left < right) {
+        const mid = Math.floor((left + right + 1) / 2);
+        let found = false;
+        
+        for (let i = mid; i <= m; i++) {
+            for (let j = mid; j <= n; j++) {
+                const sum = prefixSum[i][j] - prefixSum[i - mid][j] - prefixSum[i][j - mid] + prefixSum[i - mid][j - mid];
+                if (sum <= threshold) {
+                    found = true;
+                    break;
+                }
+            }
+            if (found) break;
+        }
+        
+        if (found) {
+            left = mid;
+        } else {
+            right = mid - 1;
+        }
+    }
+    
+    return left;
+};

Medium/2026-01-19-1292-Maximum-Side-Length-of-a-Square-with-Sum-Less-than-or-Equal-to-Threshold/solution.py

@@ -0,0 +1,34 @@
+class Solution:
+    def maxSideLength(self, mat: List[List[int]], threshold: int) -> int:
+        m, n = len(mat), len(mat[0])
+        prefix_sum = [[0] * (n + 1) for _ in range(m + 1)]
+        
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                prefix_sum[i][j] = mat[i - 1][j - 1] + prefix_sum[i - 1][j] + prefix_sum[i][j - 1] - prefix_sum[i - 1][j - 1]
+        
+        def get_sum(x1, y1, x2, y2):
+            return prefix_sum[x2 + 1][y2 + 1] - prefix_sum[x1][y2 + 1] - prefix_sum[x2 + 1][y1] + prefix_sum[x1][y1]
+        
+        left, right = 0, min(m, n)
+        result = 0
+        
+        while left <= right:
+            mid = (left + right) // 2
+            found = False
+            
+            for i in range(m - mid + 1):
+                for j in range(n - mid + 1):
+                    if get_sum(i, j, i + mid - 1, j + mid - 1) <= threshold:
+                        found = True
+                        break
+                if found:
+                    break
+            
+            if found:
+                result = mid
+                left = mid + 1
+            else:
+                right = mid - 1
+        
+        return result

README.md

@@ -338,3 +338,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-01-16 — [Maximum Square Area by Removing Fences From a Field](https://leetcode.com/problems/maximum-square-area-by-removing-fences-from-a-field/) (Medium) → `Medium/2026-01-16-2975-Maximum-Square-Area-by-Removing-Fences-From-a-Field`
 - 2026-01-17 — [Find the Largest Area of Square Inside Two Rectangles](https://leetcode.com/problems/find-the-largest-area-of-square-inside-two-rectangles/) (Medium) → `Medium/2026-01-17-3047-Find-the-Largest-Area-of-Square-Inside-Two-Rectangles`
 - 2026-01-18 — [Largest Magic Square](https://leetcode.com/problems/largest-magic-square/) (Medium) → `Medium/2026-01-18-1895-Largest-Magic-Square`
+- 2026-01-19 — [Maximum Side Length of a Square with Sum Less than or Equal to Threshold](https://leetcode.com/problems/maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold/) (Medium) → `Medium/2026-01-19-1292-Maximum-Side-Length-of-a-Square-with-Sum-Less-than-or-Equal-to-Threshold`