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)