数值1 在矩阵中的最大数量是多少，现有一个尺寸为sideLength*sideLength 的矩阵M,矩阵中的每个单元格的值不是0就是1，而且知道矩阵

的边长maxOnes，计算矩阵中最多可以有多少个1

参考：//https://leetcode.com/savevmk

根本看不懂
class Solution(object):
    def maximumNumberOfOnes(self,width: int,height: int, sideLength:int,maxOnes:int) -> int:
        arr = [0 for _ in range(sideLength*sideLength)]
        for i in range(height):
            for j in range(width):
                row = i%sideLength
                col = j%sideLength
                arr[row*sideLength +col]+=1
        arr.sort()# 升序
        ans=0
        for i in range(maxOnes):
            ans += arr[len(arr) -1 -i] # 1的个数
        return ans

if __name__ == '__main__':
    width,height,sideLength,maxOnes = 2,1,4,2
    print(Solution().maximumNumberOfOnes(width,height,sideLength,maxOnes))

来自牛客网左程云第三课第一题
问题：给定一个无序矩阵，其中有正，有负，有 0，求子矩阵的最大和。
要求：时间复杂度O(N^3)
分析：一个最直接的方法就是找到所有的子矩阵，然后遍历这些子矩阵并计算其累加和，找出最大的。矩阵将矩阵中的每一个点作为子矩阵的左上角，我们可以得到N*N的数量级的子矩阵数量。那么一共有N*N个点可以作为子矩阵的左上角，子矩阵的数量到达O(N^4)的数量级，我们在计算每个子矩阵的时候累加和的时候需要遍历每一个数，达到O(N*N)的数量级，整体的时间复杂度达到O(N^6)。子矩阵我们都可以转换成子数组解决，这道题的算法原型是leetcode
 53. Maximum Subarray 子数组最大和。
解法：我们求出以每一行的为首行的子矩阵的列累加和，就是将列对应相加，这样我们就得到了一个数组，接下来我们求这个数组的子数组最大和也就是求出了这个子矩阵的最大和。那么我们一共有N行，以这些行为首行的子矩阵有N*N个，求子数组最大和的时间复杂度为O(N)，整体的时间复杂度为O(N^3)。算法原型真的是很重要啊。
public class Main {
	public static int maxSum(int[][] m) {
		if (m == null || m.length == 0 || m[0].length == 0) {
			return 0;
		}
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < m.length; i++) {
			for (int j = i; j < m.length; j++) {
				int sum = 0;
				for (int k = 0; k < m[j].length; k++) {
					if (i != j) {
						m[i][k] += m[j][k];// 把累加结果保存在当前行
					}
					sum += m[i][k];
					max = Math.max(max, sum);
					sum = sum > 0 ? sum : 0;
				}
			}
		}
		return max;
	}

	public static void main(String[] args) {
		int[][] matrix = { { -90, 48, 78 }, { 64, -40, 64 }, { -81, -7, 66 } };
		System.out.println(maxSum(matrix));

	}
}

假设我们有一个2D矩阵，其中每个单元都存储一些硬币。如果我们从[0,0]开始，并且只能向右或向下移动，则必须在右下角找到可以收集的最大硬币数量。
所以，如果输入像1422
0005
然后输出将为14，因为我们采用以下路径：[1、4、2、2、5]
为了解决这个问题，我们将按照以下步骤操作：对于范围1至行A的r，执行A [r，0]：= A [r，0] + A [r-1，0]
对于范围1至列A的c，执行A [0，c]：= A [0，c] + A [0，c-1]
对于范围1至A大小的r，执行
对于范围1至A [0]大小的c，执行
A [r，c] = A [r，c] +(A [r-1，c]和A [r，c-1]的最大值
A的右下角的返回值
让我们看下面的实现以更好地理解-
示例class Solution:
def solve(self, A):
for r in range(1, len(A)):
A[r][0] += A[r-1][0]
for c in range(1, len(A[0])):
A[0][c] += A[0][c-1]
for r in range(1, len(A)):
for c in range(1, len(A[0])):
A[r][c] += max(A[r-1][c], A[r][c-1])
return A[-1][-1]
ob = Solution()matrix = [ [1, 4, 2, 2], [6, 0, 0, 5] ]
print(ob.solve(matrix))
输入值matrix = [
[1, 4, 2, 2],
[6, 0, 0, 5]
]
输出结果14

题目：

有一个二维矩阵 A 其中每个元素的值为 0 或 1 。

移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 0 都更改为 1，将所有 1 都更改为 0。

在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。

返回尽可能高的分数

示例：


提示：


解题思路：

对于每一行来说，保证首位是1就是最大数。

对于每一列来说，保证1的数量大于0的数量。

计算，从末尾开始，每一列的乘数是1的数量

方法一：
class Solution {
    public int matrixScore(int[][] A) {
       // 保存每列1的数量
        int[] nums = new int[A[0].length];
        for (int i = 0; i < A.length; i++) {
            // 先把每行的第一个置为1，确保最大
            // 需要移动
            boolean needMove = A[i][0] == 0;
            for (int j = 0; j < A[i].length; j++) {
                if (needMove) {
                    A[i][j] = (A[i][j] + 1) % 2;
                }
                if (A[i][j] == 1) {
                    nums[j]++;
                }
            }
        }
        int count = 0;
        int index = 1;
        // 对每一列来说，若0的数量大于1的数量则交换
        for (int i = nums.length - 1; i >= 0; i--) {
            if (nums[i] <= (A.length - nums[i])) {
                nums[i] = A.length - nums[i];
            }
            count += nums[i] * index;
            // 最后一位被乘数是1，依次向前计算
            index = index * 2;
        }
        return count;
    }
}

方法二：贪心算法
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;
    }
}