二维前缀和数组&二维差分数组

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量1.9k 收藏 5
点赞数 1
分类专栏： 算法总结 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tikitian/article/details/128738181
版权

二维前缀和数组&二维差分数组

一维前缀和

  • 用途：快速求出数组中 n u m s [ i , j ] nums[i,j] nums[i,j]元素之和

  • 定义： s u m s [ i + 1 ] sums[i+1] sums[i+1]为nums数组前 i i i个元素之和
    s u m s [ i + 1 ] = ∑ j = 0 i n u m s [ j ] sums[i + 1] = \sum _{j=0} ^{i}nums[j] sums[i+1]=j=0∑i​nums[j]

  • 因此，可以快速计算出数组中 n u m s [ i , j ] nums[i,j] nums[i,j]元素之和为 s u m [ j + 1 ] − s u m [ i ] sum[j+1]-sum[i] sum[j+1]−sum[i]

一维差分

  • 定义：差分数组的每一项都是原数组该项与上一项的差
    d [ i ] = a [ i ] − a [ i − 1 ] d[i]=a[i]-a[i-1] d[i]=a[i]−a[i−1]

  • 用途：常用于区间修改，如对原始数组a[n]内一段区间上的数值进行加减操作，则:

    • 在差分数组d[n]选定区间[l,r]，确认加减数值x

    d [ l ] + = x d [ r + 1 ] − = x d[l] += x \\d[r+1] -= x d[l]+=xd[r+1]−=x

    • 然后对该数组求累加和数组，就得到了变化后的数组

  • 例如

    index012345
    原始数组023758
    原差分数组0214-23
    操作：对区间[1,3]+35610
    现差分数组0514-53
    累加和数组0561058

二维前缀和

  • 「二维前缀和」解决的是二维矩阵中的矩形区域求和问题。

  • 二维前缀和数组中的每一个格子记录的是「**以当前位置为区域的右下角（区域左上角恒定为原数组的左上角）**的区域和」【应该不固定 可以倒转】
    s u m [ i , j ] = s u m [ i − 1 ] [ j ] + s u m [ i ] [ j − 1 ] − s u m [ i − 1 ] [ j − 1 ] + m a t r i x [ i ] [ j ] sum[i,j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+matrix[i][j] sum[i,j]=sum[i−1][j]+sum[i][j−1]−sum[i−1][j−1]+matrix[i][j]
    1.png

  • 因此，如果要求 (x1, y1) 作为左上角，(x2, y2) 作为右下角的区域和的时候，可以直接利用二维前缀和数组快速求解：
    r e s = s u m [ x 2 ] [ y 2 ] − s u m [ x 1 − 1 ] [ y 2 ] − s u m [ x 2 ] [ y 1 − 1 ] + s u m [ x 1 − 1 ] [ y 1 − 1 ] res=sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1] res=sum[x2][y2]−sum[x1−1][y2]−sum[x2][y1−1]+sum[x1−1][y1−1]

二维差分

  • 「二维差分」解决的是二维矩阵中的矩形区域值的变化问题。

  • 两种情况：以当前位置为左上角或右下角

  • 左上角

    • 二维数组某个位置 ( x 1 , y 1 ) (x1,y1) (x1,y1)的变化量，可由二维差分数组的二维前缀和数组得到，即以当前位置为左上角，原数组的右下角为右下角的区域和

    • 二维差分数组中的每一个格子记录的是「以当前位置为区域的右下角（区域左上角恒定为原数组的左上角）的值的变化量」【应该不固定 可以倒转】

    • 因此，如果要求 ( x 1 , y 1 ) (x1, y1) (x1,y1) 作为左上角， ( x 2 , y 2 ) (x2, y2) (x2,y2) 作为右下角的区域值增加 x x x的时候，可以利用二维差分数组快速求解，此时相当于二维差分矩阵上对 ( x 2 , y 2 ) (x2,y2) (x2,y2)增加 x x x，对 ( x 2 , y 1 − 1 ) (x2,y1-1) (x2,y1−1)和 ( x 1 − 1 , y 2 ) (x1-1,y2) (x1−1,y2)减小 x x x，再对重复区域 ( x 1 − 1 , y 1 − 1 ) (x1-1,y1-1) (x1−1,y1−1)增加 x x x

    • 二维数组某个位置 ( x 1 , y 1 ) (x1,y1) (x1,y1)的变化量，可由二维差分数组的二维前缀和数组sum得到，即以当前位置为左上角，原数组的右下角为右下角的区域和【倒叙求】
      s u m [ i , j ] = s u m [ i + 1 ] [ j ] + s u m [ i ] [ j + 1 ] − s u m [ i + 1 ] [ j + 1 ] + d e v [ i ] [ j ] sum[i,j] = sum[i+1][j]+sum[i][j+1]-sum[i+1][j+1]+dev[i][j] sum[i,j]=sum[i+1][j]+sum[i][j+1]−sum[i+1][j+1]+dev[i][j]

  • 右下角【常用】

    • 二维数组某个位置 ( x 1 , y 1 ) (x1,y1) (x1,y1)的变化量，可由二维差分数组的二维前缀和数组得到，即以当前位置为右下角，原数组的左上角为左上角的区域和

    • 二维差分数组中的每一个格子记录的是「以当前位置为区域的左上角（区域右下角恒定为原数组的右下角）的值的变化量」【应该不固定 可以倒转】

    • 因此，如果要求 ( x 1 , y 1 ) (x1, y1) (x1,y1) 作为左上角， ( x 2 , y 2 ) (x2, y2) (x2,y2) 作为右下角的区域值增加 x x x的时候，可以利用二维差分数组快速求解，此时相当于二维差分矩阵上对 ( x 1 , y 1 ) (x1,y1) (x1,y1)增加 x x x，对 ( x 2 + 1 , y 1 ) (x2+1,y1) (x2+1,y1)和 ( x 1 , y 2 + 1 ) (x1,y2+1) (x1,y2+1)减小 x x x，再对重复区域 ( x 2 + 1 , y 2 + 1 ) (x2+1,y2+1) (x2+1,y2+1)增加 x x x

    • 要求得二维数组每个位置 ( x 1 , y 1 ) (x1,y1) (x1,y1)的变化量，即求二维差分数组的二维前缀和数组sum，即差分数组以当前位置为右下角，原数组的左上角为左上角的区域和
      s u m [ i , j ] = s u m [ i − 1 ] [ j ] + s u m [ i ] [ j − 1 ] − s u m [ i − 1 ] [ j − 1 ] + d e v [ i ] [ j ] sum[i,j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+dev[i][j] sum[i,j]=sum[i−1][j]+sum[i][j−1]−sum[i−1][j−1]+dev[i][j]

  • 总结

    • 二维差分数组可视为以位置[i,j]为右下角原点为右上角的区域之和【二维前缀和数组 s u m [ i ] [ j ] sum[i][j] sum[i][j]】与该区域除了位置[i,j]的区域和之差，用二维前缀和数组可表示为

    d i v [ i ] [ j ] = s u m [ i ] [ j ] − s u m [ i − 1 ] [ j ] − s u m [ i ] [ j − 1 ] + s u m [ i + 1 ] [ j + 1 ] div[i][j]=sum[i][j] - sum[i-1][j]-sum[i][j-1]+sum[i+1][j+1] div[i][j]=sum[i][j]−sum[i−1][j]−sum[i][j−1]+sum[i+1][j+1]

    image-20230118214317962

    • 因此若已知二维数组a，求得其二维前缀和数组b，那么a即为b的差分数组

  • 用途：将某一区域的值进行变化，首先求出差分数组，然后对该求出二维前缀和数组，即可求得变化后的结果

  • 模板：由区域变化量求得二维差分数组，由二维差分数组求前缀和数组

    二维差分数组div中的每一个格子记录的是「以当前位置为区域的左上角（区域右下角恒定为原数组的右下角）的值的变化量」【应该不固定 可以倒转】

    二维差分数组的二维前缀和数组sum，即差分数组以当前位置为右下角，原数组的左上角为左上角的区域和

    • 初始时div数组需要扩展边界，转化为sum时需要处理0

      class Solution {
    public int[][] rangeAddQueries(int n, int[][] queries) {
        int[][] div = new int[n + 1][n + 1];
        for (int[] q : queries){
            div[q[0]][q[1]]++;
            div[q[0]][q[3] + 1]--;
            div[q[2] + 1][q[1]]--;
            div[q[2] + 1][q[3] + 1]++;
        }
        int[][] sum = new int[n][n];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                sum[i][j] = div[i][j];
                if (i != 0) sum[i][j] += sum[i - 1][j];
                if (j != 0) sum[i][j] += sum[i][j - 1]; 
                if (i != 0 && j != 0) sum[i][j] -= sum[i - 1][j - 1];
            }
        }
        return sum;
    }
}

    • div数组边界可以+2，方便处理0

      d i v [ 1 : n ] [ 1 : n ] div[1:n][1:n] div[1:n][1:n]计算为二维前缀和数组，在赋值给结果集

      class Solution {
    public int[][] rangeAddQueries(int n, int[][] queries) {
        int[][] div = new int[n + 2][n + 2];
        for (int[] q : queries){
            div[q[0] + 1][q[1] + 1]++;
            div[q[0] + 1][q[3] + 2]--;
            div[q[2] + 2][q[1] + 1]--;
            div[q[2] + 2][q[3] + 2]++;
        }
        int[][] sum = new int[n][n];
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                sum[i - 1][j - 1] = (div[i][j] += div[i - 1][j] + div[i][j - 1] - div[i - 1][j - 1]);
            }
        }
        return sum;
    }
}

  • 模板：由前缀和数组求得二维差分数组即求出每个位置的数值

    	// sum n*n
	// div (n+1)*(n+1)
	//求出差分数组
	for(int i=1;i<=n;i++)
		for(int j=1;j<=m;j++){
			div[i][j]=sum[i][j]-sum[i-1][j]-sum[i][j-1]+sum[i-1][j-1]; 
	}

相关题目

子矩阵元素加 1【LC2536】

给你一个正整数 n ，表示最初有一个 n x n 、下标从 0 开始的整数矩阵 mat ，矩阵中填满了 0 。

另给你一个二维整数数组 query 。针对每个查询 query[i] = [row1i, col1i, row2i, col2i] ，请你执行下述操作：

  • 找出 左上角 为 (row1i, col1i) 且 右下角 为 (row2i, col2i) 的子矩阵，将子矩阵中的 每个元素 加 1 。也就是给所有满足 row1i <= x <= row2i 和 col1i <= y <= col2i 的 mat[x][y] 加 1 。

返回执行完所有操作后得到的矩阵 mat 。

暴力

java过了…

class Solution {
    public int[][] rangeAddQueries(int n, int[][] queries) {
        int[][] mat = new int[n][n];
        for (int[] query : queries){
            int row1 = query[0], col1 = query[1], row2 = query[2], col2 = query[3];
            for (int i = row1; i <= row2; i++){
                for (int j = col1; j <= col2; j++){
                    mat[i][j]++;
                }
            }
        }
        return mat;

    }
}
  • 复杂度
    • 时间复杂度： O ( n 2 ∗ q ) O(n^2*q) O(n2∗q)， q q q为 q u e r i e s queries queries的长度
    • 空间复杂度： O ( 1 ) O(1) O(1)
二维差分

前置知识：二维差分数组与二维前缀和数组

  • 思路：使用二维差分数组记录每个区域的变化量，然后通过二维前缀和数组求得每个位置的值

  • 实现

    • 二维差分数组div中的每一个格子记录的是「以当前位置为区域的左上角（区域右下角恒定为原数组的右下角）的值的变化量」【应该不固定 可以倒转】

    • 二维差分数组的二维前缀和数组sum，即差分数组以当前位置为右下角，原数组的左上角为左上角的区域和

    • 因此，如果要求 ( x 1 , y 1 ) (x1, y1) (x1,y1) 作为左上角， ( x 2 , y 2 ) (x2, y2) (x2,y2) 作为右下角的区域值增加 x x x的时候，可以利用二维差分数组快速求解，此时相当于二维差分矩阵上对 ( x 1 , y 1 ) (x1,y1) (x1,y1)增加 x x x，对 ( x 2 + 1 , y 1 ) (x2+1,y1) (x2+1,y1)和 ( x 1 , y 2 + 1 ) (x1,y2+1) (x1,y2+1)减小 x x x，再对重复区域 ( x 2 + 1 , y 2 + 1 ) (x2+1,y2+1) (x2+1,y2+1)增加 x x x

    • 要求得二维数组每个位置 ( x 1 , y 1 ) (x1,y1) (x1,y1)的变化量，即求二维差分数组的二维前缀和数组sum，即差分数组以当前位置为右下角，原数组的左上角为左上角的区域和
      s u m [ i , j ] = s u m [ i − 1 ] [ j ] + s u m [ i ] [ j − 1 ] − s u m [ i − 1 ] [ j − 1 ] + d e v [ i ] [ j ] sum[i,j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+dev[i][j] sum[i,j]=sum[i−1][j]+sum[i][j−1]−sum[i−1][j−1]+dev[i][j]

      • 初始时div数组需要扩展边界，转化为sum时需要处理0

        class Solution {
    public int[][] rangeAddQueries(int n, int[][] queries) {
        int[][] div = new int[n + 1][n + 1];
        for (int[] q : queries){
            div[q[0]][q[1]]++;
            div[q[0]][q[3] + 1]--;
            div[q[2] + 1][q[1]]--;
            div[q[2] + 1][q[3] + 1]++;
        }
        int[][] sum = new int[n][n];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                sum[i][j] = div[i][j];
                if (i != 0) sum[i][j] += sum[i - 1][j];
                if (j != 0) sum[i][j] += sum[i][j - 1]; 
                if (i != 0 && j != 0) sum[i][j] -= sum[i - 1][j - 1];
            }
        }
        return sum;
    }
}
        • 复杂度
          • 时间复杂度： O ( n 2 + q ) O(n^2+q) O(n2+q)， q q q为 q u e r i e s queries queries的长度
          • 空间复杂度： O ( 1 ) O(1) O(1)

      • div数组边界可以+2，方便处理0

        d i v [ 1 : n ] [ 1 : n ] div[1:n][1:n] div[1:n][1:n]计算为二维前缀和数组，在赋值给结果集

        class Solution {
    public int[][] rangeAddQueries(int n, int[][] queries) {
        int[][] div = new int[n + 2][n + 2];
        for (int[] q : queries){
            div[q[0] + 1][q[1] + 1]++;
            div[q[0] + 1][q[3] + 2]--;
            div[q[2] + 2][q[1] + 1]--;
            div[q[2] + 2][q[3] + 2]++;
        }
        int[][] sum = new int[n][n];
        for (int i = 1; i <= n; i++){
            for (int j = 1; j <= n; j++){
                sum[i - 1][j - 1] = (div[i][j] += div[i - 1][j] + div[i][j - 1] - div[i - 1][j - 1]);
            }
        }
        return sum;
    }
}

  • 进阶：子矩阵元素变化量不定

二维区域和检索 - 矩阵不可变【LC304】

Given a 2D matrix matrix, handle multiple queries of the following type:

  • Calculate the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).

Implement the NumMatrix class:

  • NumMatrix(int[][] matrix) Initializes the object with the integer matrix matrix.
  • int sumRegion(int row1, int col1, int row2, int col2) Returns the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).

You must design an algorithm where sumRegion works on O(1) time complexity.

  • 思路：在构造方法中生成矩阵matrix的二维累加和数组，在sumRegion方法中通过累加和数组返回指定区域的和

  • 实现

    二维前缀和数组sum，即以当前位置为右下角，matrix数组的左上角为左上角的区域和

    为了方便处理边界0，将sum数组的周围扩展1

    class NumMatrix {
    int[][] sum;
    int m;
    int n;
    public NumMatrix(int[][] matrix) {
        m = matrix.length;
        n = matrix[0].length;
        sum = new int[m + 1][n + 1];
        for (int i = 0; i < m; i++){
            for (int j = 0; j < n; j++){
                sum[i + 1][j + 1] = sum[i][j + 1] + sum[i + 1][j] + matrix[i][j] - sum[i][j]; 
            }
        }
    }
    
    public int sumRegion(int row1, int col1, int row2, int col2) {
        return sum[row2 + 1][col2 + 1] + sum[row1][col1] - sum[row1][col2 + 1] - sum[row2 + 1][col1];
    } 
}

/**
 * Your NumMatrix object will be instantiated and called as such:
 * NumMatrix obj = new NumMatrix(matrix);
 * int param_1 = obj.sumRegion(row1,col1,row2,col2);
 */
    • 复杂度
      • 时间复杂度：构造方法的时间复杂度为生成二维前缀和数组的时间复杂度 O ( m ∗ n ) O(m*n) O(m∗n),sumRegion的时间复杂度为 O ( 1 ) O(1) O(1)
      • 空间复杂度： O ( m ∗ n ) O(m*n) O(m∗n)
TIkitianya
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法-前缀和数组、差分数组
u011764940的博客
11-04 1231
nums[n] = {a1, a2, ...., an-1}; preSum[n + 1] = {0, a1, a1 + a2, ...., a1+..+an-1}; [i, j]之间元素的和(包括i, j)：preSum[j+ 1] - preSum[i]
某学长讲课ppt（前缀和与差分，二维前缀和与差分）
03-23
一维前缀和与差分的计算：通过具体案例和计算步骤，详细展示如何构造一维前缀和数组，以及如何根据前缀和数组计算差分数组，同时强调它们在算法优化中的应用。 二维前缀和与差分的计算：在一维的基础上，进一步讲解...
JavaScript刷题——前缀和数组、差分数组
ronghwa_lu
01-10 1001
303.区域和检索 - 数组不可变 已知一维数组长度，创建数组： const preSum = new Array(nums.length + 1); 而我是先赋值第一个元素，再push添加新元素： this.arr = [nums[0]] 304.二维区域和检索 - 矩阵不可变 创建二维数组： const preSum = new Array(rows) for (let i = 0; i < rows; i++) { preSum[i] = new Array(cols) } 560.和为
【学习总结】一、二维前缀和 && 一、二维差分
m0_74215326的博客
03-19 9065
【学习总结】一、二维前缀和 && 一、二维差分
【模板】二维前缀和与二维差分
脚踏实地，仰望星空
03-22 4169
1.二维前缀和 1.1 求解二维前缀和数组 1.2 区间查询 2.二维差分 2.1 定义 2.2 区间修改 2.3 初始化
前缀和——（2）二维数组前缀和
热门推荐
努力中的老周的专栏
12-30 2万+
前面部分我们介绍了一维前缀和https://blog.csdn.net/justidle/article/details/103524440。下面我们扩展一下，来介绍二维前缀和。 什么是二维前缀和 比如我们有这样一个矩阵a，如下所示： 1 2 4 3 5 1 2 4 6 3 5 9 我们定义一个矩阵sum，其中，那么这个矩阵就是这样的： 1 3 7 10 6 9 15 22...
差分数组详解，一维二维差分
EQUINOX1的博客
12-14 1214
从一维差分到二位差分，你学会了吗？
数据结构与算法(十二) 前缀和与差分数组
半虹小站
05-09 1226
大家好，我是半虹，这篇文章讲前缀和与差分数组
Python数据结构与算法篇（二）-- 前缀和与差分数组
CarpeDiem
03-12 1653
前缀和主要适用的场景是原始数组不会被修改的情况下，适用于快速、频繁地计算一个索引区间内的元素之和以及频繁查询某个区间的累加；差分数组的主要适用场景是频繁对原始数组的某个区间的元素进行增减。本节主要学习算法的原理，结合LeetCode题目分析如何使用这些技巧。
算法设计 - 前缀和 & 差分数列
伏城之外的博客
02-10 5244
前缀和 & 差分数列
二维数组前缀和 前缀和 课程zb
01-19
对于一个一维数组，前缀和是指数组中连续子数组的和，例如，对于数组a[1...n]，前缀和数组preSum[i]表示a[1...i]的和。二维数组前缀和是这个概念的扩展，它计算的是矩阵中所有左上角为(s1, s2)、右下角为(e1, e2)的...
前缀和与差分算法地深入理解
07-11
设矩阵a：a[i][j]，则其二维前缀和数组s：s[i][j] = s[i-1][j] + s[i][j-1] - s[i-1][j-1] + a[i][j]。二维前缀和的应用之一是计算矩阵中某个子矩阵的和。我们可以使用二维前缀和来计算以(x1,y1)为左上角和以(x2,y2)...
前缀和详22解1.zip
03-31
4. **频数统计**：在处理二维数组时，可以使用前缀和进行二维区间查询，从而统计特定区间内的元素出现频率。 5. **数据结构设计**：例如，单调栈结合前缀和可以实现动态维护区间最大值或最小值。 在学习前缀和的...
[宫水三叶的刷题日记]：前缀和1
08-03
在Java中，可以创建一个类`NumMatrix`，其中包含一个二维前缀和数组`sum`，以及一个构造函数用于初始化前缀和。`sumRegion`方法接受四个参数，用于查询矩形区域的和，并使用前缀和公式计算结果。 6. **学习与实践*...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 947
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 237
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 253
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 310
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
二维前缀和
05-25
二维前缀和（2D Prefix Sum）是指对于一个二维数组，通过预处理得到一个新的数组，该数组中每个元素的值为原数组中以该元素为右下角的子矩阵的所有元素之和。其可以用于快速计算出二维矩阵区域和。 具体实现方法为，先预处理出一个二维前缀和数组，然后通过该数组计算出任意两个坐标所确定的矩形区域的和。 下面给出 C++ 实现代码供参考： ```cpp const int MAXN = 1005; int a[MAXN][MAXN], s[MAXN][MAXN]; // 计算二维前缀和 void prefix_sum(int n, int m) { for (int i = 1; i <= n; ++i) { for (int j = 1; j <= m; ++j) { s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + a[i][j]; } } } // 计算以 (x1, y1) 为左上角，以 (x2, y2) 为右下角的矩形区域的和 int query(int x1, int y1, int x2, int y2) { return s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1]; } ``` 其中，`a` 数组是原始的二维数组，`s` 数组是计算得到的二维前缀和数组。`prefix_sum` 函数用于计算二维前缀和，`query` 函数用于查询任意矩形区域的和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值