0x03前缀和与差分

前缀和：对于一个给定的数列A，它的前缀和数列S是通过递推能求出的基本信息之一：
S[1] = A[1]，S[2] = A[1]+A[2]，S[3] = A[1]+A[2]+A[3]，…S[n] = A[1]+A[2]+…+A[n]。
一个部分和，即数列A某个下标区间内的数的和，可表示为前缀和相关的形式：
sum(l,r) = A[l]+A[l+1]+…+A[r-1]+A[r] = S[r]-S[l-1]；
在二维数组（矩阵）中，可类似地求出二维前缀和：
S[i,j] = S[i-1,j]+S[i,j-1]-S[i-1,j-1]+A[i,j];

题目一：
地图上有 N 个目标，用整数Xi,Yi表示目标在地图上的位置，每个目标都有一个价值Wi。
注意：不同目标可能在同一位置。
现在有一种新型的激光炸弹，可以摧毁一个包含 R×R 个位置的正方形内的所有目标。
激光炸弹的投放是通过卫星定位的，但其有一个缺点，就是其爆炸范围，即那个正方形的边必须和x，y轴平行。
求一颗炸弹最多能炸掉地图上总价值为多少的目标。

输入格式
第一行输入正整数 N 和 R ,分别代表地图上的目标数目和正方形的边长，数据用空格隔开。
接下来N行，每行输入一组数据，每组数据包括三个整数Xi,Yi,Wi,分别代表目标的x坐标，y坐标和价值，数据用空格隔开。

输出格式
输出一个正整数，代表一颗炸弹最多能炸掉地图上目标的总价值数目。

数据范围
0≤R≤10^9
0<N≤10000,
0≤Xi,Yi≤5000
0≤Wi≤1000

输入样例：
2 1
0 0 1
1 1 1

输出样例：
1

题目思路：因为xi,yi是0到5000之间，我们可以建立一个二维数组存储这些点的权值，接下来再来求这个二维数组的前缀和数组。然后我们再查找边长为R的正方形权值最大的就解决问题了。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 5010;  //已知点不大于5000，所以N定义为5010;
int z,r;  //z表示输入多少个数，r表示炸弹轰炸的正方形边长
int s[N][N];  //用来存储每个点的权值
int main(){
    cin>>z>>r;
    int n,m;  //n和m表示，我实际上能有的最大的坐标值
    r =min(r,5001); //因为r的取值范围过大，所以当他大于5001时，我们直接取5001，减去冗余。
    n =m =r;  //实际长,宽都起码等于边长r，因为如果r过大，则当i>=r时且dx小于r时，s[i][j]必然为空，无法遍历到二维的右下角。
    for(int i = 0;i<z;i++){
        int x,y,w;
        cin>>x>>y>>w;
        x++;y++;  //这里加1 表示前缀和，从1开始，每个数自动加1
        n = max(n,x);m = max(m,y);//更新长宽的数据，防止dx,dy大于r
        s[x][y]+=w;
    }
    for(int i=1;i<=n;i++)  //此时n和m一定是大于最大的一个点的坐标值
        for(int j = 1;j<=m;j++)
            s[i][j] += s[i-1][j]+s[i][j-1]-s[i-1][j-1];
    int res = 0;
    for(int i=r;i<=n;i++)
        for(int j=r;j<=m;j++)
            res = max(res,s[i][j]-s[i-r][j]-s[i][j-r]+s[i-r][j-r]);
    cout<<res<<endl;
    return 0;
}

差分：对于一个给定的数列A，它的差分数列B定义为：
B[1] = A[1]，B[2] = A[2]-A[1]，B[i] = A[i]-A[i-1]；（2<=i<=n）
容易发现，”前缀和“与”差分“是一对互逆运算，差分序列B的前缀和序列就是原序列A，前缀和序列S的差分序列也是原序列A。
把序列A的区间[l,r]加d（即把A[l],A[l+1]…A[r]都加上d），其差分序列B的变化为B[l]加上d，B[r+1]减去d，其它位置不变。这有助于我们在很多题目中，把原序列上的”区间操作“转化为差分序列上的”单点操作“进行计算，降低求解难度。

题目二：给定一个长度为 n 的数列 a1,a2,…,an，每次可以选择一个区间 [l,r]，使下标在这个区间内的数都加一或者都减一。
求至少需要多少次操作才能使数列中的所有数都一样，并求出在保证最少次数的前提下，最终得到的数列可能有多少种。

输入格式
第一行输入正整数n。
接下来n行，每行输入一个整数，第i+1行的整数代表ai。

输出格式
第一行输出最少操作次数。
第二行输出最终能得到多少种结果。

数据范围
0<n≤105,
0≤ai<2147483648

输入样例：
4
1
1
2
2

输出样例：
1
2

题目思想：我们可以求出a数列的差分数列，题目对数列a的操作，相当于每次可以选出b1,b2,…bn+1 中任意两个数，一个加1，另一个减1.目标是把b2,b3,…,bn变成全零，最终得到的数列a就是由n个b1构成的。
从b1,b2,b3…bn中任选两个数的方法可以有四类：
1.选bi,bj，其中2<=i,j<=n 这种操作会改变b2,b3…bn中两个数的值，应该bi和bj在一正一负的情况下，尽量多地采取这种操作，更快接近目标；
2.选b1,bj，其中2<=j<=n
3.选bi和bn+1，其中2<=i<=n
4.选b1和bn+1。这种情况没有意思，因为不会改变b2,b3…bn的值。
设b2,b3…bn中正数总和为p，负数总和绝对值为q，首先以正负配对的方式尽量执行第一类操作，可执行min(q,p)，剩余|p-q|个求配对，每一个可以选择第2类或第3类操作，其需要|p-q|次。所以最少操作次数为min(q,p)+|p-q| = max(p,q)。根据|p-q|次,，可以自己消掉或者与1号位置对消，能产生|p-q|+1种不同的b1的值，

#include<iostream>
#include<algorithm>
using namespace std;
const int N =100010;
int n;
int a[N];
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=n;i;i--) a[i]-=a[i-1];
    long long p,q;
    q=p=0;
    for(int i=2;i<=n;i++){
        if(a[i]>0) p+=a[i];
        else q-=a[i];
    }
    cout<<max(q,p)<<endl<<abs(p-q)+1;
    return 0;
}

题目三：有 N 头牛站成一行，被编队为1、2、3…N，每头牛的身高都为整数。
当且仅当两头牛中间的牛身高都比它们矮时，两头牛方可看到对方。
现在，我们只知道其中最高的牛是第 P 头，它的身高是 H ，剩余牛的身高未知。
但是，我们还知道这群牛之中存在着 M 对关系，每对关系都指明了某两头牛 A 和 B 可以相互看见。
求每头牛的身高的最大可能值是多少。

输入格式
第一行输入整数N,P,H,M，数据用空格隔开。
接下来M行，每行输出两个整数 A 和 B ，代表牛 A 和牛 B 可以相互看见，数据用空格隔开。

输出格式
一共输出 N 行数据，每行输出一个整数。
第 i 行输出的整数代表第 i 头牛可能的最大身高。

数据范围
1≤N≤10000,
1≤H≤1000000,
1≤A,B≤10000,
0≤M≤10000

输入样例：
9 3 5 5
1 3
5 3
4 3
3 7
9 8

输出样例：
5
4
5
3
4
4
5
5
5

注意：此题中给出的关系对可能存在重复

题目思路：题目中的m对关系带给我们的信息实际上是牛之间的身高的相对大小关系。我们可以建立一个数组C，数组中起始全为0，若一条关系指明Ai和Bi可以互相看见，（设Ai<Bi），则把数据C中下标为Ai+1到Bi-1的数都减去1，又因为第p头牛是最高的，所以最终C[p]一定为0，其他的牛与第p头牛的身高差距就体现在数组C中。换言说，第i头牛的身高就等于H+C[i]。
数据C中下标为Ai+1到Bi-1的数都减去1，我们可以用差分数列来实现，我们建立一个差分数列D,令D[Ai+1]减去1，D[Bi]加上1 。最后数列C就是数列D的前缀和，第i头牛换身高就为H+C[i]。

#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
const int N =10010;
int d[N];
int main(){
    int n,p,h,m;
    cin>>n>>p>>h>>m;
    set<pair<int,int>> e;
    for(int i=0;i<m;i++){
        int a,b;
        cin>>a>>b;
        if(a>b) swap(a,b);
        if(!e.count({a,b})){ //保证不能重复
            e.insert({a,b});
            d[a+1]-=1;d[b]+=1;
        }
    }
    for(int i=1;i<=n;i++){
        d[i]+=d[i-1];
    }
    for(int i=1;i<=n;i++)
        cout<<h+d[i]<<endl;
    return 0;
}