前缀和算法详解：一维与二维前缀和模板实现

025【模板】一维前缀和

1.1 算法思路：前缀和

先预处理出来一个【前缀和】数组——用 dp[i] 表示。
- [1, i] 区间内所有元素的和，那么 dp[i-1] 里面存的就是 [1, i-1] 区间内所有元素的和。
- 递推公式：dp[i] = dp[i-1] + arr[i]。
使用前缀和数组，【快速】求出【某一个区间内】所有元素的和：
- 当询问的区间是 [l, r] 时：区间内所有元素的和为：dp[r] - dp[l-1]。

1.2 算法实现

1.2.1 C++ 实现

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 1、读入数据
    int n, m;
    cin >> n >> m;
    vector<int> arr(n + 1);
    for(int i = 1; i <= n; i++) cin >> arr[i];

    // 2、预处理出来一个前缀和数组
    vector<long long> dp(n + 1);
    for(int i = 1; i <= n; i++) dp[i] = dp[i - 1] + arr[i];

    // 3、使用前缀和数组
    int l = 0, r = 0;
    while(m--) {
        cin >> l >> r;
        cout << dp[r] - dp[l - 1] << endl;
    }
    return 0;
}

时间复杂度：O(1)，空间复杂度：O(1)。

1.2.2 Java 实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int q = scan.nextInt();
        
        // 为了防止溢出，用 long 类型的数组
        int[] arr = new int[n + 1];
        long[] dp = new long[n + 1];
        
        for (int i = 1; i <= n; i++) {
            arr[i] = scan.nextInt();
        }
        
        for (int i = 1; i <= n; i++) {
            dp[i] = dp[i - 1] + arr[i];
        }
        
        while (q > 0) {
            int l = scan.nextInt();
            int r = scan.nextInt();
            System.out.println(dp[r] - dp[l - 1]);
            q--;
        }
    }
}

时间复杂度：O(1)，空间复杂度：O(1)。

026【模板】二维前缀和

2.1 算法思路：前缀和

类比于一维数组的形式，如果我们能处理出来从 [0, 1] 位置到 [i, j] 位置这片区域内所有元素的累加和，就可以在 O(1) 的时间内，搞定矩阵内任意区域内所有元素的累加和。

2.1.1 第一步：搞出来前缀和矩阵

在矩阵的最上面和最左边添加上一行和一列 0，这样可以省去非常多的边界条件的处理。处理后的矩阵下标直接从开始，能大胆使用 i-1，j-1 位置的值。

注意 dp 表与原数组 matrix 内的元素的映射关系：

从 dp 表到 matrix 矩阵，横纵坐标减一；
从 matrix 矩阵到 dp 表，横纵坐标加一。

2.1.2 前缀和矩阵中 sum[i][j] 的含义及递推方程

sum[i][j] 的含义
- 表示从 [0, 0] 位置到 [i, j] 位置这段区域内，所有元素的累加和。
递推方程
- 将 [0, 0] 到 [i, j] 的区域分解：
  - sum[i][j] = 红 + 蓝 + 绿 + 黄
- 分析四块区域：
  - 黄色部分：matrix[i-1][j-1]
  - 红 + 蓝：sum[i-1][j]
  - 红 + 绿：sum[i][j-1]
  - 多算了一部分红的面积：sum[i-1][j-1]
- 综上所述，递推方程为：
  - sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + matrix[i-1][j-1]

2.1.3 第二步：使用前缀和矩阵

题目接口参数是原始矩阵下标，需先映射成 dp 表对应的下标（row1++, col1++, row2++, col2++）。

对于左上角 (row1, col1)、右下角 (row2, col2) 围成的区域（红色部分），利用容斥原理计算：

整个面积：sum[row2][col2]
减去上方和左方多余部分：sum[row2][col1-1] + sum[row1-1][col2]
加上重复减去的左上角部分：sum[row1-1][col1-1]

计算公式： sum[row2][col2] - sum[row2][col1 - 1] - sum[row1 - 1][col2] + sum[row1 - 1][col1 - 1]

2.2 算法实现

2.2.1 C++ 实现

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 1. 读入数据
    int n = 0, m = 0, q = 0;
    cin >> n >> m >> q;
    vector<vector<int>> arr(n + 1, vector<int>(m + 1));
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; j++)
            cin >> arr[i][j];

    // 2. 预处理前缀和矩阵
    vector<vector<long long>> dp(n + 1, vector<long long>(m + 1));
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1] + arr[i][j] - dp[i - 1][j - 1];

    // 3. 使用前缀和矩阵
    int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
    while(q--) {
        cin >> x1 >> y1 >> x2 >> y2;
        cout << dp[x2][y2] - dp[x1 - ][y2] - dp[x2][y1 - ] + dp[x1 - ][y1 - ] << endl;
    }
     ;
}

时间复杂度：O(1)，空间复杂度：O(1)。

2.2.2 Java 实现

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int q = in.nextInt();
        
        int[][] arr = new int[n + 1][m + 1];
        long[][] dp = new long[n + 1][m + 1];
        
        // 读入数据
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                arr[i][j] = in.nextInt();
        
        // 处理前缀和矩阵
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                dp[i][j] = dp[i - ][j] + dp[i][j - ] - dp[i - ][j - ] + arr[i][j];
        
        
         (q > ) {
               in.nextInt(), y1 = in.nextInt(), x2 = in.nextInt(), y2 = in.nextInt();
            System.out.println(dp[x2][y2] - dp[x1 - ][y2] - dp[x2][y1 - ] + dp[x1 - ][y1 - ]);
            q--;
        }
    }
}

时间复杂度：O(1)，空间复杂度：O(1)。

前缀和算法详解：一维与二维前缀和模板实现

更多推荐文章

相关免费在线工具

025【模板】一维前缀和

1.1 算法思路：前缀和

1.2 算法实现

1.2.1 C++ 实现

1.2.2 Java 实现

026【模板】二维前缀和

2.1 算法思路：前缀和

2.1.1 第一步：搞出来前缀和矩阵

2.1.2 前缀和矩阵中 sum[i][j] 的含义及递推方程

2.1.3 第二步：使用前缀和矩阵

2.2 算法实现

2.2.1 C++ 实现

2.2.2 Java 实现

前缀和算法详解：一维与二维前缀和模板实现

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具

025【模板】一维前缀和

1.1 算法思路：前缀和

1.2 算法实现

1.2.1 C++ 实现

1.2.2 Java 实现

026【模板】二维前缀和

2.1 算法思路：前缀和

2.1.1 第一步：搞出来前缀和矩阵

2.1.2 前缀和矩阵中 sum[i][j] 的含义及递推方程

2.1.3 第二步：使用前缀和矩阵

2.2 算法实现

2.2.1 C++ 实现

2.2.2 Java 实现