前缀和/差分专题

_Ocean__

已于 2025-07-12 16:54:09 修改

阅读量246

点赞数 2

CC 4.0 BY-SA版权

分类专栏：上机文章标签：算法 leetcode 数据结构

于 2024-08-06 22:43:50 首次发布

本文链接：https://blog.youkuaiyun.com/zjjaibc/article/details/140967900

上机专栏收录该内容

22 篇文章

订阅专栏

参考:

分享丨【算法题单】常用数据结构（前缀和/栈/队列/堆/字典树/并查集/树状数组/线段树）- 讨论 - 力扣（LeetCode）

①一维前缀和模板

int n, m, l, r;
int q[N], s[N];
int main() {
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) 	cin >> q[i];
    for(int i = 1; i <= n; i ++)	s[i] = s[i - 1] + q[i];
    while (m --) {
        int l, r;
        cin >> l >> r;
        cout << s[r] - s[l - 1] << endl;
    }
    return 0;
}

②二维前缀和模板

int n, m, q;
int arr[N][N], s[N][N];

int main() {
    cin >> n >> m >> q;
    for (int i = 1; i <= n; i ++)
        for (int j = 1; j <= m; j ++)
            cin >> arr[i][j];
    for (int i = 1; i <= n; i ++)
        for (int j = 1;j <= m; j ++)
            s[i][j] = arr[i][j] + s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
    while (q --) {
        int x1, x2, y1, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        cout << s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1] << endl;
    }
    return 0;
}

③一维差分模板

a数组相当于diff数组。

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int q[N], a[N];//a为差分数组
int n, m, l, r, c;
void insert(int l, int r, int c) {
    a[l] += c, a[r + 1] -= c;
}
int main() {
    cin >> n >> m;
    for(int i = 1; i <= n; i ++) {
        cin >> q[i] ; insert(i, i, q[i]);//构造差分数组
    }
    while (m --) {
        cin >> l >> r >> c;
        insert(l, r, c);
    }
    for(int i = 1; i <= n; i ++)
        q[i] = q[i - 1] + a[i];//逆向（前缀和）得到原数组
    for(int i = 1; i <= n; i ++)  
        cout << q[i] << " ";
    return 0;
}

④二维差分模板

int a[N][N], q[N][N];
int n, m, Q;
int x1, x2, y1, y2, c;

void insert(int x1, int y1, int x2, int y2, int c) {
    a[x1][y1] += c, a[x1][y2 + 1] -= c, a[x2 + 1][y1] -= c, a[x2 + 1][y2 + 1] += c;
}
int main() {
    cin >> n >> m >> Q;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++) {
            cin >> q[i][j];
            insert(i, j, i, j, q[i][j]);
        }//构造差分数组
    while(Q --) {
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        insert(x1, y1, x2, y2, c);
    }
    //逆向求前缀和
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            q[i][j] = q[i - 1][j] + q[i][j - 1] - q[i - 1][j - 1] + a[i][j];
    for(int i = 1; i <= n; i ++) {
        for(int j = 1; j <= m; j ++)
            cout << q[i][j] << " ";
        cout << endl;
      }
    return 0;
}

一、前缀和

1.前缀和基础

Leetcode 303. 区域和检索 - 数组不可变模板题

class NumArray {
    vector<int> s;
public:
    NumArray(vector<int>& nums) {
        s.resize(nums.size() + 1);
        for (int i = 0; i < nums.size(); i++)
            s[i + 1] = s[i] + nums[i];
    }
    int sumRange(int left, int right) {
        return s[right + 1] - s[left];
    }
};

2 前缀和与哈希表

通常要用到「枚举右，维护左」的技巧。

Leetcode 2845. 统计趣味子数组的数目

预处理：

符合要求的处理成1，不符合要求的处理成0==>方便后续前缀和

问题转化：（带模运算）

到这一步，可以通过枚举r，维护左left得到答案。

Code：

class Solution {
public:
    long long countInterestingSubarrays(vector<int>& nums, int modulo, int k) {
        // 预处理出来 nums[i] % mod 的结果, 满足==k设置为1,否则为0
        int n = nums.size();
        vector<int> sum(n + 1, 0);
        for (int i = 0; i < n; i ++)    // 前缀和统计
            sum[i + 1] = sum[i] + (nums[i] % modulo == k);
        vector<int> cnt(min(n + 1, modulo));    // 哈希表
        long long res = 0;
        for (int s: sum) {
            if (s >= k) res += cnt[(s - k) % modulo];   // s[l]-k的对应个数
            cnt[s % modulo] ++; // 统计更新当前s[r]的信息
        }
        return res;
    }
};

3 距离和

4 前缀异或和

5 其他一维前缀和

Leetcode 238. 除自身以外数组的乘积

优化前：使用前后缀数组记录

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> pre(n, 1), suf(n, 1), ans(n, 0);
        for(int i = 0; i < n; i ++)
            pre[i] = (i==0?1:pre[i - 1]) * nums[i];
        for(int i = n - 1; i >= 0; i --)
            suf[i] = (i==(n - 1)? 1 : suf[i + 1]) * nums[i];
        for(int i = 0; i < n; i ++)
            ans[i] = (i==0?1:pre[i - 1])  * (i==(n-1)?1:suf[i + 1]);
        return ans;
    }
};

优化后：

先计算 pre，然后一边计算 suf，一边把 suf直接乘到 pre[i] 中。最后返回 pre。(注意：suf是从1开始累乘的)

题目说「输出数组不被视为额外空间」，所以该做法的空间复杂度为 O(1)。此外，这种做法比上面少遍历了一次。

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n = nums.size();
        vector<int> pre(n, 1);
        // 计算出前缀和数组
        for(int i = 1; i < n; i ++)
            pre[i] = pre[i - 1] * nums[i - 1];
        // 针对前缀和数组补上后缀计算部分即可
        int suf = 1;
        for(int i = n - 1; i >= 0; i --){
            pre[i] = pre[i] * suf;
            suf *= nums[i];
        }
        return pre;
    }
};

6 二维前缀和

Leetcode 3148. 矩阵中的最大得分

核心：

模拟过程，发现只与起点和终点的值相关，联想到重力势能
可以维护一个二维的前缀最小值，当前值grid(i, j) - 当前矩阵除了当前当前元素的min（提前维护好了）

class Solution {
public:
    int maxScore(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size(), ans = INT_MIN;
        vector<vector<int>> pre(n + 1, vector<int>(m + 1, INT_MAX));    // 这边要初始化为max(因为要维护的是前缀的最小值)
        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++){
                int t = min(pre[i + 1][j], pre[i][j + 1]);
                ans = max(ans, grid[i][j] - t);
                pre[i + 1][j + 1] = min(t, grid[i][j]);
            }
        return ans;
    }
};

在实现过程中，由于数组下标是从0开始的，为了防止数组越界，使用pre[i + 1][j + 1]表示矩阵[0,i][0,j]的min.

二、差分

1 一维差分（扫描线）

Leetcode 3355. 零数组变换 I

思路：核心在于每一个区间的子集选择对应元素减去1。直接从0开始差分数组，计算差分数组的前缀和之后与nums数组逐个元素进行比较。

Code：
class Solution {
public:
    const static int N = 1e5 + 10;
    int a[N];
    void insert(int l, int r, int v) {
        a[l] += v, a[r + 1] -= v; 
    }
    bool isZeroArray(vector<int>& nums, vector<vector<int>>& queries) {
        memset(a, 0, sizeof a);
        int n = nums.size();
        for (auto& v: queries)     insert(v[0], v[1], 1);
        for (int i = 1; i < n; i ++) a[i] += a[i - 1]; 
        for (int i = 0; i < n; i ++)
            if (nums[i] > a[i]) return false;
        return true;
    }
};
拓展：参考leetcod 3356（二分+差分）

Leetcode 1450. 在既定时间做作业的学生人数

本题可以简单做，但是如果是1e5的查询，那就得差分。

class Solution {
public:
    const static int N = 1e5 + 10;
    int a[N];
    void insert(int l, int r){
        a[l] += 1, a[r + 1] -= 1;
    }
    int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
        memset(a, 0, sizeof(a));
        int n = startTime.size();
        int maxt = 0;
        int res = 0;
        // 差分数组预处理出来
        for(int i = 0; i < n; i ++){
            int st = startTime[i], ed = endTime[i];
            maxt = max(maxt, ed);
            insert(st, ed);
        }
        for(int i = 1; i <= maxt + 1; i ++) a[i] += a[i - 1];   // 这边边界是maxt + 1
        return a[queryTime];
    }
};

二分方法：sort从集合的角度思考

Leetcode 3169. 无需开会的工作日

思路：

这种区间统一减去一个数字-->第一反应差分。可是数据范围卡到了1e9，正常的差分方法会爆内存。

class Solution {
public:
    // 前缀和差分
    int countDays(int days, vector<vector<int>>& meetings) {
        int res = 0;
        vector<bool> a(days + 2, 1);    // 原始数组
        vector<int> b(days + 2, 0);    // 差分
        for (auto& x: meetings) {
            b[x[0]] -= 1;
            b[x[1] + 1] += 1;
        }   a[0] = 1;
        for (int i = 1; i <= days; i ++)    b[i] = b[i] + b[i - 1];
        for (int i = 1; i <= days; i ++) {
            a[i] = (a[i] + b[i]) > 0;
            res += a[i];
        }return res;
    }
};

此时，可以离散化，使用有序的map当做diff，这样就不用担心报MLE了。（int数组似乎只能开1e6左右，开bool差不多1e7？，总之，这里1e9不管开int还是bool都会MLE）。

class Solution {
public:
    // 前缀和差分
    int countDays(int days, vector<vector<int>>& meetings) {
        int res = 0;
        map<int, int> diff;
        for (auto& x: meetings) {
            diff[x[0]] += 1;
            diff[x[1] + 1] -= 1;        // 注意这里的右区间是+1,下面要补上这个1
        }
        int s = 0, left = 1;
        for (auto& [i, d]: diff) {
            if (s == 0) {   // 只有可能在x[1] + 1即区间右侧让s=0(区间闭合)
                res += i - left;
            }
            s += d;
            left = i;
        }
        // 处理末尾，没有diff标记的
        if (s == 0) res += days - left + 1; // 这边left是原始区间+1，所以这里要补一个+1
        return res;
    }
};

复杂度还是很高，更好的写法“区间贪心”见贪心专题，正难则反。