目录
一、题目
有一个二维矩阵 A 其中每个元素的值为 0 或 1 。
移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。
在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。
返回尽可能高的分数。
二、示例
示例：
输入：[[0,0,1,1],[1,0,1,0],[1,1,0,0]]
输出：39
解释：
转换为 [[1,1,1,1],[1,0,0,1],[1,1,1,1]]
0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39
提示：
- 1 <= A.length <= 20
- 1 <= A[0].length <= 20
- A[i][j] 是 0 或 1
三、思路
0、 原矩阵
[
[0, 0, 1, 1],
[1, 0, 1, 0],
[1, 1, 0, 0]
]
1、先依次反转所有行，保证每行的第0列为1
[
[1, 1, 0, 0],
[1, 0, 1, 0],
[1, 1, 0, 0]
]
2、因为第0列全为1了，所有从第1列开始反转列，计算每一列的1的数量，如果1数量小于50%，那么反转该列
(为了计算每一列的1的数量，次数我们先将矩阵进行转置，得到转置矩阵A_T
之后再从第二行开始计算1的数量，如果数量小于50%，反转，
最后再转置即可。)
[
[1, 1, 1, 1],
[1, 0, 0, 1],
[1, 1, 1, 1]
]
3、完成反转矩阵，计算所得值
四、代码
import numpy as np
class Solution:
def matrixScore(self, A) -> int:
"""
:param A: List[List[int]]
:return: int
"""
"""
0、 [
[0, 0, 1, 1],
[1, 0, 1, 0],
[1, 1, 0, 0]
]
1、先依次反转所有行，保证每行的第0列为1
[
[1, 1, 0, 0],
[1, 0, 1, 0],
[1, 1, 0, 0]
]
2、因为第0列全为1了，所有从第1列开始反转列，计算每一列的1的数量，如果1数量小于50%，那么反转该列
(为了计算每一列的1的数量，次数我们先将矩阵进行转置，得到转置矩阵A_T
之后再从第二行开始计算1的数量，如果数量小于50%，反转，
最后再转置即可。)
[
[1, 1, 1, 1],
[1, 0, 0, 1],
[1, 1, 1, 1]
]
3、完成反转矩阵，计算所得值
"""
m, n = len(A), len(A[0])
# 翻转
def Reverse(array):
if len(array) == 0:
return []
for i in range(len(array)):
array[i] = 0 if array[i] == 1 else 1
return array
# 先依次反转所有行，保证每行的第0列为1
for i in range(m):
if A[i][0] == 0:
A[i] = Reverse(A[i])
# 计算每一列的1的数量，如果1数量小于50%，那么反转该列
A_T = np.transpose(A)
for i in range(1, n):
sums = np.sum(A_T[i])
if sums / len(A_T[i]) < 0.5:
A_T[i] = Reverse(A_T[i])
A = np.transpose(A_T)
# 计算所得值
ans = 0
for i in range(m):
tmp = 0
for j in range(n - 1, -1, -1):
# print(A[i][j])
power = n - j - 1
tmp += pow(2, power) * A[i][j]
ans += tmp
return ans
if __name__ == '__main__':
test = [
[0, 0, 1, 1],
[1, 0, 1, 0],
[1, 1, 0, 0]
]
s = Solution()
ans = s.matrixScore(test)
"""
[
[1,1,1,1],
[1,0,0,1],
[1,1,1,1]
]
"""
print(ans)