LeetCode 363. Max Sum of Rectangle No Larger Than K（矩阵和）

原题网址：https://leetcode.com/problems/max-sum-of-sub-matrix-no-larger-than-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:

Given matrix = [
  [1,  0, 1],
  [0, -2, 3]
]
k = 2

The answer is 2. Because the sum of rectangle [[0, 1], [-2, 3]] is 2 and 2 is the max number no larger than k (k = 2).

Note:

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

方法：使用累积数组和有序集合，需要注意边界情况。

public class Solution {
    public int maxSumSubmatrix(int[][] matrix, int k) {
        int[][] vsum = new int[matrix.length][matrix[0].length];
        for(int i = 0; i < matrix.length; i++) {
            for(int j = 0; j < matrix[i].length; j++) {
                vsum[i][j] = matrix[i][j];
                if (i > 0) vsum[i][j] += vsum[i-1][j];
            }
        }
        int max = Integer.MIN_VALUE;
        for(int i = 0; i < matrix.length; i++) {
            for(int j = i; j < matrix.length; j++) {
                TreeSet<Integer> ts = new TreeSet<Integer>();
                int sum = 0;
                for(int m = 0; m < matrix[i].length; m++) {
                    sum += vsum[j][m];
                    if (i > 0) sum -= vsum[i-1][m];
                    if (sum == k) return sum;
                    if (sum < k) max = Math.max(max, sum);
                    Integer other = ts.ceiling(sum - k);
                    // System.out.printf("i=%d, j=%d, m=%d, sum=%d, ts=%s\n", i, j, m, sum, ts);
                    ts.add(sum);
                    if (other == null) continue;
                    max = Math.max(max, sum - other);
                }
            }
        }
        return max;
    }
}

优化：

public class Solution {
    public int maxSumSubmatrix(int[][] matrix, int k) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return 0;
        int max = Integer.MIN_VALUE;
        int m = matrix.length;
        int n = matrix[0].length;
        if (n <= m) {
            // O(n * n * m * log(m))
            for(int left = 0; left < n; left++) {
                int[] rsums = new int[m];
                for(int right = left; right < n; right++) {
                    TreeSet<Integer> ts = new TreeSet<>();
                    int rsum = 0;
                    for(int row = 0; row < m; row++) {
                        rsum += matrix[row][right];
                        rsums[row] += rsum;
                        if (rsums[row] == k) return k;
                        if (rsums[row] < k) max = Math.max(max, rsums[row]);
                        Integer ceiling = ts.ceiling(rsums[row] - k);
                        if (ceiling != null) {
                            max = Math.max(max, rsums[row] - ceiling);
                            if (max == k) return k;
                        }
                        ts.add(rsums[row]);
                    }
                }
            }
        } else {
            // O(m * m * n * log(n))
            for(int top = 0; top < m; top++) {
                int[] csums = new int[n];
                for(int bottom = top; bottom < m; bottom++) {
                    TreeSet<Integer> ts = new TreeSet<>();
                    int csum = 0;
                    for(int col = 0; col < n; col++) {
                        csum += matrix[bottom][col];
                        csums[col] += csum;
                        if (csums[col] == k) return k;
                        if (csums[col] < k) max = Math.max(max, csums[col]);
                        Integer ceiling = ts.ceiling(csums[col] - k);
                        if (ceiling != null) {
                            max = Math.max(max, csums[col] - ceiling);
                            if (max == k) return k;
                        }
                        ts.add(csums[col]);
                    }
                }
            }
        }
        return max;
    }
}