基础知识：差分

最新推荐文章于 2023-06-20 17:43:58 发布

Knight-lh

最新推荐文章于 2023-06-20 17:43:58 发布

阅读量225

点赞数 2

分类专栏：算法基础知识文章标签： java

本文链接：https://blog.csdn.net/qq_51081091/article/details/125616598

版权

算法基础知识专栏收录该内容

1 篇文章 0 订阅

订阅专栏

差分

1、对于给定一个序列 A ，它的差分序列为：

$B [1] = A [1], B [i] = A [i] - A [i - 1] (2 < = i < = n)$

2、差分和前缀和是一对逆运算：差分序列 B 的前缀和就是序列 A，前缀和 S 的差分序列也是序列A。

差分序列 B 的前缀和：

$= B [1] + B [2] + B [3] + . . . + B [i]$

$= A [1] + A [2] - A [1] + A [3] - A [2] + . . . + A [i] - A [i - 1]$

$= A [i]$

前缀和 S 的差分序列:

$= S [i] - S [i - 1]$

$= A [1] + A [2] + . . . + A [i - 1] + A [i] - (A [1] + A [2] + . . . + A [i - 1])$

$= A [i]$

3、作用：把序列 A 的区间 $[l, r]$ 加 d（即把 $A_l,A_{l+1},...,A_r$ 都加上 d），其差分序列 B 的变化为 $B_l$ 加 d， $B_{r+1}$ 减 d，其他位置不变。

A 序列加d ： $A [l] + d, A [l + 1] + d, . . ., A [r] + d$

变化后差分序列：

$B[l] = A[l] + d - A[l-1] = B[l]_{原} + d$

$B[l+1] = A[l+1] + d - (A[l] + d) = B[l+1]_{原}$

…

$B[r+1] = A[r+1] - (A[r] + d) = B[r+1]_{原} - d$

AcWing 100. IncDec序列

题目：

给定一个长度为 n 的数列 a1,a2,…,an，每次可以选择一个区间 [l,r]，使下标在这个区间内的数都加一或者都减一。

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

输入格式

第一行输入正整数 n。

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

输出格式

第一行输出最少操作次数。

第二行输出最终能得到多少种结果。

数据范围

0 < n ≤ 10^5
0 ≤ ai < 2147483648

输入样例：

输出样例：

1
2

思路：

题目对序列 A 的操作就是对 $B_1,B_2,...,B_n$ 任选2个数，一个加1，一个减1.

题目要求序列 A 的每一个数都要相同，可以转换为差分序列 $B_2,B_3,...,B_n$ 全变为 0.

对 $B_1,B_2,...,B_n$ 任选2个数有四种情况：

1、选 $B_i 和 B_j, 2 <= i,j <= n$ , 为尽量让序列为 0 ，应选择一正一负，相互抵消，逐渐趋近0.

2、选 $B_1,B_j 其中 2 <= j <= n$

3、选 $B_i,B_{n+1} 其中 2 <= i <= n$

4、选 $B_1,B_{n+1}$ 相当于选取全部加减，没有意义。

设差分序列 B 中正整数的和为 P，负整数的和为 Q，在正负数的选取下，先采用第一种选法，可选min(P, Q),还有|P-Q|种没有匹配，可以选择第二种或者第三种，总次数为 min(P, Q) + |P-Q| = max(P, Q);

根据|P - Q| 次第二或第三种选择，可以选择出 |P - Q| + 1 种 $B_1$ ，所以 A 序列有|P - Q| + 1 种。

算法：

import java.util.*;

public class Main{
    
    public static int MAX = 100010;
    public static int[] A = new int[MAX];
    public static int[] B = new int[MAX];
    
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        long poSum = 0, neSum = 0;
        for(int i = 0; i < n; i++) {
            A[i] = scanner.nextInt();
            if(i == 0) B[i] = A[i];
            else {
                B[i] = A[i] - A[i-1];
                if(B[i] > 0) poSum += B[i];
                else neSum -= B[i];
            }
        }
        System.out.println(Math.max(poSum, neSum));
        System.out.println(Math.abs(poSum - neSum) + 1);
    }
    
}