差分与前缀和-CFANZ编程社区

差分与前缀和是一对互逆的操作，常常用于处理区间问题，差分法是解决区间加减问题，前缀和是解决区间求和问题的常用办法。

差分法

差分法的应用主要是用于处理区间问题。当某一个数组要在很多不确定的区间，加上相同的一个数。我们如果每个都进行加法操作的话，那么复杂度 O(nm) 是平方阶的，非常消耗时间。

如果我们采用差分法，将数组拆分，构造出一个新的拆分数组，通过对数组区间的端点进行加减操作，最后将数组和并就能完成原来的操作。

差分法的特点：

将对于区间的加减操作转化为对于端点的操作；
时间复杂度为 O(n)；
用于维护区间的增减但不能维护乘除；
差分后的序列比原来的数组序列多一个数。

差分算法解题的基本思路：b[i]=a[i]-a[i-1]，a[0]=0

b[1]=a[1]；
从第 2 项到 n 项，利用 b[i]=a[i]-a[i-1]差分式；
对于区间端点操作加减；
差分还原(前缀和)。
注意是从1开始，从0开始还有讨论i=0 的情况，使用1的话 b[1]=a[1]-a[0]=a[1]-0;

差分与前缀和是逆操作，常在一起出现，但是先做差分还是先做前缀和就是两种不同的算法，做不做另一种操作也决定了算法不同，所以要根据题目分析。

大学里的树木要打药

利用b[i]=a[i]-a[i-1]差分式。

(由于这里开始时都是 0，可以用，但是用完都还是 0，所以没有意义，所以直接跳过即可。)

依次读入区间的值，然后将对于区间的操作转化为对于区间端点操作加减。由于题目树的编号从 0~N-1，而（1 <=L<=R<= N<= 10^6）我们上述所讲操作是从1开始，所以数目整体区间要右移1位。

对于每个 [L,R] 区间的加减操作都转化为对端点 L,R+1 的操作。

差分还原(前缀和)。

代码如下：


import java.util.Scanner;
public class Main {

  static int b[]=new int [100005];

  public static void main(String[] args) {

      Scanner in = new Scanner(System.in);

      int n; //n层
      int m; // m个区间
      n = in.nextInt();
      m = in.nextInt();

      while(m>0)
      {
          m--;
          int l,r,value ;
          l = in.nextInt();
          r = in.nextInt();
          value = in.nextInt();
          b[l+1]+=value;
          b[r+1+1]-=value;
      }

      for(int i=1; i<=n; i++)

          b[i]=b[i]+b[i-1];//复原操作

      int sum=0;

      for(int i=1;i<=n;i++)
          sum+=b[i];
  /*

  也可以一次性搞定
  int sum=a[0];
  for(int i=1; i<n; i++){
  a[i]=a[i]+a[i-1];
  sum+=a[i]
  }
  */
      System.out.println(sum);
  }
}

前缀和

前缀和算法的应用主要也是用于处理区间内求和问题。

前缀和是指某序列的前 n 项和，可以把它理解为数学上的数列的前 n 项和。当对于某一数组区间进行多次询问，[L,r] 的和时，如果正常处理，那么我们每次都要 [l,r]。查询 N 次，那么时间复杂度也是 O(nm) 也是平方阶的。

前缀和的特点：

将对于区间的求和操作转化为对于端点值的减法的操作；
区间求和操作的时间复杂度为 O(1)；
数组存放时要从 1 开始；
前缀和数组比原来的数组序列多一个数，第 0 个

前缀和算法解题的基本思路：

利用 sum[i]=a[i]+sum[i-1]差分式；
从第 1 项到 n 项，且第 0 项无数据默认为 0；
对于区间求和的操作转化为端点值相减。

前缀和的一般解题过程：

大学里的树木要维护

利用sum[i]=a[i]+sum[i-1]前缀和公式在输入时求出前缀和；

依次读入区间的值，然后将对于区间的求和操作转化为对于区间端点操作加减，

sum[k]=a[1]+....+a[k];设k<n, sum[n]=a[1]+...+a[k]+....+a[n]; 求sum(a[k,n]) ---》sum(a[k,n])=sum[n]-sum[k]=a[k]-a[n-1] 即对于每个 [l,r] 区间的求和操作都转化为对端点[r]-[l-1]的操作。

代码如下:

普通算法:


import java.util.Scanner;
public class Main {

    static int a[]=new int [100005];//每颗树的花费
    static int sum[]=new int [100005];

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int n; //n层
        int m; // m个区间
        n = in.nextInt();
        m = in.nextInt();

        for(int i=1;i<=n;i++)
        {
            a[i]= in.nextInt();
            sum[i]=a[i]+sum[i-1];//先把前缀和求出

        }
        //再根据sum[]对区间问题进行操作
        while(m>0)
        {
            m--;
            int l,r;
            l = in.nextInt();
            r = in.nextInt();
            System.out.println((sum[r]-sum[l-1]));
        }
    }
}

特殊代码:


import java.util.Scanner;
import java.util.Vector;

public class Main {


    static int a[]=new int [100005];
    static int sum[]=new int [100005];
    static Vector ans=new Vector<Integer>();

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int n; //n层
        int m; // m个区间
        n = in.nextInt();
        m = in.nextInt();

        for(int i=1;i<=n;i++)
        {
             a[i]= in.nextInt();
            sum[i]=a[i]+sum[i-1];

        }

        while(m>0)
        {
            m--;
            int l,r;
            l = in.nextInt();
            r = in.nextInt();
            ans.addElement(sum[r]-sum[l-1]);
        }

        for(Object ab:ans){
            System.out.println(ab);
        }
    }
}