feat: add solutions for lc No.3548 (#5108)

Author: yanglbme

solution/3500-3599/3548.Equal Sum Grid Partition II/README.md

@@ -116,32 +116,356 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：枚举分割线
+
+我们可以先枚举水平分割线，计算分割后两部分的元素和，并使用哈希表记录每个部分中元素的出现次数。
+
+对于每条分割线，我们需要判断两部分的元素和是否相等，或者是否可以通过移除一个单元格使它们相等。如果两部分的元素和相等，那么我们直接返回 $\text{true}$。如果两部分的元素和不相等，我们需要计算它们的差值 $\textit{diff}$，如果 $\textit{diff}$ 在较大部分的哈希表中存在，并且满足移除该单元格后两部分仍然连通的条件，那么我们也返回 $\text{true}$。
+
+连通性的判断可以通过以下条件来实现：
+
+- 该部分的行数大于 $1$ 且列数大于 $1$。
+- 该部分的行数等于 $1$，且移除的单元格位于该部分的边界（即第一列或最后一列）。
+- 该部分的行数等于 $1$，且移除的单元格位于该部分的边界（即第一行或最后一行）。
+
+满足上述条件之一即可保证移除单元格后该部分仍然连通。
+
+我们还需要枚举垂直分割线，方法与水平分割线类似。为了方便枚举垂直分割线，我们可以先对矩阵进行转置，然后使用相同的逻辑进行判断。
+
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def canPartitionGrid(self, grid: List[List[int]]) -> bool:
+        def check(g: List[List[int]]) -> bool:
+            m, n = len(g), len(g[0])
+            s1 = s2 = 0
+            cnt1 = defaultdict(int)
+            cnt2 = defaultdict(int)
+            for i, row in enumerate(g):
+                for j, x in enumerate(row):
+                    s2 += x
+                    cnt2[x] += 1
+            for i, row in enumerate(g[: m - 1]):
+                for x in row:
+                    s1 += x
+                    s2 -= x
+                    cnt1[x] += 1
+                    cnt2[x] -= 1
+                if s1 == s2:
+                    return True
+                if s1 < s2:
+                    diff = s2 - s1
+                    if cnt2[diff]:
+                        if (
+                            (m - i - 1 > 1 and n > 1)
+                            or (
+                                i == m - 2
+                                and (g[i + 1][0] == diff or g[i + 1][-1] == diff)
+                            )
+                            or (n == 1 and (g[i + 1][0] == diff or g[-1][0] == diff))
+                        ):
+                            return True
+                else:
+                    diff = s1 - s2
+                    if cnt1[diff]:
+                        if (
+                            (i + 1 > 1 and n > 1)
+                            or (i == 0 and (g[0][0] == diff or g[0][-1] == diff))
+                            or (n == 1 and (g[0][0] == diff or g[i][0] == diff))
+                        ):
+                            return True
+            return False
+
+        return check(grid) or check(list(zip(*grid)))
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public boolean canPartitionGrid(int[][] grid) {
+        return check(grid) || check(rotate(grid));
+    }
+
+    private boolean check(int[][] g) {
+        int m = g.length, n = g[0].length;
+        long s1 = 0, s2 = 0;
+
+        Map<Long, Integer> cnt1 = new HashMap<>();
+        Map<Long, Integer> cnt2 = new HashMap<>();
+
+        for (int[] row : g) {
+            for (int x : row) {
+                s2 += x;
+                cnt2.merge((long) x, 1, Integer::sum);
+            }
+        }
+
+        for (int i = 0; i < m - 1; i++) {
+            for (int x : g[i]) {
+                s1 += x;
+                s2 -= x;
+
+                cnt1.merge((long) x, 1, Integer::sum);
+                cnt2.merge((long) x, -1, Integer::sum);
+            }
+
+            if (s1 == s2) {
+                return true;
+            }
+
+            if (s1 < s2) {
+                long diff = s2 - s1;
+                if (cnt2.getOrDefault(diff, 0) > 0) {
+                    if ((m - i - 1 > 1 && n > 1)
+                        || (i == m - 2 && (g[i + 1][0] == diff || g[i + 1][n - 1] == diff))
+                        || (n == 1 && (g[i + 1][0] == diff || g[m - 1][0] == diff))) {
+                        return true;
+                    }
+                }
+            } else {
+                long diff = s1 - s2;
+                if (cnt1.getOrDefault(diff, 0) > 0) {
+                    if ((i + 1 > 1 && n > 1) || (i == 0 && (g[0][0] == diff || g[0][n - 1] == diff))
+                        || (n == 1 && (g[0][0] == diff || g[i][0] == diff))) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private int[][] rotate(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        int[][] t = new int[n][m];
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                t[j][i] = grid[i][j];
+            }
+        }
+        return t;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    bool canPartitionGrid(vector<vector<int>>& grid) {
+        return check(grid) || check(rotate(grid));
+    }
+
+private:
+    bool check(const vector<vector<int>>& g) {
+        int m = g.size(), n = g[0].size();
+        long long s1 = 0, s2 = 0;
+
+        unordered_map<long long, int> cnt1, cnt2;
+
+        for (auto& row : g) {
+            for (int x : row) {
+                s2 += x;
+                cnt2[x]++;
+            }
+        }
+
+        for (int i = 0; i < m - 1; i++) {
+            for (int x : g[i]) {
+                s1 += x;
+                s2 -= x;
+                cnt1[x]++;
+                cnt2[x]--;
+            }
+
+            if (s1 == s2) return true;
+
+            if (s1 < s2) {
+                long long diff = s2 - s1;
+                if (cnt2[diff] > 0) {
+                    if (
+                        (m - i - 1 > 1 && n > 1) || (i == m - 2 && (g[i + 1][0] == diff || g[i + 1][n - 1] == diff)) || (n == 1 && (g[i + 1][0] == diff || g[m - 1][0] == diff))) return true;
+                }
+            } else {
+                long long diff = s1 - s2;
+                if (cnt1[diff] > 0) {
+                    if (
+                        (i + 1 > 1 && n > 1) || (i == 0 && (g[0][0] == diff || g[0][n - 1] == diff)) || (n == 1 && (g[0][0] == diff || g[i][0] == diff))) return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    vector<vector<int>> rotate(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        vector<vector<int>> t(n, vector<int>(m));
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                t[j][i] = grid[i][j];
+            }
+        }
+        return t;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func canPartitionGrid(grid [][]int) bool {
+	return check(grid) || check(rotate(grid))
+}
+
+func check(g [][]int) bool {
+	m, n := len(g), len(g[0])
+	var s1, s2 int64
+
+	cnt1 := map[int64]int{}
+	cnt2 := map[int64]int{}
+
+	for _, row := range g {
+		for _, x := range row {
+			v := int64(x)
+			s2 += v
+			cnt2[v]++
+		}
+	}
+
+	for i := 0; i < m-1; i++ {
+		for _, x := range g[i] {
+			v := int64(x)
+			s1 += v
+			s2 -= v
+			cnt1[v]++
+			cnt2[v]--
+		}
+
+		if s1 == s2 {
+			return true
+		}
+
+		if s1 < s2 {
+			diff := s2 - s1
+			if cnt2[diff] > 0 {
+				if (m-i-1 > 1 && n > 1) ||
+					(i == m-2 && (int64(g[i+1][0]) == diff || int64(g[i+1][n-1]) == diff)) ||
+					(n == 1 && (int64(g[i+1][0]) == diff || int64(g[m-1][0]) == diff)) {
+					return true
+				}
+			}
+		} else {
+			diff := s1 - s2
+			if cnt1[diff] > 0 {
+				if (i+1 > 1 && n > 1) ||
+					(i == 0 && (int64(g[0][0]) == diff || int64(g[0][n-1]) == diff)) ||
+					(n == 1 && (int64(g[0][0]) == diff || int64(g[i][0]) == diff)) {
+					return true
+				}
+			}
+		}
+	}
+
+	return false
+}
+
+func rotate(grid [][]int) [][]int {
+	m, n := len(grid), len(grid[0])
+	t := make([][]int, n)
+	for i := range t {
+		t[i] = make([]int, m)
+	}
+	for i := 0; i < m; i++ {
+		for j := 0; j < n; j++ {
+			t[j][i] = grid[i][j]
+		}
+	}
+	return t
+}
+```
 
+#### TypeScript
+
+```ts
+function canPartitionGrid(grid: number[][]): boolean {
+    return check(grid) || check(rotate(grid));
+}
+
+function check(g: number[][]): boolean {
+    const m = g.length,
+        n = g[0].length;
+    let s1 = 0,
+        s2 = 0;
+
+    const cnt1 = new Map<number, number>();
+    const cnt2 = new Map<number, number>();
+
+    for (const row of g) {
+        for (const x of row) {
+            s2 += x;
+            cnt2.set(x, (cnt2.get(x) || 0) + 1);
+        }
+    }
+
+    for (let i = 0; i < m - 1; i++) {
+        for (const x of g[i]) {
+            s1 += x;
+            s2 -= x;
+
+            cnt1.set(x, (cnt1.get(x) || 0) + 1);
+            cnt2.set(x, (cnt2.get(x) || 0) - 1);
+        }
+
+        if (s1 === s2) return true;
+
+        if (s1 < s2) {
+            const diff = s2 - s1;
+            if ((cnt2.get(diff) || 0) > 0) {
+                if (
+                    (m - i - 1 > 1 && n > 1) ||
+                    (i === m - 2 && (g[i + 1][0] === diff || g[i + 1][n - 1] === diff)) ||
+                    (n === 1 && (g[i + 1][0] === diff || g[m - 1][0] === diff))
+                )
+                    return true;
+            }
+        } else {
+            const diff = s1 - s2;
+            if ((cnt1.get(diff) || 0) > 0) {
+                if (
+                    (i + 1 > 1 && n > 1) ||
+                    (i === 0 && (g[0][0] === diff || g[0][n - 1] === diff)) ||
+                    (n === 1 && (g[0][0] === diff || g[i][0] === diff))
+                )
+                    return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+function rotate(grid: number[][]): number[][] {
+    const m = grid.length,
+        n = grid[0].length;
+    const t: number[][] = Array.from({ length: n }, () => Array(m).fill(0));
+
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            t[j][i] = grid[i][j];
+        }
+    }
+
+    return t;
+}
 ```
 
 <!-- tabs:end -->