leetcode 363. Max Sum of Rectangle No Larger Than K（和不大于K的矩形）

Given a non-empty 2D matrix matrix and an integer k, find the max sum of a rectangle in the matrix such that its sum is no larger than k.

Example:

Input: matrix = [[1,0,1],[0,-2,3]], k = 2
Output: 2
Explanation: Because the sum of rectangle [[0, 1], [-2, 3]] is 2,
and 2 is the max number no larger than k (k = 2).

Note:

The rectangle inside the matrix must have an area > 0.
What if the number of rows is much larger than the number of columns?

给出一个矩阵，要在矩阵中找出元素和<=k的矩形

思路：
可以先求积分矩阵，然后遍历每个形状的矩形求内部元素和，找出和不大于K的最大值，不详述

还可以用一步步缩小范围的方法，比如要找的矩阵上下边界分别是up, down, 那么up可以从0～row（matrix的行数），down从up～row遍历。
确定了行的上下边界以后，再确定左右边界。
举个例子，matrix = [[1,0,1],[0,-2,3]],如果上边界是行0，下边界是行1，就是matrix本身，这时候要确定左右边界。
现在是两行，为了方便找左右边界，把两行拍扁成一行，成了[1,-2,4], 即两行求和。那么问题就转化成一维数组中找左右边界。
对一维数组求累加和，sum=[1,-1, 3]，假设右边界是 j， 左边界是 i，那么i～j范围内的和为sum[ j ] - sum[ i ], 我们要找<= k的和,
因此sum[ j ] - sum[ i ] <= k, 那么sum[ i ] >= sum[ j ] - k
当右边界j 确定之后，只需要二分搜索0～j 范围内 >= sum[ j ] - k的数，如果存在sum[ i ] == sum[ j ] - k，直接返回k即可，因为和的上限就是k，不需要再计算了。如果存在 sum[ i ] > sum[ j ] - k, 找到最小的sum[i], 不存在就不更新结果。

但是我们不能直接在sum数组中0～j的范围内二分搜索sum[ j ]-k， 因为二分搜索的条件是升序数组，现在sum这个数组它不一定是有序的。也不要每搜索一段范围就对这段范围内的元素排序，最好的办法是把sum中0～j 范围内的元素逐一加入一个数组，加入的时候就按升序排列，这样j 每向右移动一位只需要每次加入一个元素即可。 这个可以利用红黑树实现的set来实现，java中是treeSet

总结一下步骤，
先确定矩阵行的上边界up，再从up到最后一行遍历矩阵的下边界，然后把行拍扁成一维数组，在一维数组中遍历右边界，在0～右边界范围内二分搜索左边界。每次更新一个较大的矩阵和。最后返回最大的<=k的矩阵和。

注意这种方法在拍扁行的时候，求的是行的累积和，这样的结果就是非常耗时，因为计算机存储二维数组的时候是按行存的，也就是每行的所有列元素的地址是连续的，现在按行求累积和，地址不连续，可能查找耗时吧

//914ms
    public int maxSumSubmatrix(int[][] matrix, int k) {
        if(matrix == null || matrix.length == 0) {
            return 0;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        int result = Integer.MIN_VALUE;
        int[] sum = new int[n+1];
        
        for(int i = 0; i < m; i++) {
            Arrays.fill(sum, 0);
            for(int j = i; j < m; j++) {
                for(int p = 0; p < n; p++) {
                    sum[p+1] += matrix[j][p];
                }
                result = Math.max(result, rowLessThanK(sum, k));
            }
        }
        return result;
    }
    
    int rowLessThanK(int[] sum, int k) {
        int n = sum.length;
        TreeSet<Integer> rowSum = new TreeSet<>();
        rowSum.add(0);
        int result = Integer.MIN_VALUE;
        int tmp = 0;
        
        //sum_j - sum_i <= k -> sum_i >= sum_j-k 
        for(int j = 1; j < n; j++) {
            tmp += sum[j];
            Integer i = rowSum.ceiling(tmp - k);
            if(i != null) {
                result = Math.max(result, tmp - i);
            }
            
            rowSum.add(tmp);          
        }
        return result;
    }

改写成拍扁列的方式，也就是按列求累积和，效率大大提高，从914ms提高到126ms

//126ms
    public int maxSumSubmatrix(int[][] matrix, int k) {
        if(matrix == null || matrix.length == 0) {
            return 0;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        int result = Integer.MIN_VALUE;
        int[] sum = new int[m+1];
        
        for(int i = 0; i < n; i++) {
            Arrays.fill(sum, 0);
            for(int j = i; j < n; j++) {
                for(int p = 0; p < m; p++) {
                    sum[p+1] += matrix[p][j];
                }
                result = Math.max(result, rowLessThanK(sum, k));
                if(result == k) {
                    return result;
                }
            }
        }
        return result;
    }
    
    int rowLessThanK(int[] sum, int k) {
        int m = sum.length;
        TreeSet<Integer> rowSum = new TreeSet<>();
        rowSum.add(0);
        int result = Integer.MIN_VALUE;
        int tmp = 0;
        
        //sum_j - sum_i <= k -> sum_i >= sum_j-k 
        for(int j = 1; j < m; j++) {
            tmp += sum[j];
            Integer i = rowSum.ceiling(tmp - k);
            if(i != null) {
                result = Math.max(result, tmp - i);
            }
            
            rowSum.add(tmp);          
        }
        return result;
    }

如果不分开成两个函数，都写在一个函数里

    public int maxSumSubmatrix(int[][] matrix, int k) {
        if(matrix == null || matrix.length == 0) {
            return 0;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        int result = Integer.MIN_VALUE;
        
        //二维数组内存按行存放，每行的列是连续地址，按列走
        for(int i = 0; i < m; i ++) {
            for(int j = 1; j < n; j++) {
                matrix[i][j] += matrix[i][j-1];
            }
        }
        
        for(int c1 = 0; c1 < n; c1++) {
            for(int c2 = c1; c2 < n; c2++) {
                int sumJ = 0;
                TreeSet<Integer> set = new TreeSet<>();
                set.add(0);
                
                for(int r = 0; r < m; r++) {
                    //先把行拍扁，再求列元素的累加和
                    sumJ += (c1 == 0) ? matrix[r][c2] : matrix[r][c2] - matrix[r][c1-1];
                    //sumJ - sumI <= k => sumI >= sumJ - k
                    Integer sumI = set.ceiling(sumJ - k); //find equal or higher
                    if(sumI != null) {
                        result = Math.max(result, sumJ - sumI);
                    }
                    set.add(sumJ);
                }
            }
        }
        return result;
    }