LeetCode 363. 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:

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:

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?

------------------------------------------------------------

Different from https://blog.csdn.net/taoqick/article/details/105450592. This problem requires the max <=K, so C++ set is required. If ma=max(rows, cols), mi=mi(rows,cols), the complexity is O(mi^2*ma*log(ma)). The code is 

class Solution {
public:
    int maxSumSubVec(vector<int>& vec, int k) {
        set<int> rb;
        rb.insert(0);
        int curPrefix = 0, maxSum = -0x3fffffff;
        for (int i = 0; i < vec.size(); ++i) {
            curPrefix += vec[i];
            set<int>::iterator it = rb.lower_bound(curPrefix-k);
            if (it != rb.end()) {
                int delta = curPrefix-*it;
                maxSum = max(maxSum, delta);
                if (delta == k) {
                    return delta;
                }
            }
            rb.insert(curPrefix);
        }
        return maxSum;
    }
    
    int maxSumSubmatrix(vector<vector<int>>& matrix, int k)
    {
        int rows = matrix.size(), cols = matrix.empty() ? 0 : matrix[0].size();
        int res = -0x3fffffff;

        if (rows == 0 || cols == 0)  return 0;
        if (rows > cols) {
            vector<vector<int>> tmp(cols, vector<int>(rows, 0));
            for (int i = 0; i < rows; ++i) {
                for (int j = 0; j < cols; ++j) {
                    tmp[j][i] = matrix[i][j];
                }
            }
            matrix = tmp;
            rows = matrix.size();
            cols = matrix[0].size();
        }
        
        vector<vector<int>> accu(rows, vector<int>(matrix[0]));
        for (int i = 1; i < rows; ++i) {
            for (int j = 0; j < cols; ++j) {
                accu[i][j] = accu[i-1][j]+matrix[i][j];
            }
        }
        for (int l = 0; l < rows; ++l) {
            for (int r = l; r < rows; ++r) {
                vector<int> vec(cols, 0);
                for (int j = 0; j < cols; ++j) {
                    int pre = l >= 1 ? accu[l-1][j] : 0;
                    vec[j] = accu[r][j]-pre;
                }
                res = max(res, maxSumSubVec(vec, k));
            }
        }
        return res;
    }
};