Leetcode 每日一题——861. 翻转矩阵后的得分_翻转矩阵后的得分 leetcode

Leetcode 每日一题——861. 翻转矩阵后的得分

有一个二维矩阵 A 其中每个元素的值为 0 或 1 。
移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。
在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。
返回尽可能高的分数。

该题目的算法思路是先保证首节点都是1的情况下每列有尽可能多的1，具体代码如下（C++版）：

class Solution {
public:
    int matrixScore(vector<vector<int>>& A) {
        int m=A.size();
        int n=A[0].size();
        int result=m*(1<<(n-1));
        for(int j=1;j<n;++j)
        {
            int numOfOne=0;
            for(int i=0; i<m; ++i)
            {
                if(A[i][0]==0) numOfOne+=A[i][j];
                else numOfOne+=1-A[i][j];
            }
            numOfOne=max(numOfOne,m-numOfOne);
            result+=numOfOne*(1<<(n-1-j));
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行效果：

相同思路的Scala代码：

object Solution {
    def matrixScore(A: Array[Array[Int]]): Int = {
        val m=A.size
        val n=A(0).size
        var result=m*(1<<(n-1))
        (1 until n).foreach(i=>{
            var count=0
            (0 until m).foreach(j=> count+=(if(A(j)(0)==A(j)(i)) 1 else 0))
            count=count.max(m-count)
            result+=count*(1<<(n-i-1))
        })
        return result
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行效果（估计是因为没人提交这个代码的版本）：

同样思路的Python代码：

class Solution:
    def matrixScore(self, A: List[List[int]]) -> int:
        m,n=len(A),len(A[0])
        result=m*(1<<(n-1))
        for j in range(1,n):
            count=0
            for i in range(0,m):
                count+= 1 if A[i][0]==A[i][j] else 0
            count=max(count,m-count)
            result+=count*(1<<(n-1-j))
        return result
1
2
3
4
5
6
7
8
9
10
11

运行效果：

这样一对比也能看出各个编程语言的运行速度了。
来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/score-after-flipping-matrix