chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-14-2536-Increment-Submatrices-by-One/explanation.md

@@ -0,0 +1,35 @@
+# Increment Submatrices by One (Medium)
+
+**Problem ID:** 2536  
+**Date:** 2025-11-14  
+**Link:** https://leetcode.com/problems/increment-submatrices-by-one/
+
+## Approach
+
+To solve the problem of incrementing submatrices efficiently, we can utilize a technique known as the "2D difference array" approach. This method allows us to perform range updates in constant time, which is crucial given the constraints of the problem.
+
+### Approach:
+
+1. **Initialize a 2D Difference Array**:
+   - Create a 2D array `diff` of size `(n+1) x (n+1)` initialized to zero. This extra row and column help handle boundary conditions easily.
+
+2. **Process Each Query**:
+   - For each query defined by `query[i] = [row1, col1, row2, col2]`, we will update the `diff` array to mark the increments:
+     - Increment `diff[row1][col1]` by 1 to start adding 1 from the top-left corner of the submatrix.
+     - Decrement `diff[row1][col2 + 1]` by 1 to stop adding 1 after reaching the right edge of the submatrix.
+     - Decrement `diff[row2 + 1][col1]` by 1 to stop adding 1 after reaching the bottom edge of the submatrix.
+     - Increment `diff[row2 + 1][col2 + 1]` by 1 to correct the area that was double subtracted.
+
+3. **Build the Final Matrix**:
+   - After processing all queries, construct the resulting matrix `mat` from the `diff` array:
+     - Use a nested loop to calculate the prefix sums. The value at each position `(i, j)` in `mat` can be derived from the `diff` array by adding the current cell value and the values from the left and above cells in the `diff` array.
+
+### Data Structures:
+- A 2D difference array `diff` of size `(n+1) x (n+1)` is used to efficiently mark the increments.
+- The final result matrix `mat` of size `n x n` is constructed from the `diff` array.
+
+### Complexity:
+- **Time Complexity**: The time complexity for processing all queries is O(q), where q is the number of queries (up to 10,000). Constructing the final matrix takes O(n^2), leading to an overall complexity of O(n^2 + q).
+- **Space Complexity**: The space complexity is O(n^2) for the `diff` array and the resulting matrix `mat`.
+
+This approach ensures that we efficiently handle potentially large numbers of updates to the matrix without directly iterating through the submatrices for each query, which would be computationally expensive.

Medium/2025-11-14-2536-Increment-Submatrices-by-One/solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int[][] incrementSubmatrices(int n, int[][] queries) {
+        int[][] mat = new int[n][n];
+
+        for (int[] query : queries) {
+            int row1 = query[0], col1 = query[1], row2 = query[2], col2 = query[3];
+            for (int i = row1; i <= row2; i++) {
+                for (int j = col1; j <= col2; j++) {
+                    mat[i][j]++;
+                }
+            }
+        }
+
+        return mat;
+    }
+}

Medium/2025-11-14-2536-Increment-Submatrices-by-One/solution.js

@@ -0,0 +1,13 @@
+var incrementSubmatrices = function(n, queries) {
+    const mat = Array.from({ length: n }, () => Array(n).fill(0));
+
+    for (const [row1, col1, row2, col2] of queries) {
+        for (let i = row1; i <= row2; i++) {
+            for (let j = col1; j <= col2; j++) {
+                mat[i][j]++;
+            }
+        }
+    }
+
+    return mat;
+};

Medium/2025-11-14-2536-Increment-Submatrices-by-One/solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def incrementSubmatrices(self, n: int, queries: List[List[int]]) -> List[List[int]]:
+        mat = [[0] * n for _ in range(n)]
+        
+        for row1, col1, row2, col2 in queries:
+            for i in range(row1, row2 + 1):
+                for j in range(col1, col2 + 1):
+                    mat[i][j] += 1
+        
+        return mat

README.md

@@ -278,3 +278,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-11-11 — [Ones and Zeroes](https://leetcode.com/problems/ones-and-zeroes/) (Medium) → `Medium/2025-11-11-474-Ones-and-Zeroes`
 - 2025-11-12 — [Minimum Number of Operations to Make All Array Elements Equal to 1](https://leetcode.com/problems/minimum-number-of-operations-to-make-all-array-elements-equal-to-1/) (Medium) → `Medium/2025-11-12-2654-Minimum-Number-of-Operations-to-Make-All-Array-Elements-Equal-to-1`
 - 2025-11-13 — [Maximum Number of Operations to Move Ones to the End](https://leetcode.com/problems/maximum-number-of-operations-to-move-ones-to-the-end/) (Medium) → `Medium/2025-11-13-3228-Maximum-Number-of-Operations-to-Move-Ones-to-the-End`
+- 2025-11-14 — [Increment Submatrices by One](https://leetcode.com/problems/increment-submatrices-by-one/) (Medium) → `Medium/2025-11-14-2536-Increment-Submatrices-by-One`