feat: add solutions for lc No.3888 (#5128)

Author: yanglbme

solution/2700-2799/2753.Count Houses in a Circular Street II/README_EN.md

@@ -36,7 +36,7 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/2700-2799/2753.Co
 <pre>
 <strong>Input:</strong> street = [1,1,1,1], k = 10
 <strong>Output:</strong> 4
-<strong>Explanation:</strong> There are 4 houses, and all their doors are open.
+<strong>Explanation:</strong> There are 4 houses, and all their doors are open. 
 The number of houses is less than k, which is 10.</pre>
 
 <p><strong class="example">Example 2:</strong></p>

solution/3800-3899/3888.Minimum Operations to Make All Grid Elements Equal/README.md

@@ -0,0 +1,365 @@
+---
+comments: true
+difficulty: 困难
+edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3888.Minimum%20Operations%20to%20Make%20All%20Grid%20Elements%20Equal/README.md
+---
+
+<!-- problem:start -->
+
+# [3888. Minimum Operations to Make All Grid Elements Equal 🔒](https://leetcode.cn/problems/minimum-operations-to-make-all-grid-elements-equal)
+
+[English Version](/solution/3800-3899/3888.Minimum%20Operations%20to%20Make%20All%20Grid%20Elements%20Equal/README_EN.md)
+
+## 题目描述
+
+<!-- description:start -->
+
+<p>You are given a 2D integer array <code>grid</code> of size <code>m &times; n</code>, and an integer <code>k</code>.</p>
+
+<p>In one operation, you can:</p>
+
+<ul>
+	<li>Select any <code>k x k</code> <strong>submatrix</strong> of <code>grid</code>, and</li>
+	<li>Increment <strong>all elements</strong> inside that <strong>submatrix</strong> by 1.</li>
+</ul>
+
+<p>Return the <strong>minimum</strong> number of operations required to make all elements in the grid <strong>equal</strong>. If it is not possible, return -1.</p>
+A submatrix <code>(x1, y1, x2, y2)</code> is a matrix that forms by choosing all cells <code>matrix[x][y]</code> where <code>x1 &lt;= x &lt;= x2</code> and <code>y1 &lt;= y &lt;= y2</code>.
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">grid = [[3,3,5],[3,3,5]], k = 2</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">2</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p data-end="266" data-start="150">Choose the left <code>2 x 2</code> submatrix (covering the first two columns) and apply the operation twice.</p>
+
+<ul>
+	<li>After 1 operation: <code>[[4, 4, 5], [4, 4, 5]]</code></li>
+	<li>After 2 operations: <code>[[5, 5, 5], [5, 5, 5]]</code></li>
+</ul>
+
+<p>All elements become equal to 5. Thus, the minimum number of operations is 2.</p>
+</div>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<div class="example-block">
+<p><strong>Input:</strong> <span class="example-io">grid = [[1,2],[2,3]], k = 1</span></p>
+
+<p><strong>Output:</strong> <span class="example-io">4</span></p>
+
+<p><strong>Explanation:</strong></p>
+
+<p>Since <code>k = 1</code>, each operation increments a single cell <code>grid[i][j]</code> by 1. To make all elements equal, the final value must be 3.</p>
+
+<ul>
+	<li>Increase <code>grid[0][0] = 1</code> to 3, requiring 2 operations.</li>
+	<li>Increase <code>grid[0][1] = 2</code> to 3, requiring 1 operation.</li>
+	<li>Increase <code>grid[1][0] = 2</code> to 3, requiring 1 operation.</li>
+</ul>
+
+<p>Thus, the minimum number of operations is <code>2 + 1 + 1 + 0 = 4</code>.</p>
+</div>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= m == grid.length &lt;= 1000</code></li>
+	<li><code>1 &lt;= n == grid[i].length &lt;= 1000</code></li>
+	<li><code>-10<sup>5</sup> &lt;= grid[i][j] &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= k &lt;= min(m, n)</code></li>
+</ul>
+
+<!-- description:end -->
+
+## 解法
+
+<!-- solution:start -->
+
+### 方法一：二维差分 + 贪心
+
+由于操作只能增加元素的值，因此最终网格的所有元素必须等于某个目标值 $T$，且 $T \ge \max(\textit{grid})$。
+
+从左上角 $(0, 0)$ 开始遍历网格。对于任意位置 $(i, j)$，如果它当前的数值小于 $T$，由于后续的操作（以更靠右或更靠下的位置为左上角的操作）都无法覆盖到 $(i, j)$，因此必须在当前位置执行 $T - \text{current\_val}$ 次以 $(i, j)$ 为左上角的 $k \times k$ 增加操作。
+
+如果每次执行操作都遍历 $k \times k$ 区域，复杂度将达到 $O(m \cdot n \cdot k^2)$。我们可以使用二维差分数组 $\textit{diff}$ 来记录操作。通过实时维护 $\textit{diff}$ 的二维前缀和，我们可以在 $O(1)$ 时间内获取当前位置的累计增量，并在 $O(1)$ 时间内更新一个 $k \times k$ 区域的未来影响。
+
+通常情况下 $T = \max(\textit{grid})$ 即可。但在某些 $k \times k$ 覆盖重叠的情况下，较小的 $T$ 可能导致中间位置被动增加后超过 $T$。根据数学一致性，若 $T = \max(\textit{grid})$ 和 $T = \max(\textit{grid}) + 1$ 均不可行，则该网格无法通过 $k \times k$ 操作变平。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$，其中 $m$ 和 $n$ 分别是网格的行数和列数。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minOperations(self, grid: list[list[int]], k: int) -> int:
+        m, n = len(grid), len(grid[0])
+        mx = max(max(row) for row in grid)
+
+        def check(target: int) -> int:
+            diff = [[0] * (n + 2) for _ in range(m + 2)]
+            total_ops = 0
+
+            for i, row in enumerate(grid, 1):
+                for j, val in enumerate(row, 1):
+                    diff[i][j] += diff[i - 1][j] + diff[i][j - 1] - diff[i - 1][j - 1]
+
+                    cur_val = val + diff[i][j]
+
+                    if cur_val > target:
+                        return -1
+
+                    if cur_val < target:
+                        if i + k - 1 > m or j + k - 1 > n:
+                            return -1
+
+                        needed = target - cur_val
+                        total_ops += needed
+                        diff[i][j] += needed
+                        diff[i + k][j] -= needed
+                        diff[i][j + k] -= needed
+                        diff[i + k][j + k] += needed
+            return total_ops
+
+        for t in range(mx, mx + 2):
+            res = check(t)
+            if res != -1:
+                return res
+
+        return -1
+```
+
+#### Java
+
+```java
+class Solution {
+    int[][] grid;
+    int m, n, k;
+
+    public long minOperations(int[][] grid, int k) {
+        this.grid = grid;
+        this.k = k;
+        this.m = grid.length;
+        this.n = grid[0].length;
+
+        int mx = Integer.MIN_VALUE;
+        for (int[] row : grid) {
+            for (int v : row) {
+                mx = Math.max(mx, v);
+            }
+        }
+
+        for (int t = mx; t <= mx + 1; t++) {
+            long res = check(t);
+            if (res != -1) {
+                return res;
+            }
+        }
+        return -1;
+    }
+
+    private long check(int target) {
+        long[][] diff = new long[m + 2][n + 2];
+        long totalOps = 0;
+
+        for (int i = 1; i <= m; i++) {
+            for (int j = 1; j <= n; j++) {
+                diff[i][j] += diff[i - 1][j] + diff[i][j - 1] - diff[i - 1][j - 1];
+                long cur = grid[i - 1][j - 1] + diff[i][j];
+
+                if (cur > target) {
+                    return -1;
+                }
+
+                if (cur < target) {
+                    if (i + k - 1 > m || j + k - 1 > n) {
+                        return -1;
+                    }
+
+                    long need = target - cur;
+                    totalOps += need;
+
+                    diff[i][j] += need;
+                    diff[i + k][j] -= need;
+                    diff[i][j + k] -= need;
+                    diff[i + k][j + k] += need;
+                }
+            }
+        }
+        return totalOps;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    long long minOperations(vector<vector<int>>& grid, int k) {
+        int m = grid.size();
+        int n = grid[0].size();
+        int mx = grid[0][0];
+        for (auto& row : grid) {
+            for (int val : row) {
+                mx = max(mx, val);
+            }
+        }
+
+        auto check = [&](int target) -> long long {
+            vector<vector<long long>> diff(m + 2, vector<long long>(n + 2, 0));
+            long long total_ops = 0;
+
+            for (int i = 1; i <= m; ++i) {
+                for (int j = 1; j <= n; ++j) {
+                    diff[i][j] += diff[i - 1][j] + diff[i][j - 1] - diff[i - 1][j - 1];
+                    long long cur_val = grid[i - 1][j - 1] + diff[i][j];
+
+                    if (cur_val > target) {
+                        return -1;
+                    }
+
+                    if (cur_val < target) {
+                        if (i + k - 1 > m || j + k - 1 > n) {
+                            return -1;
+                        }
+
+                        long long needed = target - cur_val;
+                        total_ops += needed;
+                        diff[i][j] += needed;
+                        diff[i + k][j] -= needed;
+                        diff[i][j + k] -= needed;
+                        diff[i + k][j + k] += needed;
+                    }
+                }
+            }
+
+            return total_ops;
+        };
+
+        for (int t = mx; t <= mx + 1; ++t) {
+            long long res = check(t);
+            if (res != -1) {
+                return res;
+            }
+        }
+
+        return -1;
+    }
+};
+```
+
+#### Go
+
+```go
+func minOperations(grid [][]int, k int) int64 {
+	m, n := len(grid), len(grid[0])
+	maxVal := grid[0][0]
+	for _, row := range grid {
+		maxVal = max(maxVal, slices.Max(row))
+	}
+
+	check := func(target int) int64 {
+		diff := make([][]int64, m+2)
+		for i := range diff {
+			diff[i] = make([]int64, n+2)
+		}
+		var totalOps int64
+
+		for i := 1; i <= m; i++ {
+			for j := 1; j <= n; j++ {
+				diff[i][j] += diff[i-1][j] + diff[i][j-1] - diff[i-1][j-1]
+				curVal := int64(grid[i-1][j-1]) + diff[i][j]
+
+				if curVal > int64(target) {
+					return -1
+				}
+
+				if curVal < int64(target) {
+					if i+k-1 > m || j+k-1 > n {
+						return -1
+					}
+					needed := int64(target) - curVal
+					totalOps += needed
+					diff[i][j] += needed
+					diff[i+k][j] -= needed
+					diff[i][j+k] -= needed
+					diff[i+k][j+k] += needed
+				}
+			}
+		}
+		return totalOps
+	}
+
+	for t := maxVal; t <= maxVal+1; t++ {
+		if res := check(t); res != -1 {
+			return res
+		}
+	}
+
+	return -1
+}
+```
+
+#### TypeScript
+
+```ts
+function minOperations(grid: number[][], k: number): number {
+    const m = grid.length;
+    const n = grid[0].length;
+    let maxVal = grid[0][0];
+
+    for (const row of grid) {
+        for (const val of row) {
+            maxVal = Math.max(maxVal, val);
+        }
+    }
+
+    const check = (target: number): number => {
+        const diff: number[][] = Array.from({ length: m + 2 }, () => Array(n + 2).fill(0));
+        let totalOps = 0;
+
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                diff[i][j] += diff[i - 1][j] + diff[i][j - 1] - diff[i - 1][j - 1];
+                const curVal = grid[i - 1][j - 1] + diff[i][j];
+
+                if (curVal > target) return -1;
+
+                if (curVal < target) {
+                    if (i + k - 1 > m || j + k - 1 > n) return -1;
+
+                    const needed = target - curVal;
+                    totalOps += needed;
+                    diff[i][j] += needed;
+                    diff[i + k][j] -= needed;
+                    diff[i][j + k] -= needed;
+                    diff[i + k][j + k] += needed;
+                }
+            }
+        }
+
+        return totalOps;
+    };
+
+    for (let t = maxVal; t <= maxVal + 1; t++) {
+        const res = check(t);
+        if (res !== -1) return res;
+    }
+
+    return -1;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
+<!-- problem:end -->