前缀和与差分专题-优快云博客

本文链接：https://blog.youkuaiyun.com/wirepuller_king/article/details/144946318

广义的“前缀和”运算是指连续的进行若干次操作，产生一个叠加影响，如果这种影响可以通过某种反向操作“撤销”。

前缀乘

给定一个长度大小为N{N}N的正整数数组，查询M{M}M轮，每次问一个区间所有元素的连续乘积。

由于这个答案可能很大，你只用输出结果对1e9+7取余数后的结果即可。

输入

5 3
5 2 3 10 6
1 5
2 3
2 5

输出

1800
6
360

AC代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
const int mod = 1e9+7;
int qpow(int a, int b){
    int res = 1;
    while (b){
        if (b&1)  res=(res*a)%mod;
        b >>= 1;
        a=(a*a)%mod;
    }
    return res;
}
int getInv(int a){   // 乘法逆元
    return qpow(a, mod-2);
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n, m;
    cin >> n >> m;
    vector<int> a(n+1), pre(n+1);
    pre[0] = 1;
    for (int i = 1; i<=n; i++){
        cin >> a[i];
        pre[i] = pre[i-1]*a[i]%mod;
    }
    while (m--){
        int l, r;
        cin >> l >> r;
        int ans = pre[r]*getInv(pre[l-1])%mod;
        cout << ans << endl;
    }
    
    return 0;
}

二维前缀和

前缀和的优点：

高效查询区间和：通过预先计算前缀和数组，可以在常数时间内查询任意区间的和。例如，对于数组 a，其前缀和数组 s 中 s[r] - s[l-1] 就是区间 [l, r] 的和。

领地选择

作为在虚拟世界里统帅千军万马的领袖，小 Z 认为天时、地利、人和三者是缺一不可的，所以，谨慎地选择首都的位置对于小 Z 来说是非常重要的。

首都被认为是一个占地 C×C 的正方形。小 Z 希望你寻找到一个合适的位置，使得首都所占领的位置的土地价值和最高。

第一行三个整数 N,M,CN,M,C，表示地图的宽和长以及首都的边长。

接下来 NN 行每行 MM 个整数，表示了地图上每个地块的价值。价值可能为负数。

输入数据

3 4 2
1 2 3 1
-1 9 0 2
2 0 1 1

输出数据

1 2

AC代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	
	int n, m, c;
	cin >> n >> m >> c;
	vector<vector<int>> a(n+1, vector<int>(m+1, 0)), g(n+1, vector<int>(m+1,0));
	for (int i=1; i<=n; i++){
		for (int j = 1; j<=m; j++){
			cin >> a[i][j];
			g[i][j] = g[i][j-1]+g[i-1][j]-g[i-1][j-1]+a[i][j];
		}
	}
	int max = -1e9, mai=0,maj=0;
	for (int i = c; i<=n; i++){
		for (int j = c; j <=m; j++){
			int ans = g[i][j]-g[i][j-c]-g[i-c][j]+g[i-c][j-c];
			if (ans > max){
				max = ans;
				mai = i-c+1;
				maj = j-c+1;
			}
		}
	}
	cout << mai << " " << maj << endl;
	return 0;
}

前缀置换

准备了10个小球，小球的编号从0~9。用10个不透明的杯子倒扣住，按照一定的操作顺序以极快的速度交换这些杯子，有一个长度大小为n的操作序列，每一行表示一次操作都有两个非负整数a,b，表示本次操作将会交换从左往右数第a个杯子和从左往右数第b个杯子（a和b均从0开始数）。

一共玩了m次猜球游戏，第i轮游戏中会按照操作序列中的第 $l_i$ 个操作开始做，一直做到第 $r_i$ 个操作结束（l和r的编号从1开始计算）。回答出牛牛每一轮游戏结束时，从左至右的杯子中小球的编号各是多少。

输入

5 3
0 1
1 2
2 3
0 1
9 0
1 5
5 5
3 5

输出

9 1 3 0 4 5 6 7 8 2
9 1 2 3 4 5 6 7 8 0
9 0 3 2 4 5 6 7 8 1

AC代码：

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct ballList {
    int pos[10];
};
ostream & operator << (ostream& os, const ballList &ob) {  //自定义操作符"<<"
    for (int i = 0; i < 10; ++i) {
        if (i)os << ' ';
        os << ob.pos[i];
    }
    return os;
}
ballList operator - (const ballList A, const ballList B) {  //自定义操作符"-"
    ballList C, temp, D;
    for (int i = 0; i < 10; ++i) {
        temp.pos[B.pos[i]] = i;
    }
    // cout << "temp[]=" << temp << endl;
    for (int i = 0; i < 10; ++i) {
        C.pos[i] = temp.pos[A.pos[i]];
    }
    return C;
}
ballList presum[MAXN];
int n, m, u[MAXN], v[MAXN], l, r;
// ballList bf(int l, int r) {
//     ballList ret;
//     for (int i = 0; i < 10; ++i) {
//         ret.pos[i] = i;
//     }
//     for (int i = l; i <= r; ++i) {
//         swap(ret.pos[u[i]], ret.pos[v[i]]);
//     }
//     return ret;
// }
 
int main()
{
    ios::sync_with_stdio(false);
    for (int i = 0; i < 10; ++i) {
        presum->pos[i] = i;
    }
    cin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        cin >> u[i] >> v[i];
        presum[i] = presum[i - 1];
        swap(presum[i].pos[u[i]], presum[i].pos[v[i]]);
        // cout << "presum["<<i<<"]=" << presum[i] << endl;
    }
    for (int i = 1; i <= m; ++i) {
        cin >> l >> r;
        cout << presum[r] - presum[l - 1] << endl;
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct ballList{
    int pos[10];
};
ballList presum[MAXN];
ballList operator - (const ballList A, const ballList B){
    ballList temp, C;
    for (int i = 0; i<10; i++){
        temp.pos[B.pos[i]] = i;
    }
    for (int i = 0; i<10; i++){
        C.pos[i] = temp.pos[A.pos[i]];
    }
    return C;
}
ostream & operator << (ostream & os, const ballList &ob){
    for (int i = 0; i<10; i++){
        if (i) os << " ";
        os << ob.pos[i];
    }
    return os;
}
int main()
{
    ios::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    for (int i = 0; i<10; i++) presum[0].pos[i] = i;
    for (int i = 1; i<=n; i++){
        int x, y;
        cin >> x >> y;
        presum[i] = presum[i-1];
        swap(presum[i].pos[x], presum[i].pos[y]);
    }
    while (m--){
        int l, r;
        cin >> l >> r;
        cout << presum[r]-presum[l-1] << endl;
    }
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;

int main()
{
    ios::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    vector<vector<int>> s(n+1, vector<int>(10, 0));
    for (int i = 0; i<10; i++) s[0][i] = i;
    for (int i = 1; i<=n; i++){
        int x, y;
        cin >> x >> y;
        s[i] = s[i-1];
        swap(s[i][x], s[i][y]);
    }
    while (m--){
        int l, r;
        cin >> l >> r;
        vector<int> temp(10);
        for (int i = 0; i<10; i++){
            temp[s[l-1][i]] = i;
        }
        for (int i = 0; i<10; i++){
            cout << temp[s[r][i]] << " \n"[i==9];
        }
    }
    return 0;
}

二维差分

差分的优点：

高效区间更新：差分数组可以在常数时间内完成对数组某个区间的批量更新。例如，对区间 [l, r] 的所有元素同时加上一个值，只需修改差分数组的两个位置。
简化更新操作：在需要频繁更新数组元素的情况下，差分数组避免了每次更新都遍历整个区间的复杂操作，提高了更新效率。

地毯

在 n×n 的格子上有 mm 个地毯。

给出这些地毯的信息，问每个点被多少个地毯覆盖。

第一行，两个正整数 n,mn,m。意义如题所述。

接下来 m 行，每行两个坐标 (x1,y1) 和 (x2,y2)，代表一块地毯，左上角是 (x1,y1)，右下角是 (x2,y2)。

输入数据

5 3
2 2 3 3
3 3 5 5
1 2 1 4

输出数据

0 1 1 1 0
0 1 1 0 0
0 1 2 1 1
0 0 1 1 1
0 0 1 1 1

注意差分方式为下表，以5*5中的点一(1,1),点二(3,3)为例

	1	2	3	4	5
1	1			-1
2
3
4	-1			1
5

这里a的数组为什么要开n+2呢，因为当x2,y2为边界时得在它+1的位置-1.

AC代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	
	int n, m;
	cin >> n >> m;
	vector<vector<int>> a(n+2, vector<int>(n+2, 0)), g(n+2, vector<int>(n+1, 0));
	for (int i = 0; i<m; i++){
		int x1, x2, y1, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		a[x1][y1]++;
		a[x2+1][y1]--;
		a[x1][y2+1]--;
		a[x2+1][y2+1]++;
	}
	for (int i = 1; i<=n; i++){
		for (int j = 1; j<=n; j++){
			g[i][j] = g[i-1][j]+g[i][j-1]-g[i-1][j-1]+a[i][j];
			cout << g[i][j] << " \n"[j==n];
		}
	}
	
	return 0;
}

逆向差分

积木大赛

春春幼儿园举办了一年一度的“积木大赛”。今年比赛的内容是搭建一座宽度为 nn 的大厦，大厦可以看成由 nn 块宽度为 11 的积木组成，第 ii 块积木的最终高度需要是 hihi。

在搭建开始之前，没有任何积木（可以看成 nn 块高度为 00 的积木）。接下来每次操作，小朋友们可以选择一段连续区间 [l,r][l,r]，然后将第 LL 块到第 RR 块之间（含第 LL 块和第 RR 块）所有积木的高度分别增加 11。

小 M 是个聪明的小朋友，她很快想出了建造大厦的最佳策略，使得建造所需的操作次数最少。但她不是一个勤于动手的孩子，所以想请你帮忙实现这个策略，并求出最少的操作次数。

输入数据

5
2 3 4 1 2

输出数据

5

先求出a的差分序列b，b[i]=a[i]-a[i-1],根据b[i]的值大于0就可以得出结果。

AC代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long

void solve()
{
	int n;
	cin >> n;
	vector<int> a(n+2), b(n+2);
	for (int i = 1; i<=n; i++){
		cin >> a[i];
	}
	int res = 0;
	for (int i = 1; i<=n; i++){
		b[i] = a[i]-a[i-1];
		if (b[i] > 0) res+=b[i];
	}
	cout << res << endl;
}

signed main()
{
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
	
	solve();
	
	return 0;
}

树上差分

思路：因为m的值不是很大，所以我们可以来枚举要使用魔法的边来找最小值，需要记录每条边有多少个人的记录，这里应该用树上边差分来统计，再在枚举时取最大值，思路还是比较简单，但代码实现上还是有点难度。

struct LCA{
    vector<vector<int>> f;
    vector<int> sum, dep;
    vector<vector<pair<int, int>>> g;
    LCA(int n){
        f.resize(20, vector<int>(n+1));
        dep.resize(n+1), sum.resize(n+1);
        g.resize(n+1);
    }
    void dfs(int u, int fa){
        dep[u] = dep[fa] + 1;
        f[0][u] = fa;
        for (int i = 1; i<20; i++){
            f[i][u] = f[i-1][f[i-1][u]];
        }
        for (auto [v, w] : g[u]){
            if (v == fa) continue;
            sum[v] = sum[u]+w;
            dfs(v, u);
        }
    }
    int find(int u, int v){
        if (dep[u] < dep[v]) swap(u, v);
        for (int i = 19; i>=0; i--){
            if (dep[f[i][u]] >= dep[v]) u = f[i][u];
        }
        if (u == v) return u;
        for (int i = 19; i>=0; i--){
            if (f[i][u] != f[i][v]){
                u = f[i][u];
                v = f[i][v];
            }
        }
        return f[0][u];
    }
};
struct node{
    int u, v, w;
};
void solve(){
    int n, m;
    cin >> n >> m;
    LCA lca(n);
    vector<node> edge(n+1);
    for (int i=1,u,v,w; i<=n-1; i++){
        cin >> u >> v >> w;
        lca.g[u].push_back(make_pair(v, w));
        lca.g[v].push_back(make_pair(u, w));
        edge.push_back({u, v, w});
    }
    lca.dfs(1, 0);
    int cost = 0;
    vector<int> s(n+1);
    for (int i = 0,a,b; i<m; i++){
        cin >> a >> b;
        int ll = lca.find(a, b);
        s[a]++, s[b]++, s[ll]-=2;
        cost += (lca.sum[a]+lca.sum[b]-2*lca.sum[ll]);
    }
    auto dfs2 = [&](auto &&dfs2, int u, int fa)->void
    {
        for (auto [v, w]: lca.g[u]){
            if (v == fa) continue;
            dfs2(dfs2, v, u);
            s[u] += s[v];
        }
    };
    dfs2(dfs2, 1, 0);
    int mx = 0;
    for (auto [u, v, w]:edge){
        if (lca.dep[u] < lca.dep[v]) swap(u, v);
        mx = max(mx, s[u]*w);
    }
    cout << cost - mx << endl;
}