Leetcode: Max Sum of Rectangle 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:
The rectangle inside the matrix must have an area > 0.
What if the number of rows is much larger than the number of columns?

Reference: https://discuss.leetcode.com/topic/48875/accepted-c-codes-with-explanation-and-references/2

The naive solution is brute-force, which is O((mn)^2). In order to be more efficient, I tried something similar to Kadane's algorithm. The only difference is that here we have upper bound restriction K.

First, How to find the max sum rectangle in 2D array? The naive way is O(N^4)

Here's the easily understanding video link for the problem "find the max sum rectangle in 2D array": Maximum Sum Rectangular Submatrix in Matrix dynamic programming/2D kadane , O(N^3), the idea is select left edge l and right edge r, together with top edge 0 and bottom edge n, form a subrectangle area, (O(N^2)), find the local max sum in this subrectangle, just like max sum subarray(O(N). So the total time complexity is O(N^3), space complexity is O(N).

Once you are clear how to solve the above problem, the next step is to find the max sum no more than K in an array. This can be done within O(nlogn), and you can refer to this article: max subarray sum no more than k.  

You can do this in O(nlog(n))

First thing to note is that sum of subarray (i,j] is just the sum of the first j elements less the sum of the first i elements. Store these cumulative sums in the array cum. Then

the problem reduces to finding i,j such that i<j and cum[j]−cum[i] is as close to k but lower than it.

To solve this, scan from left to right. Put the cum[i] values that you have encountered till now into a set. When you are processing cum[j] what you need to retrieve from the set is the smallest number in the set such which is bigger than cum[j]−k. This lookup can be done in O(log⁡n) using upper_bound. Hence the overall complexity is O(nlog(n)).

This can be done using TreeSet.

For the solution below, I assume that the number of rows is larger than the number of columns. Thus in general time complexity is

O[min(m,n)^2 * max(m,n) * log(max(m,n))], space O(max(m, n)).

假设col<row，下面的意思就是维护一个size为row的 sum数组。 每次iteration这个sum数组用来存某几个col叠加在一起的和（就是某一个rectangle的sum），然后在其中用treeSet找出当前最大的rectangle sum，时间复杂度是row*(log(row)). 所有iteration完成就得到最终答案，iteration数目是O(col^2), 所以总时间复杂度是O（col^2*row*log(row)）。

例子：

1 2 3 

4 5 6

7 8 9

假如现在i = 0， j=1, 那么当前subrectangle是[[1, 2], [4, 5], [7, 8]], 于是int[] sum就是[[1+2], [4+5], [7+8]] = [[3], [9], [15]], val是这个sum数组的preSum, 依次取的值是3， 3+9=12， 3+9+15=27， 所以TreeSet里面依次被加入0，3，12，27.  假设k=16，那么到27的时候，set里面是0,3,12，存在比27-16=11大的值是12，说明存在不大于k=16的最大subrectangle area = 27-12=15

Time Complexity: O[min(m,n)^2 * max(m,n) * log(max(m,n))], space O(max(m, n)).     compare to naive solution time complexity O((mn)^2)

same as Leetcode: Number of Submatrices That Sum to Target

public class Solution {
    public int maxSumSubmatrix(int[][] matrix, int k) {
        if (matrix==null || matrix.length==0 || matrix[0].length==0) return Integer.MIN_VALUE;
        int res = Integer.MIN_VALUE;
        
        int row = matrix.length;
        int col = matrix[0].length;
        int m = Math.min(row, col);
        int n= Math.max(row, col);
        boolean moreCol = col > row;
        
        for (int i=0; i<m; i++) {
            int[] sum = new int[n];
            for (int j=i; j<m; j++) {
                TreeSet<Integer> set = new TreeSet<Integer>();
                int val = 0;  //sum array's preSum
                set.add(0);
                for (int l=0; l<n; l++) {
                    sum[l] += moreCol? matrix[j][l] : matrix[l][j];
                    val += sum[l];  
                    Integer oneSum = set.ceiling(val-k);
                    if (oneSum != null) {
                        res = Math.max(res, val-oneSum);
                    }
                    set.add(val);
                }
            }
        }
        return res;
    }
}