Matrix Leetcode 1314中的堆溢出

问题:

我试图用二维前缀sum来解决这个问题，其中

sum[I][j]

是左侧所有元素的总和，包括元素及其行和列

代码：

class Solution {
public:
    int n, m;
    int getSum(int i, int j, vector<vector<int>>& sum) {
        if(i<0 || j<0) return 0;
        if (i >= n) i = m - 1;
        if (j >= n) j = m - 1;
        return sum[i][j];
    }
    
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) {
        n = mat.size();
        m = mat[0].size();
        vector<vector<int>> sum(n, vector<int>(m, 0)), res(n, vector<int>(m, 0));
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                sum[i][j] = mat[i][j] + getSum(i-1, j, sum) + getSum(i, j-1, sum) - getSum(i-1, j-1, sum);
            }
        }
        for(int i=0; i<n; i++) {
            for(int j=0; j<m; j++) {
                res[i][j] = getSum(i+k, j+k, sum) - getSum(i-k-1, j+k, sum) - getSum(i+k, j-k-1, sum) + getSum(i-k-1, j-k-1, sum);
            }
        }
        return res;
    }
};

类解决方案{
公众：
int n，m；
int getSum（int i、int j、向量和和和）{
如果（i=n）j=m-1；
回报金额[i][j]；
}
向量矩阵X锁和（向量和矩阵，整数k）{
n=材料尺寸（）；
m=材料[0]。尺寸（）；
向量和（n，向量（m，0）），res（n，向量（m，0））；
对于（int i=0；i

该缺陷可能位于这些索引的最后一个循环中


下面是具有不同变量名的相同方法，将传递：

//下面的块可能会稍微缩短执行时间；
//可以移除；
静态常数自动优化{
std:：ios:：与stdio同步（false）；
标准：cin.tie（无PTR）；
标准：：cout.tie（无PTR）；
返回0；
}();
//大多数标题已经包含在内；
//可以移除；
#包括
#包括
静态常数结构解{
静态常数std:：向量矩阵xblocksum(
常数标准：：向量和矩阵，
常数int K
) {
常数std:：size\u t row\u len=std:：size（mat）；
常数std:：size\u t col\u len=行长度？std:：size（mat[0]）：0；
std：：向量和（row_len，std：：vector（col_len，0））；
对于（标准：：大小\u t行=0；行<行长度；++行）{
对于（标准：：大小列=0；列<列；++列）{
总和[行][col]=mat[行][col]+
getPrefixSum（第1行，第2列，总和）+
getPrefixSum（行，列-1，总和）-
getPrefixSum（第1行，第1列，总和）；
}
}
std:：vector res（行长度，std:：vector（列长度，0））；
对于（标准：：大小\u t行=0；行<行长度；++行）{
对于（标准：：大小列=0；列<列；++列）{
res[row][col]=getPrefixSum（row+K，col+K，sums）-
getPrefixSum（行+K，列-K-1，总和）-
getPrefixSum（行-K-1，列+K，总和）+
getPrefixSum（行-K-1，列-K-1，总和）；
}
}
返回res；
}
私人：
静态常量int getPrefixSum(
int row，
int col，
常数std:：向量和
) {
如果（行<0 | |列<0）{
返回0；
}
如果（行>=标准：：大小（总和））{
行=标准：：大小（总和）-1；
}
if（col>=std:：size（总和[0]））{
col=std:：size（和[0]）-1；
}
返回金额[行][col]；
}
};
谢谢。但与您的代码相比，我无法理解我的代码中有什么错误。
                res[i][j] = getSum(i+k, j+k, sum) - getSum(i-k-1, j+k, sum) - getSum(i+k, j-k-1, sum) + getSum(i-k-1, j-k-1, sum);

// The following block might slightly improve the execution time;
// Can be removed;
static const auto __optimize__ = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    return 0;
}();

// Most of headers are already included;
// Can be removed;
#include <cstdint>
#include <vector>

static const struct Solution {
        static const std::vector<std::vector<int>> matrixBlockSum(
                    const std::vector<std::vector<int>>& mat,
                    const int K
        ) {
            const std::size_t row_len = std::size(mat);
            const std::size_t col_len = row_len ? std::size(mat[0]) : 0;

            std::vector<std::vector<int>> sums(row_len, std::vector<int>(col_len, 0));

            for (std::size_t row = 0; row < row_len; ++row) {
                for (std::size_t col = 0; col < col_len; ++col) {
                    sums[row][col] = mat[row][col] +
                                     getPrefixSum(row - 1, col, sums) +
                                     getPrefixSum(row, col - 1, sums) -
                                     getPrefixSum(row - 1, col - 1, sums);
                }
            }

            std::vector<std::vector<int>> res(row_len, std::vector<int>(col_len, 0));

            for (std::size_t row = 0; row < row_len; ++row) {
                for (std::size_t col = 0; col < col_len; ++col) {
                    res[row][col] = getPrefixSum(row + K, col + K, sums) -
                                    getPrefixSum(row + K, col - K - 1, sums) -
                                    getPrefixSum(row - K - 1, col + K, sums) +
                                    getPrefixSum(row - K - 1, col - K - 1, sums);
                }
            }

            return res;
        }

    private:

        static const int getPrefixSum(
            int row,
            int col,
            const std::vector<std::vector<int>>& sums
        ) {
            if (row < 0 || col < 0) {
                return 0;
            }

            if (row >= std::size(sums)) {
                row = std::size(sums) - 1;
            }

            if (col >= std::size(sums[0])) {
                col = std::size(sums[0]) - 1;
            }

            return sums[row][col];
        }
};