差分与前缀和

1. 一维前缀和 ： 

给你一个数列 ：a1 , a2 , a3 , a4 , ....... , an 。 以及 k 次询问。 每一次询问给出两个数 L 、R ，要求你回答这个数列的 [ L , R ] 区间内所有数的和是多少 (即 sum( L,R ) )

解法 ： 1. 暴力。每次询问都用一层 for 循环求解。查询复杂度为 O( n*k )

     2.一维前缀和： 另外开一个与存储数列的数组等长度的 数组 dp[N] 。dp[i] 表示 sum(1,i) 。

        之后对于 k 次询问，只需要用 dp[R] - dp[L-1] 表示。查询复杂度为O（1）

int arr[100+1];
int  dp[100+1];
int n,k,l,r;
cin >> n >> k;
for(int i = 1; i <= n; i++){
    cin >> arr[i];
    dp[i] = dp[i-1] + arr[i];
}
while(k--){
    cin >> l >> r;
    cout<<dp[r] - dp[l-1];
}

2.差分（一维）：

在上一个问题的基础上，再附加：在 k 次询问以前 , 还有这样一系列操作( 设一共进行了 t 次 ) ： 

（1）给定 L 、R  ， 对原数列的 [ L , R ] 每一个数增加 p

（2）给定 L 、R ，  对原数列的 [ L , R ]每一个数减少 p

最后再进行之前的k次询问

解法：

新建一个数组 m [ N ] ， 引进一个变量 add 来记录实时变化。具体看代码。

    for(i = 1;i <= t ; i++){
        int L,R,cmd;
        cin >> cmd >> L >> R >> p;
        if(cmd == 1){
            m[L]+=p;m[R+1]-=p; 
        }
        else{
            m[L]-=p;m[R+1]+=p;
        }
    }
    int add=0;
    for(i=1;i<=n;i++){
        add+=b[i];
        dp[i]= dp[i-1]+ arr[i] + add;
    }

我们假设 t 就等于 1 （ 即只进行了一次修改 ）。 方便我们理解差分的工作原理。

假设 N = 10 , 即数列共有10项， 我们现在对区间[ 3，6 ] 的每一个数进行 +1 操作。 这对应于代码的第4行: m[3] += 1  , m[7] -= 1

接下来进入第 11 行， add 初始为 0。

然后进入循环：

* 当1 <= i <= 2 时 , add += 0       dp [i]  = dp[i-1] + arr[i] + add = ap[i-1] + arr[i] + 0    

* 当 i = 3 时 , add += b[3]   -> add = add + 1 = 1

   故 3 <= i <= 6 时 ,dp [i]  = dp[i-1] + arr[i] + add = ap[i-1] + arr[i] + 1  

* 当 i = 7 时 , add += b[7]    -> add = add - 1 = 0

  故 7 <= i  <= 10 时 dp [i]  = dp[i-1] + arr[i] + add = ap[i-1] + arr[i] + 0    

利用差分 , 我们将 t 次区间修改的复杂度从O( t * n )降到了 O( t ) ， 而对dp数组的处理复杂度没变。

 

ps ： 如果题目改成边修改边询问，就是用线段树来求解了。这不属于本次讨论的范畴。

3.二维前缀和：

贴一个网上找到的图 ： 图片来源：https://blog.csdn.net/qq_34990731/article/details/82807870 

 

再推荐一个比较精致的博客： 

https://www.cnblogs.com/LMCC1108/p/10753451.html

我们用二维数组 arr[ m ][ n ] 来存储输入所给出的矩阵各个点的数值，并用一个二维数组 dp[ m ][ n ] 来表示 以点 ( 1,1 ) 为左上角 , 点 ( i , j ) 为右下角的矩形区间和。

易得状态转移方程 : dp[ i ][ j ] = dp[ i - 1][ j ] + dp[ i ][ j - 1 ] - dp[ i - 1][ j - 1] + arr[ i ][ j ]

在接下来的询问中 ， 每次询问给出 四个数 x1, y1, x2, y2 。 要求你给出包含点 ( x1,y1 ) 、(x2 , y2 )在内的 ， 且以( x1, y1 ) 为左上角 ， 点（ x2 , y2 ）为右下角的子矩阵区间和

/* 2D-sum */
#include <iostream>
#define Maxsize 1000+1
using namespace std;
int map[Maxsize][Maxsize];
int dp[Maxsize][Maxsize];
int main(){
    /* read */
    int n,m;
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            cin >> map[i][j];

    /* init dp array */
    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] - dp[i-1][j-1] + map[i][j];

    /* query */
    int q;
    int x1,y1,x2,y2;
    /*
       (x1,y1) -> the upper left  corner
       (x2,y2) -> the lower right corner
                                         */
    cin >> q;
    while(q--){
        cin >> x1 >> y1 >> x2 >> y2;
        x1--;y1--;
//      有一点注意，因为画图和定义原因我们发现边
//      界好像不对，我们来看看，我们定义的状态是
//      整个矩阵包括边的和，而我们要求的也是要包括边的，所以我们要让x1--,y1--
        cout<<"output: "<<dp[x2][y2] - dp[x1][y2] - dp[x2][y1] + dp[x1][y1]<<endl;
    }
    return 0;
}

4.差分（二维）：  

 

#include <cstdio>
#include <iostream>
#define Maxsize 5+1
using namespace std;
int m,n;
int  map[Maxsize][Maxsize];
int   dp[Maxsize][Maxsize];
int diff[Maxsize][Maxsize];
void init_map(){
    cin >> m >> n;
    for(int i = 1; i <= m; i++)
        for(int j = 1; j <= n; j++)
            cin >> map[i][j];
}
void add(int x1,int y1,int x2,int y2,int val){
    diff[x1][y1] += val;
    diff[x1][y2+1] -= val;
    diff[x2+1][y1] -= val;
    diff[x2+1][y2+1] += val;
}
void init_dp(){
    for(int i = 1; i <= m; i++){
        for(int j = 1; j <= n; j++){
            diff[i][j] += diff[i-1][j] + diff[i][j-1] - diff[i-1][j-1];
            dp[i][j] = dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + map[i][j] + diff[i][j];
        }
    }
}
void query(int x1,int y1,int x2,int y2){
    x1--;y1--;
    cout << dp[x2][y2] - dp[x2][y1] - dp[x1][y2] + dp[x1][y1] << endl;
}
int main(){
    init_map();
    int k,t;
    int x1,y1,x2,y2,val;
    cin >> k;
    while (k--) {
        cin >> x1 >> y1 >> x2 >> y2 >> val;
        add(x1,y1,x2,y2,val);
    }
    init_dp();
    cin >> t;
    while (t--) {
        cin >> x1 >> y1 >> x2 >> y2;
        query(x1,y1,x2,y2);
    }
    return 0;
}

5.利用 hash 将二维前缀和问题降维处理：

当题目中给的矩阵过大的时候,如果强行开二维数组存矩阵就会MLE , 此时如果用 hash 就可以减少空间。

例： HDU 6514 Monitor https://vjudge.net/problem/HDU-6514

注 ： 这个题的评测机不知道为什么不对全局数组做默认初始化，因此直接交这个代码会判WA。实际上这个也是对的。

如果交的化记得在while循环开始时fill map 数组置 0 。

#include <cstdio>
const int maxn = 20000010;
int map[maxn];
int n,m,k,q;
using namespace std;
inline int Hash(int x,int y){
    return x * (m + 1) + y;
}
inline void add(int x1,int y1,int x2,int y2){
    map[Hash(x1,y1)]++;   map[Hash(x1,y2+1)]--;
    map[Hash(x2+1,y1)]--; map[Hash(x2+1,y2+1)]++;
}
int main(){
    while (~scanf("%d %d",&n,&m)) {
        int x1,y1,x2,y2;
        n++; m++; // why ?
        scanf("%d",&k);
        for(int i = 1; i <= k; i++){
            scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
            add(x1,y1,x2,y2);
        }
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                map[Hash(i,j)] += map[Hash(i-1,j)] + map[Hash(i,j-1)] - map[Hash(i-1,j-1)];

        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                    map[Hash(i,j)] = (bool)map[Hash(i,j)];

        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= m; j++)
                map[Hash(i,j)] += map[Hash(i-1,j)] + map[Hash(i,j-1)] - map[Hash(i-1,j-1)];

        scanf("%d",&q);
        while(q--){
            scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
            int ans = map[Hash(x2,y2)] - map[Hash(x1-1,y2)] - map[Hash(x2,y1-1)] + map[Hash(x1-1,y1-1)];
            if(ans == (x2-x1+1) * (y2-y1+1))
                puts("YES");
            else
                puts("NO");
        }
    }
    return 0;
}