二维前缀和

关于前缀和不知道的可以去看一下我的另一篇文章前缀和，不想跳转的话我也在下面列出了

前缀和即是前n项和，这是我做力扣53时动态规划暴力解法领悟的，果不其然地超时了

即数组nums中从0到下标为n的数字之和为 f [ n ] = f [ n - 1 ] + nums [ n ]

同时我们可以进行扩展，对于区间[ x , y ]的数字之和即是 f [ y ] - f [ x ]

然后我们对一维数组再进行扩展，扩展到二维数组

int[][] nums = {
                    {1, 5, 2, 6},
                    {2, 5, 2, 1},
                    {1, 2, 3, 1},
                    {4, 3, 2, 1}
            };

对于上述的二维数组，可以将其视作一个矩阵，在创建一个同样大小的前缀和 f [ ][ ]如果我们要获取 f [ 1 ][ 1 ]，即nums[ 1 ][ 1 ]处的和，

即 nums[ 0 ][ 0 ]+nums[ 0 ][ 1 ]+nums[ 1 ][ 0 ]+nums[ 1 ][ 1 ]

但如果是nums[ 3 ][ 3 ]直接这样计算就比较费劲，尤其是时间复杂度，所以可以用上一维前缀和的知识，将前缀和都存储在 f 中，首先需要填满第 0 行和第 0 列，而 f[ 1 ][ 1 ]就是这个点上面的前缀和加上左侧的前缀和，这样就把前缀和重叠的部分加了两遍，所以需要再减去这部分即

f [ 1 ][ 1 ] =  f[ 0 ][ 1 ]+f[ 1 ][ 0 ] - f[ 0 ][ 0 ]

所以可以得出动态规划结果
f[ x ][ y ] = f [ x-1 ][ y ] + f [ x ][ y-1] -f [ x-1][ y-1 ]

    static public class Solution {
        public int sum(int[][] nums, int x, int y) {
            int row = nums.length;
            int col = nums[0].length;
            int[][] f = new int[row][col];
            f[0][0] = nums[0][0];
            for (int i = 1; i < col; i++) {
                f[0][i] = f[0][i - 1] + nums[0][i];
                f[i][0] = f[i - 1][0] + nums[i][0];
            }
            f[1][1] = nums[1][1] + f[0][1] + f[1][0] - f[0][0];
            for (int i = 1; i <= x; i++) {
                for (int j = 1; j <= y; j++) {
                    f[i][j] = f[i-1][j]+f[i][j-1]+nums[i][j]-f[i-1][j-1];
                }
            }
            return f[x][y];
        }

        public static void main(String[] args) {
            Solution solution = new Solution();
            int[][] nums = {
                    {1, 5, 2, 6},
                    {2, 5, 2, 1},
                    {1, 2, 3, 1},
                    {4, 3, 2, 1}
            };
            int x = 2;
            int y = 2;
            System.out.println(solution.sum(nums, x, y));
        }
    }

继续扩展，目前的方法只能获取从0开始的前缀和，让后扩展到指定起点开始的前缀和，

而[ x1,y1 ]到[ x2,y2 ]的前缀和，闭区间内一定保留 x1 x2 y1 y2 对应的行列，因此需要减去前面的行列，即 f[ x1-1 ][y2] 和 f[ x2 ][ y1-1 ]，由于f[ x1 ][ y1 ]被减去了两次，所以还要再加一次补偿

    static public class Solution {
        public int sum(int[][] nums, int x1, int y1,int x2,int y2) {
            int row = nums.length;
            int col = nums[0].length;
            int[][] f = new int[row][col];
            f[0][0] = nums[0][0];
            for (int i = 1; i < col; i++) {
                f[0][i] = f[0][i - 1] + nums[0][i];
                f[i][0] = f[i - 1][0] + nums[i][0];
            }
            f[1][1] = nums[1][1] + f[0][1] + f[1][0] - f[0][0];
            for (int i = 1; i <= x2; i++) {
                for (int j = 1; j <= y2; j++) {
                    f[i][j] = f[i-1][j]+f[i][j-1]+nums[i][j]-f[i-1][j-1];
                }
            }
            return f[x2][y2]-f[x1-1][y2]-f[x2][y1-1]+f[x1-1][y1-1];
        }

        public static void main(String[] args) {
            Solution solution = new Solution();
            int[][] nums = {
                    {1, 5, 2, 6},
                    {2, 5, 2, 1},
                    {1, 2, 3, 1},
                    {4, 3, 2, 1}
            };
            int x1 = 2;
            int y1 = 2;
            int x2 = 3;
            int y2 = 3;
            System.out.println(solution.sum(nums, x1, y1,x2,y2));
        }
    }