【Java】浅谈前缀和与差分

前缀和

思路及其实现

前缀和，顾名思义，就是求出一个序列中每个数的前面的数和自身相加。下面的s数组表示前缀和，a数组表示当前数

s[i] = a[1] + a[2] + ... + a[i - 1] + a[i];
s[i - 1] = a[1] + a[2] + ... + a[i - 2] + a[i - 1];
由此可以得出：
s[i] = s[i - 1] + a[i];
现在对其边界进行判断，当i == 1的时候
s[1] = s[0] + a[1]; a[0] = 0；
所以可以判断等式成

作用：

例如： 2 1 3 6 4 求出2到4区间的和，我们有前面的s[4] - s[2 - 1]就可以求出其值。当然for循环从a[2]加到a[4]也是可以实现的，但未知的多组数据就不知道需要多少个for来实现了，所以求多组区间的和就需要用到前缀和

795. 前缀和 - AcWing题库

输入一个长度为 n 的整数序列。

接下来再输入 mm 个询问，每个询问输入一对 l,r。

对于每个询问，输出原序列中从第 l 个数到第 r 个数的和。

输入格式

第一行包含两个整数 n 和 mm。

第二行包含 n 个整数，表示整数数列。

接下来 mm 行，每行包含两个整数 l 和 r，表示一个询问的区间范围。

输出格式

共 mm 行，每行输出一个询问的结果。

数据范围

1≤l≤r≤n
1≤n,m≤100000,
−1000≤数列中元素的值≤1000

输入样例：

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

输出样例：

3
6
10

import java.io.*;

public class Main {
    
    static int N=100010;
    static int[] a = new int[N];
    static int[] s = new int[N];
    
    public static void main(String[]args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] s1 = in.readLine().split(" ");
        int n = Integer.parseInt(s1[0]);
        int m = Integer.parseInt(s1[1]);
        
        String[] s2 = in.readLine().split(" ");
        for(int i = 1; i <= n; i ++) a[i] = Integer.parseInt(s2[i - 1]);
        for(int i = 1; i <= n; i ++) s[i] = a[i] + s[i - 1];
        while(m -- > 0) {
            String[] s3 = in.readLine().split(" ");
            int l = Integer.parseInt(s3[0]);
            int r = Integer.parseInt(s3[1]);
            System.out.println(s[r] - s[l - 1]);
        }
    }
}

796. 子矩阵的和 - AcWing题库

输入一个 n 行 m列的整数矩阵，再输入 q 个询问，每个询问包含四个整数 x1 , y1, x2, y2，表示一个子矩阵的左上角坐标和右下角坐标。

对于每个询问输出子矩阵中所有数的和。

输入格式

第一行包含三个整数 n，m，q。

接下来 n 行，每行包含 mm 个整数，表示整数矩阵。

接下来 q 行，每行包含四个整数 x1, y1, x2, y2，表示一组询问。

输出格式

共 q 行，每行输出一个询问的结果。

数据范围

1≤n,m≤1000,
1≤q≤200000,
1≤x1≤x2≤n,
1≤y1≤y2≤m,
−1000≤矩阵内元素的值≤1000

输入样例：

3 4 3
1 7 2 4
3 6 2 8
2 1 2 3
1 1 2 2
2 1 3 4
1 3 3 4

输出样例：

17
27
21

1   2  3  4  5
6 	7  8  9 10
11 12 13 14 15
16 17 18 19 20
如果求出七道20区间内的和
s[5][4] = 1 + .. + 20;
S[5][1] = 1 + 6 + 11 + 16;
S[1][4] = 1 + 2 + 3 + 4 + 5;
S[1][1] = 1;
所以目标区间：
S[5][4] = S[5][1] - S[1][4] + S[1][1] 
s[x2][y2] - s[x2][y1 - 1]   s[x1 - 1][y2] + s[x1 - 1][y1 - 1]

import java.io.*;

class Main{
    static int N=1010;
    static int[][] a=new int[N][N];
    static int[][] s=new int[N][N];

    public static void main(String[]args)throws IOException{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        String[] s1=in.readLine().split(" ");
        int n=Integer.parseInt(s1[0]);
        int m=Integer.parseInt(s1[1]);
        int q=Integer.parseInt(s1[2]);

        for(int i = 1;i <= n;i ++){
            String[]arr = in.readLine().split(" ");
            for(int j=1;j<=m;j++){
                a[i][j]=Integer.parseInt(arr[j-1]);
            }
        }

        for(int i = 1;i <= n;i ++){
            for(int j = 1; j <= m; j ++){
                s[i][j] = s[i-1][j] + s[i][j-1] - s[i-1][j-1] + a[i][j];
            }
        }

        while(q-->0){
            String[] s2 = in.readLine().split(" ");
            int x1=Integer.parseInt(s2[0]);
            int y1=Integer.parseInt(s2[1]);
            int x2=Integer.parseInt(s2[2]);
            int y2=Integer.parseInt(s2[3]);

            System.out.println(s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1]);
        }
    }
}

差分

思路及其实现

差分就是前缀和的逆运算,在一个数组中如果我们更换了第i个元素的值那求前缀和的时候后面的值都会被这一个元素的修改影响全局，如果想要停止尼？那只需要在第j（i之后）用相反的操作，那j后面的前缀和就不会受到影响了，那他的作用已经很明显了，那就是多次修改数组中的元素

797. 差分 - AcWing题库

输入一个长度为 n 的整数序列。

接下来输入 m 个操作，每个操作包含三个整数 l,r,c表示将序列中 [l,r] 之间的每个数加上 c。

请你输出进行完所有操作后的序列。

输入格式

第一行包含两个整数 n和 m。

第二行包含 n 个整数，表示整数序列。

接下来 m 行，每行包含三个整数 l，r，c表示一个操作。

输出格式

共一行，包含 n 个整数，表示最终序列。

数据范围

1≤n,m≤100000
1≤l≤r≤n
−1000≤c≤1000,
−1000≤整数序列中元素的值≤1000

输入样例：

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

输出样例：

3 4 5 3 4 2

import java.io.*;

class Main{
    static int N=100010;
    static int[] d=new int[N];

    static void insert(int l,int r,int c){
        d[l] += c;
        d[r+1] -= c;
    }

    public static void main(String[]args)throws IOException{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        String[] s1 = in.readLine().split(" ");
        int n=Integer.parseInt(s1[0]);
        int m=Integer.parseInt(s1[1]);

        String[] s2 = in.readLine().split(" ");
        for(int i=1;i<=n;i++) insert(i,i,Integer.parseInt(s2[i-1]));
		//c == 0的时候相当与什么都没修改，构建差分数组
        while(m-- > 0){
            String[] s3 = in.readLine().split(" ");
            int l=Integer.parseInt(s3[0]);
            int r=Integer.parseInt(s3[1]);
            int c=Integer.parseInt(s3[2]);

            insert(l, r, c);
        }

        int num = 0;
        for(int i=1; i<=n; i++){
            num += d[i];
            System.out.print(num + " ");
        }
    }
}

798. 差分矩阵 - AcWing题库

输入一个 n 行 m 列的整数矩阵，再输入 qq 个操作，每个操作包含五个整数 x1,y1,x2,y2,c，其中 (x1,y1) 和 (x2,y2) 表示一个子矩阵的左上角坐标和右下角坐标。

每个操作都要将选中的子矩阵中的每个元素的值加上 cc。

请你将进行完所有操作后的矩阵输出。

输入格式

第一行包含整数 n,m,q。

接下来 n 行，每行包含 mm 个整数，表示整数矩阵。

接下来 q 行，每行包含 55 个整数 x1,y1,x2,y2,c，表示一个操作。

输出格式

共 n 行，每行 m 个整数，表示所有操作进行完毕后的最终矩阵。

数据范围

1≤n,m≤1000
1≤q≤100000
1≤x1≤x2≤n
1≤y1≤y2≤m
−1000≤c≤1000,
−1000≤矩阵内元素的值≤1000−1000≤矩阵内元素的值≤1000

输入样例：

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

输出样例：

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

import java.io.*;

class Main{
    static int N = 1010;
    static int[][] d = new int[N][N];

    static void insert(int x1,int y1,int x2,int y2,int c){
        d[x1][y1] += c;
        //下面两行是使其不影响上面和左面的区域
        d[x1][y2+1] -= c;
        d[x2+1][y1] -= c;
        d[x2+1][y2+1] += c;
    }

    public static void main(String[]args)throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        String[] s1 = in.readLine().split(" ");
        int n=Integer.parseInt(s1[0]);
        int m=Integer.parseInt(s1[1]);
        int q=Integer.parseInt(s1[2]);

        for(int i = 1;i <= n; i ++){
            String[] s2 = in.readLine().split(" ");
            for(int j = 1; j <= m; j ++){
                insert(i, j, i, j, Integer.parseInt(s2[j-1]));
            }
        }

        while(q-- > 0){
            String[] s3 = in.readLine().split(" ");
            int x1 = Integer.parseInt(s3[0]);
            int y1 = Integer.parseInt(s3[1]);
            int x2 = Integer.parseInt(s3[2]);
            int y2 = Integer.parseInt(s3[3]);
            int num = Integer.parseInt(s3[4]);

            insert(x1, y1, x2, y2, num);
        }

        for(int i = 1;i <= n; i ++){
            for(int j = 1;j <= m; j ++){
                d[i][j] = d[i-1][j] + d[i][j-1] - d[i-1][j-1] + d[i][j];
                System.out.print(d[i][j] + " ");
            }
            System.out.println();
        }
    }
}