基础算法 - 前缀和与差分

前缀和

对于一个数组 $A$ ，它的前缀和数组 $S$ 是通过递推能求出的基本信息之一：
$$S[i]=\sum _{j=1}^{i}A[j]$$
前缀和的作用往往用于快速的求数组的一部分和，即数组 $A$ 某个下标区间内的数的和，可以表示为前缀和相减的形式：
$$sum(l,r)=\sum _{i=l}^{r}A[i]=S[r]-S[l-1]$$
在二维数组中，也可以推出类似的二维前缀和。

对于二维空间，我们可以表示成下面几张图：

阴影部分为 $S[i-1][j]$ 。

阴影部分为 $S[i][j-1]$ 。

阴影部分为 $S[i-1][j]+S[i][j-1]$ 。

阴影部分为 $S[i-1][j]+S[i][j-1]-S[i-1][j-1]$ 。

容易的得出二维数组中，前缀和的递推式就是：
$$S[i,j]=S[i-1,j]+S[i,j-1]-S[i-1,j-1]+A[i,j]$$
同理我要计算一个子矩阵的和，已知矩阵左上角坐标 $(x_1,y_1)$ ，右下角坐标为 $(x_2,y_2)$ ，可得出：
$$\sum _{i=x_1}^{x_2}\sum _{j=y_1}^{y_2}A[i][j]=S[x_2,y_2]-S[x_1][y_2]-S[x_2][y_1]+S[x_1][y_1]$$

推导式子其实使用了 “容斥原理” 的思想，利用它也可以推出三维数组的三维前缀和。

【例题】激光炸弹
一种新型炸弹，可以摧毁一个边长为 $R$ 的正方形内所有目标。现在地图上有 $N(N\le 10^4)$ 个目标，用整数 $X_i,Y_i$ （其值在区间 $[0,5000]$ 之内）表示目标在地图上的位置，每个目标价值 $W_i$ 。

激光炸弹的投放是通过卫星定位的，但其有一个缺点，就是其爆破范围，即那个边长为 $R$ 的正方形的边必须和 $x$ ， $y$ 轴平行。若目标位于爆破正方形的边上，该目标不会被摧毁。求一颗炸弹最多能炸掉地图上的总价值为多少的目标。

分析：
问题简述就是在一个二维平面找出一个长度为 $R$ 的正方形，它的权值和最大。那么这个二维平面在 $[0,5000]$ 内，所有我们可以使用 $O(n^2)$ 来预处理出一个二维前缀和数组，再用一个 $O(n^2)$ 来遍历所有长度 $R$ 的正方形的权值和，找出最大值就行了。

代码如下：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 5010;
int n, r;
int sa[N][N];

int main()
{
    scanf("%d%d", &n, &r);

    // r最大5001有意义
    r = min(r, 5001);

    int x, y, w;
    for(int i = 0; i < n; ++i) {
        scanf("%d%d%d", &x, &y, &w);
        sa[x + 1][y + 1] += w;  // 前缀和通常以1开头，好处理。
    }

    for(int i = 1; i <= 5001; ++i) {
        for (int j = 1; j <= 5001; j ++ ) {
            sa[i][j] += sa[i - 1][j] + sa[i][j - 1] - sa[i - 1][j - 1];
        }
    }

    int res = 0;

    for(int i = r; i <= 5001; ++i) {
        for(int j = r; j <= 5001; ++j) {
            res = max(res, sa[i][j] - sa[i][j - r] - sa[i - r][j] + sa[i - r][j - r]);
        }
    }

    printf("%d", res);

    return 0;
}

差分

对于一个给定的数组 $A$ ，他的差分数列 $B$ 定义为：
$$B[1]=A[1],B[i]=A[i]-A[i-1](2\le i\le n)$$

“差分”与“前缀和”其实是一对互逆运算，差分数组 $B$ 的前缀和数组就是数组 $A$ ，前缀和数组 $S$ 的差分数组也是数组 $A$。

在数组 $A$ 的区间 $[l,r]$ 上加上 $d$ （即把 $A_l,A_{l+1},\cdots ,A_r$ 都加上 $d$ ），其差分数组 $B$ 的变化就是在 $B_l$ 加 $d$ ， $B_r+1$ 减 $d$ ，其它位置不变。

通常这个操作可以使得原本在数组 $A$ 上的区间操作，变为在数组 $B$ 上的单点操作。

【例题】增减序列

给定一个长度为 $n(n\le 10^5)$ 的数列 { a 1 , a 2 , ⋯   , a n } \{a_1,a_2,\cdots,a_n\} {a1​,a2​,⋯,an​} ，每次可以选择一个区间 $[l,r]$ ，使下标在这个区间内的数都加 $1$ 或者减 $1$ 。

求至少需要多少次操作才能使数列中的所有数都一样，并求出在保证最少次数的前提下，最终得到的数列有多少种。

分析：

如果仅仅看区间操作，那么就很难处理这个情况，但是我们要是使用差分数组来看这个数列就不一样了。

假设数列 $a$ 的全部元素已经相同了，即 { a , a , ⋯   , a } \{a,a,\cdots,a\} {a,a,⋯,a} ，那么它的差分数就是 { a , 0 , ⋯   , 0 } \{a,0,\cdots,0\} {a,0,⋯,0}，可以看出除了第一项为 $a$ ，其它数都为 $0$ ，也就是我们要通过区间操作使得差分数列的 $b_2,b_3,\cdots ,b_n$ 变为 $0$ ，这时原来的区间操作就变为了差分序列的单点操作。

如果在 $b_2,b_3,\cdots ,b_n$ 上使用单点操作可以使用使得两个正负相反的使用一次操作抵消，所有要优先去除他的，这里花费的次数就是 $min(p,q)$ ， $p$ 为在 $b_2,b_3,\cdots ,b_n$ 上所有正数的和， $q$ 为在 $b_2,b_3,\cdots ,b_n$ 所有负数的绝对值和。

这样操作完了后，还剩下 $|p-q|$ 的值需要变为 $0$ ，这时可以与 $b_1$ 搭配消耗掉，也可以和 $b_{n+1}$ 一起搭配消耗掉，而差分数列的 $b_1$ 有多少种取值，就代表有多少原数组 $A$ 全部相同的种类数。所以 $b_1$ 的变化区间就在 $[b_1,b_1+|p-q|]$ 这个区间内，总数为 $|p-q|+1$ 个。

代码如下：

#include <iostream>
using namespace std;
typedef long long LL;
const int N = 1e5 + 5;
int n;
LL a[N], b[N];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ )
        scanf("%lld", a + i);
    for (int i = 1; i <= n; i ++ )
        b[i] = a[i] - a[i - 1];

    LL  ans = 0, q = 0, p = 0;
    for (int i = 2; i <= n; i ++ ) {
        if(b[i] > 0) q += b[i];
        if(b[i] < 0) p += -b[i];
    }

    LL res = a[1];

    printf("%lld\n%lld", min(q, p) + abs(p - q), abs(p - q) + 1);

    return 0;
}

【例题】最高的牛

有 $N$ 头牛站成一行。两头牛能互相看见，当且仅当它们中间的牛的身高都比它们矮。现在，我们只知道其中最高的牛是第 $P$ 头，它的身高是 $H$ ，不知道剩余 $N-1$ 头牛的身高。但是，我们还知道 $M$ 对关系，每对关系都指明了两头牛 $A_i$ 和 $B_i$ 可以互相看见。求每头牛的身高最大可能是多少。

数据范围：$1\le N,M\le 10^4,1\le H\le 10^6$ 。

分析：

确定了最高身高 $H$ 后，我们也确定了每头牛最高也是 $H$ 了。最初没有任何关系的约数，就代表所以牛都可以是 $H$ ，但是有了关系的约束后，设这个关系就是 $a_i$ ，$b_i$ （$a_i<b_i$），那么在$[a_i+1,b_i-1]$ 这段区间内的牛至少身高得减去 $1$ ，这样才不会遮蔽视野。这时区间减一的操作我们就可以利用差分来变为单点操作了，而原本全为 $H$ 的数组，它的差分数组也变为了 $[H,0,\cdots ,0]$ 这样的。最后跑一个前缀和就可以求出满足条件的最大牛身高了。

因为关系可能重复，而我们做了一次后就不必再做一次，所以要去重操作。

代码如下：

#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
typedef pair<int, int> PII;
const int N = 10010;
int b[N];
map<PII, bool> mp;

int main()
{
    int n, p, h, m;
    scanf("%d%d%d%d", &n, &p, &h, &m);
    for(int i = 1; i <= n; ++i)
        b[i] = 0;
    b[1] = h;

    while (m -- ) {
        int u, v;
        scanf("%d%d", &u, &v);
        if(u > v) swap(u, v);
        PII t = {u, v};

        if(mp.count(t)) continue;

        b[u + 1] -=1;
        b[v] += 1;

        mp[t] = true;
    }

    for (int i = 1; i <= n; i ++ )
        b[i] += b[i - 1];

    for (int i = 1; i <= n; i ++ ) {
        printf("%d\n", b[i]);
    }

    return 0;
}