[C++&Rust]LeetCode No.363 矩形区域不超过 K 的最大数值和

原贴地址：http://blog.leanote.com/post/dawnmagnet/363

题目

给你一个 m x n 的矩阵 matrix 和一个整数 k ，找出并返回矩阵内部矩形区域的不超过 k 的最大数值和。

题目数据保证总会存在一个数值和不超过 k 的矩形区域。

示例 1：

输入：matrix = [[1,0,1],[0,-2,3]], k = 2
输出：2
解释：蓝色边框圈出来的矩形区域 [[0, 1], [-2, 3]] 的数值和是 2，且 2 是不超过 k 的最大数字（k = 2）。
示例 2：

输入：matrix = [[2,2,-1]], k = 3
输出：3

提示：

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

进阶：如果行数远大于列数，该如何设计解决方案？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路分析

我们首先观察一下该题，意思就是说计算一个矩形内部元素的和，如果我们对每个点进行分别计算，复杂度就会达到O(n^3*m3)，非常复杂，那么有没有什么简便的计算方法呢？
大家会发现，很多地方我们都会重复计算，比如样例输入1中:

• 左边矩形框（未画出）区域内的和是1+0+0+(-2)
• 1周围r区域内的和是0+(-2)+1+3

可以观察得出，我们重复计算0+(-2)很多遍，那么如何减少重复计算呢？我想出来了一个办法。

这个题目的主要意思就是让我们求一个区域范围内的和，而且要快，那么我们可以先求出来每个点与左上角围城矩形内所有元素的和。下面给大家画个图说明一下为什么这样能够便捷计算。

如图所示，待求的点在S4中，以(2*r+1)为半径画正方形，于是画出来一个S4，也就是说，S4内所有元素的和再除S4内所有元素的数量（很好计算）就是我们最终要求的答案。
那么再回到我们的设想，如果我们知道了每个点对应的和左上角围城矩形的面积内所有元素的和，那么

	点
A	S1
B	S1+S2
C	S1+S3
D	S1+S2+S3+S4

对我们来说，要求的是S4的面积，所以可以轻易推导出
$S4=D-B-C+A$
哇，仅用了O(1)的时间就做出来了！这个方法是不是非常高效，那么我们最终的目的就是推导出来一张表，其中每个点的数字对应到原图中代表了每个点与左上角围城矩形内所有元素的和。
当然，这个问题（指求出每个点与左上角围城矩形内所有元素的和）我们也可以用递推来解决。因为我们递推有一个顺序（从上往下，从左往右），所以我们可以假设在递推到[i][j]元素时，该元素左边和上方的元素已经可以表示
该点与左上角围城矩形内所有元素的和，那么我们的递推式也非常简单了，和上图完全是一样的思想。
$$A[i][j]=A[i][j]+\{\begin{array}{ll}A[i-1][j]+A[i][j-1]-A[i-1][j-1]& \text{if }i>0\&j>0\\ A[i-1][j]& \text{if }i>0\&j=0\\ A[i][j-1]& \text{if }i=0\&j>0\\ 0& \text{if }i=0\&j=0\end{array}$$
完美！
最后需要注意一下边界的问题。在上图中（四个矩形的图）还有四个变量，即上下左右边界，这个边界的计算需要注意，因为如果i和j加减r后超出了数组的边界，这个情况是需要我们判断的，所以我们使用最大最小值来限制这个边界的情况，具体的就写在代码里，就不过多赘述了。
最后BB一句：这个方法好像叫做二维前缀和。

讲完了数据处理的阶段。我们现在拥有了二维前缀和的数组，也可以在O(1)时间内获取任意一块矩形内部的和。似乎挺强的啊！于是我们来跑一跑：
C++代码（1980ms，概率超时）

int getsum(vector<vector<int>>& matrix, int left, int right, int top, int bottom) {
    left--;top--;
    int sum    = matrix[bottom][right];
    if (top >= 0) sum -= matrix[top][right];
    if (left >= 0) sum -= matrix[bottom][left];
    if (top >= 0 && left >= 0) sum += matrix[top][left];
    return sum;
}
class Solution {
public:
    int maxSumSubmatrix(vector<vector<int>>& matrix, int k) {
        int m = matrix.size();
        int n = matrix[0].size();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i != 0 && j != 0)
                    matrix[i][j] += matrix[i - 1][j] + matrix[i][j - 1] - matrix[i - 1][j - 1];
                else if (i != 0)
                    matrix[i][j] += matrix[i - 1][j];
                else if (j != 0)
                    matrix[i][j] += matrix[i][j - 1];
            }
        }
        int ret = INT_MIN;
        for (int top = 0; top < m; ++top) 
            for (int bottom = top; bottom < m; ++bottom) 
                for (int left = 0; left < n; ++left)
                    for (int right = left; right < n; ++right) {
                        int sum = getsum(matrix, left, right, top, bottom);
                        if (sum <= k) ret = max(ret, sum);
                        if (ret == k) return k;
                    }
            
        return ret;

    }
};

尴尬，超时了，那么必定还有我们可以继续优化的方法。
我们再来看看逻辑处理的部分，可以看出，我们现在的逻辑处理模块的复杂度是O(n^2)，因为我们要逐一判断每个left和right的值对应的sum，但是我们其实可以只遍历一遍，将所有判断过的sum都存放在一个有序数组中，每当遍历到一个新值的时候，我们就去该有序数组中寻找小于等于cur-k的最大值。在C++中正好对应着lower_bound操作。
这样找出来的值就是最靠近cur-k的值，再用cur减去这个值，就可以得到距离k最近且最大的数字了。

int getsum(vector<vector<int>>& matrix, int left, int right, int top, int bottom) {
    left--;top--;
    int sum    = matrix[bottom][right];
    if (top >= 0) sum -= matrix[top][right];
    if (left >= 0) sum -= matrix[bottom][left];
    if (top >= 0 && left >= 0) sum += matrix[top][left];
    return sum;
}
class Solution {
public:
    int maxSumSubmatrix(vector<vector<int>>& matrix, int k) {
        int m = matrix.size();
        int n = matrix[0].size();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (i != 0 && j != 0)
                    matrix[i][j] += matrix[i - 1][j] + matrix[i][j - 1] - matrix[i - 1][j - 1];
                else if (i != 0)
                    matrix[i][j] += matrix[i - 1][j];
                else if (j != 0)
                    matrix[i][j] += matrix[i][j - 1];
            }
        }
        int ret = INT_MIN;
        for (int top = 0; top < m; ++top) 
            for (int bottom = top; bottom < m; ++bottom) {
                set<int> s;
                s.insert(0);
                for (int i = 0; i < n; ++i) {
                    int cur = getsum(matrix, 0, i, top, bottom);
                    // printf("%d %d %d %d\n", top, bottom, i, cur);
                    auto pos = s.lower_bound(cur - k);
                    if (pos != s.end())
                        ret = max(ret, cur - *pos);
                    s.insert(cur);
                }
            }
        return ret;
    }
};