LeetCode 363. Max Sum of Rectangle No Larger Than K

原题链接在这里：https://leetcode.com/problems/max-sum-of-rectangle-no-larger-than-k/

题目：

Given an m x n matrix matrix and an integer k, return the max sum of a rectangle in the matrix such that its sum is no larger than k.

It is guaranteed that there will be a rectangle with a sum no larger than k.

Example 1:

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

Example 2:

Input: matrix = [[2,2,-1]], k = 3
Output: 3 

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 100
• -100 <= matrix[i][j] <= 100
• -105 <= k <= 105

Follow up: What if the number of rows is much larger than the number of columns?

题解：

2D Kadane's algorithm.

The outter loop should be min of (m, n).

Time Complexity: O(x^2 * y * logy). x = min(m, n). y = max(m, n).

Space: O(y).

AC Java:

class Solution {
    public int maxSumSubmatrix(int[][] matrix, int k) {
        // 2D Kadane's algorithm
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
            return 0;
        }
        
        int m = matrix.length;
        int n = matrix[0].length;
        int res = Integer.MIN_VALUE;
        
        // outter loop should be min(m, n).
        for(int left = 0; left < n; left++){
            int [] sums = new int[m];
            for(int right = left; right < n; right++){
                // Update sums[i] as sum of row i from left to right.
                for(int i = 0; i < m; i++){
                    sums[i] += matrix[i][right];
                }
                
                // Find no larger than k with sums.
                // Find the max of currentSum - prevSum <= k
                // Thus currentSum - k <= preSum, find ceiling of currentSum - k
                TreeSet<Integer> ts = new TreeSet<>();
                ts.add(0);
                int curSum = 0;
                for(int num : sums){
                    curSum += num;
                    Integer preSum = ts.ceiling(curSum - k);
                    if(preSum != null){
                        res = Math.max(res, curSum - preSum);
                    }
                    
                    ts.add(curSum);
                }
                
            }
        }
        
        return res;
    }
}

类似Maximum Subarray.