力扣日常#861 翻转矩阵后的得分

 1 class Solution {
 2     public int matrixScore(int[][] A) {
 3         int len1 = A.length, len2 = A[0].length;
 4 
 5         for(int i = 0; i < len1; i++){
 6             if(A[i][0] == 0){
 7                 for(int j = 0; j < len2; j++){
 8                     if(A[i][j] == 0){
 9                         A[i][j] = 1;
10                     }else{
11                         A[i][j] = 0;
12                     }
13                 }
14             }
15         }
16 
17         for(int i = 1; i < len2; i++){
18             int count = 0;
19             for(int j = 0; j < len1; j++){
20                 if(A[j][i] == 1) count++;
21             }
22             if(count < (len1 + 1) / 2){
23                 for(int k = 0; k < len1; k++){
24                     if(A[k][i] == 1){
25                         A[k][i] = 0;
26                     }else{
27                         A[k][i] = 1;
28                     }
29                 }
30             }
31         }
32 
33         int num = 0;
34         for(int i = 0; i < len2; i++){
35             double temp = Math.pow(2, len2 - i - 1);
36             for(int j = 0; j < len1; j++){
37                 num += A[j][i]*temp;
38             }
39         }
40         return (int)num;
41     }
42 }

根据官方文字提示写的方法 比较笨 为了获得最高的分数 矩阵最高位（最左边的一行必须是1）所以第一遍循环把第一列为0的整行翻转

然后统计每列的1的个数 如果1的个数比0少 则整列翻转 时间复杂度O(N^2);            m = A.length n = A[0].length

但实际编写代码时 不用修改矩阵 可以按列计算： 最优情况下 最左边的一列为全1 总贡献m * 2^(N - 1)

对于第j列 统计0，1的数量 让其中最大值为k 该列的总贡献为k * 2^(n - j - 1) 统计数量时要考虑最初的行翻转

class Solution {
    public int matrixScore(int[][] A) {
        int m = A.length, n = A[0].length;
        int ret = m * (1 << (n - 1));

        for (int j = 1; j < n; j++) {
            int nOnes = 0;
            for (int i = 0; i < m; i++) {
                if (A[i][0] == 1) {
                    nOnes += A[i][j];
                } else {
                    nOnes += (1 - A[i][j]); // 如果这一行进行了行反转，则该元素的实际取值为 1 - A[i][j]
                }
            }
            int k = Math.max(nOnes, m - nOnes);
            ret += k * (1 << (n - j - 1));
        }
        return ret;
    }
}

↑官方解法 时间复杂度O(NM)

标签：len2,861,++,力扣,int,length,len1,翻转
来源： https://www.cnblogs.com/doomslayer/p/14098842.html