feat: add solutions to lc problem: No.0861.Score After Flipping Matrix

Author: yanglbme

solution/0800-0899/0861.Score After Flipping Matrix/README.md

@@ -37,27 +37,123 @@
 	<li><code>A[i][j]</code>&nbsp;是&nbsp;<code>0</code> 或&nbsp;<code>1</code></li>
 </ol>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+贪心。
+
+每一行的数字要尽可能大，因此，遍历每一行，若行首元素为 0，则将该行每个元素进行翻转，即 `grid[i][j] ^= 1`；
+
+接着，遍历每一列，统计列中元素为 1 的个数 `cnt`，若 `cnt`(1 的个数) 比 `m - cnt`(0 的个数) 小，则将该列进行翻转。实际过程中，并不需要对列进行翻转，只需要取 `max(cnt, m - cnt)`，即表示 1 的个数，再乘上该位的大小 `n - j - 1`，即求得当前列的大小。累加每一列大小即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def matrixScore(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        for i in range(m):
+            if grid[i][0] == 0:
+                for j in range(n):
+                    grid[i][j] ^= 1
+
+        res = 0
+        for j in range(n):
+            cnt = 0
+            for i in range(m):
+                cnt += grid[i][j]
+            res += max(cnt, m - cnt) * (1 << (n - j - 1))
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int matrixScore(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        for (int i = 0; i < m; ++i) {
+            if (grid[i][0] == 0) {
+                for (int j = 0; j < n; ++j) {
+                    grid[i][j] ^= 1;
+                }
+            }
+        }
+        int res = 0;
+        for (int j = 0; j < n; ++j) {
+            int cnt = 0;
+            for (int i = 0; i < m; ++i) {
+                cnt += grid[i][j];
+            }
+            res += Math.max(cnt, m - cnt) * (1 << (n - j - 1));
+        }
+        return res;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int matrixScore(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        for (int i = 0; i < m; ++i)
+        {
+            if (grid[i][0] == 0)
+            {
+                for (int j = 0; j < n; ++j) grid[i][j] ^= 1;
+            }
+        }
+        int res = 0;
+        for (int j = 0; j < n; ++j)
+        {
+            int cnt = 0;
+            for (int i = 0; i < m; ++i) cnt += grid[i][j];
+            res += max(cnt, m - cnt) * (1 << (n - j - 1));
+        }
+        return res;
+    }
+};
+```
 
+### **Go**
+
+```go
+func matrixScore(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	for i := 0; i < m; i++ {
+		if grid[i][0] == 0 {
+			for j := 0; j < n; j++ {
+				grid[i][j] ^= 1
+			}
+		}
+	}
+	res := 0
+	for j := 0; j < n; j++ {
+		cnt := 0
+		for i := 0; i < m; i++ {
+			cnt += grid[i][j]
+		}
+		res += max(cnt, m-cnt) * (1 << (n - j - 1))
+	}
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0800-0899/0861.Score After Flipping Matrix/README_EN.md

@@ -6,36 +6,22 @@
 
 <p>We have a two dimensional matrix&nbsp;<code>A</code> where each value is <code>0</code> or <code>1</code>.</p>
 
-
-
 <p>A move consists of choosing any row or column, and toggling each value in that row or column: changing all <code>0</code>s to <code>1</code>s, and all <code>1</code>s to <code>0</code>s.</p>
 
-
-
 <p>After making any number of moves, every row of this matrix is interpreted as a binary number, and the score of the matrix is the sum of these numbers.</p>
 
-
-
 <p>Return the highest possible&nbsp;score.</p>
 
-
-
 <p>&nbsp;</p>
 
-
-
 <ol>
 
 </ol>
 
-
-
 <div>
 
 <p><strong>Example 1:</strong></p>
 
-
-
 <pre>
 
 <strong>Input: </strong><span id="example-input-1-1">[[0,0,1,1],[1,0,1,0],[1,1,0,0]]</span>
@@ -48,16 +34,10 @@
 
 0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39</span></pre>
 
-
-
 <p>&nbsp;</p>
 
-
-
 <p><strong>Note:</strong></p>
 
-
-
 <ol>
 	<li><code>1 &lt;= A.length &lt;= 20</code></li>
 	<li><code>1 &lt;= A[0].length &lt;= 20</code></li>
@@ -66,22 +46,111 @@
 
 </div>
 
-
-
 ## Solutions
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def matrixScore(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        for i in range(m):
+            if grid[i][0] == 0:
+                for j in range(n):
+                    grid[i][j] ^= 1
+
+        res = 0
+        for j in range(n):
+            cnt = 0
+            for i in range(m):
+                cnt += grid[i][j]
+            res += max(cnt, m - cnt) * (1 << (n - j - 1))
+        return res
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int matrixScore(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        for (int i = 0; i < m; ++i) {
+            if (grid[i][0] == 0) {
+                for (int j = 0; j < n; ++j) {
+                    grid[i][j] ^= 1;
+                }
+            }
+        }
+        int res = 0;
+        for (int j = 0; j < n; ++j) {
+            int cnt = 0;
+            for (int i = 0; i < m; ++i) {
+                cnt += grid[i][j];
+            }
+            res += Math.max(cnt, m - cnt) * (1 << (n - j - 1));
+        }
+        return res;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int matrixScore(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        for (int i = 0; i < m; ++i)
+        {
+            if (grid[i][0] == 0)
+            {
+                for (int j = 0; j < n; ++j) grid[i][j] ^= 1;
+            }
+        }
+        int res = 0;
+        for (int j = 0; j < n; ++j)
+        {
+            int cnt = 0;
+            for (int i = 0; i < m; ++i) cnt += grid[i][j];
+            res += max(cnt, m - cnt) * (1 << (n - j - 1));
+        }
+        return res;
+    }
+};
+```
 
+### **Go**
+
+```go
+func matrixScore(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	for i := 0; i < m; i++ {
+		if grid[i][0] == 0 {
+			for j := 0; j < n; j++ {
+				grid[i][j] ^= 1
+			}
+		}
+	}
+	res := 0
+	for j := 0; j < n; j++ {
+		cnt := 0
+		for i := 0; i < m; i++ {
+			cnt += grid[i][j]
+		}
+		res += max(cnt, m-cnt) * (1 << (n - j - 1))
+	}
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0800-0899/0861.Score After Flipping Matrix/Solution.cpp

@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int matrixScore(vector<vector<int>>& grid) {
+        int m = grid.size(), n = grid[0].size();
+        for (int i = 0; i < m; ++i)
+        {
+            if (grid[i][0] == 0)
+            {
+                for (int j = 0; j < n; ++j) grid[i][j] ^= 1;
+            }
+        }
+        int res = 0;
+        for (int j = 0; j < n; ++j)
+        {
+            int cnt = 0;
+            for (int i = 0; i < m; ++i) cnt += grid[i][j];
+            res += max(cnt, m - cnt) * (1 << (n - j - 1));
+        }
+        return res;
+    }
+};

solution/0800-0899/0861.Score After Flipping Matrix/Solution.go

@@ -0,0 +1,26 @@
+func matrixScore(grid [][]int) int {
+	m, n := len(grid), len(grid[0])
+	for i := 0; i < m; i++ {
+		if grid[i][0] == 0 {
+			for j := 0; j < n; j++ {
+				grid[i][j] ^= 1
+			}
+		}
+	}
+	res := 0
+	for j := 0; j < n; j++ {
+		cnt := 0
+		for i := 0; i < m; i++ {
+			cnt += grid[i][j]
+		}
+		res += max(cnt, m-cnt) * (1 << (n - j - 1))
+	}
+	return res
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

solution/0800-0899/0861.Score After Flipping Matrix/Solution.java

@@ -0,0 +1,21 @@
+class Solution {
+    public int matrixScore(int[][] grid) {
+        int m = grid.length, n = grid[0].length;
+        for (int i = 0; i < m; ++i) {
+            if (grid[i][0] == 0) {
+                for (int j = 0; j < n; ++j) {
+                    grid[i][j] ^= 1;
+                }
+            }
+        }
+        int res = 0;
+        for (int j = 0; j < n; ++j) {
+            int cnt = 0;
+            for (int i = 0; i < m; ++i) {
+                cnt += grid[i][j];
+            }
+            res += Math.max(cnt, m - cnt) * (1 << (n - j - 1));
+        }
+        return res;
+    }
+}

solution/0800-0899/0861.Score After Flipping Matrix/Solution.py

@@ -0,0 +1,15 @@
+class Solution:
+    def matrixScore(self, grid: List[List[int]]) -> int:
+        m, n = len(grid), len(grid[0])
+        for i in range(m):
+            if grid[i][0] == 0:
+                for j in range(n):
+                    grid[i][j] ^= 1
+
+        res = 0
+        for j in range(n):
+            cnt = 0
+            for i in range(m):
+                cnt += grid[i][j]
+            res += max(cnt, m - cnt) * (1 << (n - j - 1))
+        return res