蓝桥杯备赛系列

倒计时50天！

前缀和和差分

知识点

前缀和数组：
假设原数组用a[i]表示，前缀和数组用sum[i]表示，那么sum[i]表示的是原数组前i项之和，注意一般用前缀和数组时，原数组a[i]的有效下标是从1开始的。式子如下，
$$sum[n]=\sum _{i=1}^{n}a[i]$$
差分数组：
假设原数组用a[i]表示，差分数组用d[i]表示，那么d[i]表示的是a[i]和a[i-1]之差，注意一般用差分数组时，原数组a[i]的有效下标也是从1开始的。式子如下，
$$d[n]=a[i]-a[i-1]$$
接下来看一下前缀和和差分的模板题。

前缀和模板

3 2
1 2 4
1 2
2 3

3
6

题目分析

前缀和最经典的一个作用就是以O（1）的时间复杂度求区间和。

sum[l-1]=a[1]+a[2]+a[3]+…+a[l-1]

sum[r]=a[1]+a[2]+a[3]+…+a[l-1]+a[l]+…+a[r]

sum[r]-sum[l-1]=a[1]+a[2]+a[3]+…+a[l-1]+a[l]+…+a[r]-(a[1]+a[2]+a[3]+…+a[l-1])

​ =a[l]+a[l+1]+…+a[r]

所以区间[l,r]的和可以用sum[r]-sum[l-1]表示。

题目代码

import java.util.Scanner;
public class Main{
public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int q = scanner.nextInt();int a[] = new int[n+1];long sum[] = new long[n+1];for(int i = 1;i <= n;i++) a[i] = scanner.nextInt();for(int i = 1;i <= n;i++) sum[i] = sum[i-1] + a[i];while(q-- > 0) {int l = scanner.nextInt();int r = scanner.nextInt();System.out.println(sum[r]-sum[l-1]);}
}
}

二维前缀和模板

3 4 3
1 2 3 4
3 2 1 0
1 5 7 8
1 1 2 2
1 1 3 3
1 2 3 4

8
25
32

题目分析

首先要了解二维前缀和数组的定义，$sum[i][j]$表示的是对左上角行列分别为1，1，右下角行列分别为i，j的矩阵求和。$sum[7][7]$如下图，为红色圈起来的矩阵。注意这里矩阵的下标都是从1开始的。

我们通过图片分析如何求二维前缀和数组以及如何利用二维前缀和数组求矩阵和。

如何求二维前缀和数组。如图所示，假设要求$sum[x1][y1]$的值，也就是图中大红色圈起来的部分，我们可以将蓝色部分加上绿色部分后再加上x1,y1处本来的值，也就是$sum[x1][y1-1]+sum[x1-1][y1]+a[x1][y1]$。但是这样会多加上一部分，也就是蓝色和绿色重叠的部分，他用$sum[x1-1][y1-1]$表示，需要减掉。综上$sum[x1][y1]=sum[x1][y1-1]+sum[x1-1][y1]+a[x1][y1]-sum[x1-1][y1-1]$。

如何利用二维前缀和数组求矩阵和。如图所示，假设要求左上角下标为x1,y1，右下角下标为x2,y2的矩阵的值，也就是图中蓝色的部分。可以用$sum[x2][y2]-sum[x2][y1-1]-sum[x1-1][y2]+sum[x1-1][y1-1]$表示，也就是图中绿色部分减去图中橙色和紫色部分，而紫色和橙色部分有重叠，多减了，要再加回来，也就是图中棕色部分。

题目代码

代码细节，数据的读入涉及到矩阵，对于java而言数据量较大，要使用快读。如果没有学过快读，可以点击链接学习一下。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;public class Main {
public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String[] strings = br.readLine().split(" ");int n = Integer.parseInt(strings[0]);int m = Integer.parseInt(strings[1]);int q = Integer.parseInt(strings[2]);long a[][] = new long[n+1][m+1];long sum[][] = new long[n+1][m+1];for(int i = 1;i <= n;i++) {strings = br.readLine().split(" ");for(int j = 1;j <= m;j++) {a[i][j] = Integer.parseInt(strings[j-1]);}}for(int i = 1;i <= n;i++) {for(int j = 1;j <= m;j++) {sum[i][j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+a[i][j];}}while(q-- > 0) {strings = br.readLine().split(" ");int x1 = Integer.parseInt(strings[0]);int y1 = Integer.parseInt(strings[1]);int x2 = Integer.parseInt(strings[2]);int y2 = Integer.parseInt(strings[3]);System.out.println(sum[x2][y2]-sum[x2][y1-1]-sum[x1-1][y2]+sum[x1-1][y1-1]);}
}
}

差分模板题

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

5 6 1

题目分析

差分数组一般要结合前缀和使用，使用方法如下，

假设我有两个操作，第一个操作是对下标为3一直到下标为10的数字都加上2，第二个操作是对下标为4到下标为7的数字都加上3，朴素的做法是遍历一遍要操作的数组区间，然后执行操作就可以了，两次操作过后，原始数组累计要改变的值如下，

这样做执行每次操作的时间复杂度是数组的长度。那么如何利用差分数组来做呢？

对下标为3一直到下标为10的数字都加上2——>d[3]+=2，d[11]-=2。

对下标为4到下标为7的数字都加上3——>d[4]+=3，d[8]-=3。

然后求d数组的前缀和数组，结果如下，下标从1开始

此时sum里面的值表示的是原始数组要变动的值，将sum数组与原始数组相加，即是操作后的结果，可以发现是和表1一样的。而这样每次操作的时间复杂度是O（1）。

综上，如果我要对区间[l,r]里的数加上k，我只需要对差分数组进行操作，即d[l]+=k，d[r+1]-=k。

题目代码

import java.util.Scanner;public class Main {
public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int m = scanner.nextInt();long[] a = new long[n+1];long[] s = new long[n+1];for (int i = 1; i < a.length; i++) {a[i] = scanner.nextInt();}while(m>0) {m--;int l = scanner.nextInt();int r = scanner.nextInt();int k = scanner.nextInt();s[l] += k;if(r+1<=n) {s[r+1]-=k;}}long sum[] = new long[n+1];for (int i = 1; i < s.length; i++) {sum[i] = sum[i-1]+s[i];a[i] = a[i]+sum[i];System.out.print(a[i] +" ");}
}
}

二维差分模板题

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

9 8 6
8 7 5

题目分析

二维差分模板关键在于确定好在差分数组的哪些地方更改值。假设要更改的地方是从下标（2,4）到下标（3,6）的位置加1，那么首先必然是让（2,4）的位置加1，这样之后对差分数组求前缀和的结果如图所示，

我们要更改的是绿色圈起来的部分，但是之外的部分也更改了，我需要把这部分更改变回来，我想让（2,6）之后的从（2,7）开始都是0，既然（2,4）加了1，那么对应的（2,7）这一部分之后我要减掉1，来抵消前面的加1。同样，（4，4）也要减1来抵消（2,4）的加1。这样就可以了吗？这样相当于有两个位置减1，一个位置加1，一看也不对呀，对于（4,7）这个位置应该是没有变化的，但是它的前缀和所包含的格子里（2,4）加了1，（2,7）减了1，（4，4）也减了1，相当于（4,7）这个位置减了1，我们要把这个减1抵消，所以要在（4,7）这里加1。

综上，对（x1,y2）到（x2,y2）的格子都进行加k操作，只需要（x1,y1）+=k，（x1,y2+1）-=k，（x2+1,y1）-=k，（x2+1,y2+1）+=k。

然后对差分数组求二维前缀和之后，把结果累加到原始数组上就可以了。

题目代码

import java.util.Scanner;
public class Main{public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int m = scanner.nextInt();int q = scanner.nextInt();long[][] a = new long[n + 1][m + 1];long[][] b = new long[n + 1][m + 1];long[][] sum = new long[n + 1][m + 1];for (int i = 1; i <= n; i++) {for (int j = 1; j <= m; j++) {a[i][j] = scanner.nextLong();}}while ((q--) != 0) {int x1 = scanner.nextInt();int y1 = scanner.nextInt();int x2 = scanner.nextInt();int y2 = scanner.nextInt();int k = scanner.nextInt();b[x1][y1] += k;if (y2 + 1 <= m) {b[x1][y2 + 1] -= k;}if (x2 + 1 <= n) {b[x2 + 1][y1] -= k;}if (x2 + 1 <= n && y2 + 1 <= m) {b[x2 + 1][y2 + 1] += k;}}for (int i = 1; i <= n; i++) {for (int j = 1; j <= m; j++) {sum[i][j] = sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1]+b[i][j];a[i][j] += sum[i][j];System.out.print(a[i][j] + " ");}System.out.println();}}
}

abb

6
abcbcc

8

题目分析

在abcbcc中，acc的个数为3，他是哪3个呢？可以看下图，a的后面有3个c，在这3个c里面任选两个c可以和a组成一个叠词，那么组合的种类为$C_3^2$也就是$3\ast 2/2=3$种。假设字母a后面有num个相同的字母，那么它能够贡献的叠词个数为$C_{num}^2$，也就是$num\ast (num-1)/2$个。因此我们需要求出每个字母后面出现的其它相同字母的个数。

对于上图字符串，因为求的是后面的字符出现的次数，所以我们倒序遍历去求。位置6c出现了一次，用$num[6][c]=1$表示，位置5c出现了1次，用$num[5][c]=1$表示，位置3c出现了一次，用$num[3][c]=1$表示，其余位置$num[1,2,4][c]=1$都是0。那么求位置4后面包括位置4在内c出现的次数，应该是位置6的c累加上位置5的c，即$num[5][c]+num[6][c]$，求位置1后面c出现的次数，应该是$num[2][c]+num[3][c]+num[4][c]+num[5][c]+num[6][c]=0+1+0+1+1=3$。这里其实就是前缀和数组或者说是后缀和数组，因为求的是后面的值累加的结果。

综上，我们用$nums[i][c]$表示下标为i的位置的右边字符c出现的总次数。这里的数组就是后缀和数组。即$nums[i][c]=num[i+1][c]+num[i+2][c]+...+num[n][c]$。

那么$nums[i][c]=nums[i+1][c]+num[i][c]$。

题目代码

import java.util.Scanner;
public class abb {
public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();char[] s = (" "+scanner.next()).toCharArray();int pre[][] = new int[n+2][26];for(int i = n;i >= 1;i--) {for(int j = 0;j < 26;j++) {//求下标为i的位置包括下标i在内26个字母中，每个字母出现的次数。这里要用到前缀和pre[i][j] =pre[i+1][j];}pre[i][s[i]-'a']++;//这里就是加上位置i的字母}long sum = 0;for(int i = 1;i <= n;i++) {for(int j = 0;j < 26;j++) {//注意这里要有j!=s[i]-'a'的判断，因为aaa是不合法的//同样也要有pre[i][j]>=2的判断，因为后面至少要有两个才能组合出acc//pre[i+1][j]是i+1，因为pre[i][j]包含了位置i的字母，但是我们求的是i后面的字母//但其实用pre[i][j]也没有问题，因为这里的字母j肯定和位置i的字母不一样，那么必然不会对pre[i][j]数组产生作用，因为这里的num[i][j]=0if(pre[i][j]>=2&&j!=s[i]-'a') sum += (pre[i+1][j]-1)*pre[i
+1][j]/2;}}System.out.println(sum);
}
}

鼠鼠我鸭

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

6
16

题目分析

假设原本所有鸭鸭的重量是sum，操作后形成的偏移是fix，即经过至多1次操作后鸭鸭的总重量是sum+fix，这里的fix最小是0，因为如果操作后的fix是负数，会使得鸭鸭的总重量减少，倒不如不操作，直接是sum就可以了。

来看这个fix应该怎么求。以样例的第二组数据为例，如果操作区间是[0,4]，那么每个位置对应的偏移量分别为2，-5，6，5。总的偏移量为2-5+6+5=8。如果操作区间是[1,2]，总的偏移量为-5+6=1。其实要求某个区间的偏移量就是数组[2，-5，6，5]对应区间的区间和。这里的[2，-5，6，5]也叫做偏移量数组，因为对于位置i的值而言，如果他是鸭鸭，一次操作后就变为了鼠鼠，那么之前累加上的他的重量应该减去，所以偏移量就是负的该位置的重量也就是-a[i]，如果他是鼠鼠，一次操作后就变为了鸭鸭，他的重量应该累加上，所以偏移量就是该位置的重量也就是a[i]。所以我们可以求一下偏移量数组的前缀和，然后利用前缀和求最大的偏移量区间和，也就是一开始说的fix，累加到原始的重量和sum里面就好。

假设偏移量的前缀和数组是pre[i]，那么偏移量的区间和[l,r]就用pre[r]-pre[l-1]，如果我们遍历l和r的话，双层嵌套for循环会超时，所以这里应该采用类似双指针的做法，假设固定了r，要想pre[r]-pre[l-1]最大，需要pre[l-1]是区间[1,l-1]里面最小的那个数，用mi表示，关键代码如下，

fix=0;mi=0;
for(int i=1;i<=n;i++)  {fix=max(fix,s[i]-mi);//i固定时，mi是下标比i小的数中的最小值mi=min(mi,s[i]);}

fix最小是0，所以初始化为0。这里的mi最小值也为0，mi为0时表示的是区间[1,i]的区间和，如果mi不为负数，说明s[i]-mi会变小，即比s[i]本身小，倒不如直接用s[i]，s[i]表示的就是前i项之和，也是区间和。

题目代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;const int N=1e5+10;
ll g[N],w[N],s[N],p[N];
ll sum,fix,mi;int main(){int t;cin>>t;while(t--){int n;cin>>n;for(int i=1;i<=n;i++)cin>>g[i];for(int i=1;i<=n;i++)cin>>w[i];for(int i=1;i<=n;i++){s[i]=s[i-1]+(g[i] == 1 ? -1 : 1)*w[i]; //计算出施加魔法后的偏移值（鸭子重量），如果原来是1（鸭子）就要减去，原来是0（鼠）就加上}sum=0;for(int i=1;i<=n;i++) {sum+=w[i]*g[i];}fix=0,mi=0;for(int i=1;i<=n;i++){fix=max(fix,s[i]-mi);mi=min(mi,s[i]);}cout<<sum+fix<<'\n';}return 0;
}

代码有一个易错点，因为变量都是全局变量，所以sum，fix，e在每一组测试样例中都要重置为初始值。

import java.util.Scanner;
public class Main{static  int N=(int) (1e5+10);static long[] g=new long[N],w=new long[N],s=new long[N],p=new long[N];static long sum,fix,mi;
public static void main(String[] args) {int t;Scanner scanner = new Scanner(System.in);t = scanner.nextInt();while(t-- > 0){int n;n = scanner.nextInt();for(int i=1;i<=n;i++)g[i]=scanner.nextLong();for(int i=1;i<=n;i++)w[i]=scanner.nextLong();for(int i=1;i<=n;i++){s[i]=s[i-1]+(g[i] == 1 ? -1 : 1)*w[i]; //计算出施加魔法后的偏移值（鸭子重量），如果原来是1（鸭子）就要减去，原来是0（鼠）就加上}sum=0;for(int i=1;i<=n;i++) {sum+=w[i]*g[i];}fix=0;mi=0;for(int i=1;i<=n;i++)  //从第一个遍历到最后，计算出最大最小值{fix=Math.max(fix,s[i]-mi);mi=Math.min(mi,s[i]);}System.out.println(sum+fix);}}
}

前缀和的拓展——压缩矩阵

最大子段和

7
2 -4 3 -1 2 -4 3

4

题目分析

提供一下类似动态规划的解法，而这个动态规划dp数组的定义类似最长上升子序列里面dp数组的定义。

第一阶段定义dp数组

直接定义dp数组。dp[i]表示以第i个字母结尾的最大字段和。

第二阶段推导状态转移方程

对于dp[i]我可以从两个地方转移过来，即以a[i-1]结尾的最大子段和加上a[i]和a[i]自己，那么从这两个转移状态里面选一个最大的就可以了，状态转移方程是下面的式子。

$dp[i]=max(dp[i-1]+a[i],a[i])$

第三阶段写代码

（1）dp数组初始化。这里求的是最大值，一般初始状态是为0，但是这里可能会出现负数的情况，要初始化为较小值吗？不需要，我们可以看一下$dp[1]=max(dp[0]+a[1],a[1])$，这里的dp[0]=0是对的，因为对于前0个数字，它的和就是0。每次dp[i]都会可能的值被更新，而dp[i+1]只用到了dp[i]。所以不用初始化。写的有点啰嗦了。

（2）递推dp数组。这里只需要遍历一次a数组就行了。

（3）答案。min(dp[i])。

题目代码

import java.util.Scanner;
public class Main {
public static void main(String[] args) {Scanner scanner=new Scanner(System.in);int n = scanner.nextInt();int a[] = new int[n+1];int dp[] = new int[n+1];int ans = Integer.MIN_VALUE;for(int i = 1;i <= n;i++) {a[i] = scanner.nextInt();dp[i] = Math.max(dp[i-1]+a[i], a[i]);ans = Math.max(dp[i], ans);}System.out.println(ans);
}
}

最大加权矩形

 0 –2 –7  0 9  2 –6  2
-4  1 –4  1 
-1  8  0 –2

9  2
-4  1
-1  8

4
0 -2 -7 09 2 -6 2
-4 1 -4  1 
-1 8  0 -2

15

题目分析

这道题是最大子段和的二维形式。可尝试把它压缩成一维。我们利用前缀和对矩阵进行行压缩。行压缩的结果是$a[i][j]$里面存的是前i行第j列的和，其实就是相对于第j列的前缀和。假设$a[i][j]$初始值是矩阵的值，那么类比于$sum[i]=sum[i-1]+a[i]$的前缀和求解方法，可以利用下式求前缀和，
$$a[i][j]+=a[i-1][j]$$
求完前缀和后，如果我要求第j列，第l行到第r行的和，用$a[r][j]-a[l-1][j]$表示。如果我要求以i行结尾的矩阵的最大值，那么应该怎么求？如下图所示，

原本我求第j列某几行的和，我需要依次相加，但是压缩后，我只需要用一个式子一下子就可以表示出来第j列某几行的和，现在相当于把矩阵压缩成了一维的形式，我只需要移动j就可以了。定义两个数组f[j]和dp[j]，dp[j]的含义和最大子段和的含义一样，在行固定的情况下以第j列结尾的最大矩阵和，那么它的转移也和最大子段和一样，f[j]就表示在行固定的情况下第j列的矩阵和，它相当于最大子段和里面的a[i]。

对应的关键代码如下，

for(int i = 1;i <= n;i++) {for(int k = 1; k <= i;k++) {int f[] = new int[n+1];int dp[] = new int[n+1];for(int j = 1;j <= n;j++) {f[j] = a[i][j]-a[i-k][j];dp[j] = Math.max(dp[j-1]+f[j], f[j]);ans = Math.max(dp[j], ans);}}}

要想固定行，最低行和最高行都要固定，所以两层for循环是不可少的，固定了行之后再遍历列就可以了。

题目代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;public class Main {
public static void main(String[] args) throws IOException {BufferedReader br = new BufferedReader(new InputStreamReader(System.in));Scanner scanner = new Scanner(System.in);int n = scanner.nextInt();int a[][] = new int[n+1][n+1];for(int i = 1;i <= n;i++){int id = 1;for(int j = 1;j <= n;j++) {a[i][j] = scanner.nextInt();a[i][j] += a[i-1][j];//利用前缀和进行矩阵的行压缩}}long ans = 0;for(int i = 1;i <= n;i++) {for(int k = 1; k <= i;k++) {int f[] = new int[n+1];int dp[] = new int[n+1];for(int j = 1;j <= n;j++) {f[j] = a[i][j]-a[i-k][j];dp[j] = Math.max(dp[j-1]+f[j], f[j]);ans = Math.max(dp[j], ans);}}}System.out.println(ans);
}
}

如果题目分析有错误或者没有表达清楚的地方，欢迎在评论区里指出！