DP - 补

应某些人要求发出来了（

这应该是 24 年 3 月份结束编写的东西。

简介

动态规划常用于最优化或计数问题，通常要满足最优子结构（一个问题的答案可以由其子问题答案算出），无后效性（可以按某种顺序求解），子问题的重叠性（递归时可能会走到相同子问题）。

使用递归实现就是记忆化搜索，而如果我们能确定转移顺序那么我们就可以按顺序转移。

这一类问题通常考察思维，所以极其令我厌恶，通常是先设计一个状态，再想状态之间的转移，然后再优化。

背包

通常的问题形式是：

有 $n$ 类物品，物品有体积 $v$，有价值 $w$，需要满足一定限制的条件下选择物品是的价值和最大。大多数题目的限制都是提及综合不超过 $m$。

01 背包

这个背包的特殊之处在于每类物品只有一个。

为了防止一个物品多次选择，我们采用 从大到小枚举容积 的方式做。

转移方程明显为 $f_{i,j}\leftarrow \max (f_{i-1,j-v[i]}+w)$，可滚。

完全背包

这种背包每类物品有无限个，这样就不用关心一个物品是否多次重复选择，我们容许多次选择，那么可以 从小到大枚举容积。

转移方程不变，可滚。

一种非常简单的优化是如果有 $v_i\geq v_j$ 且 $w_i\leq w_j$，那么可以把种类 $i$ 踢掉。那么一种更为简单的方式是，对于 $v$ 相等的几类物品，只留下 $w$ 最大的物品即可。

多重背包

这种背包每种物品的物品有 $k$ 个。

首先可以二进制分组，把 $k$ 拆分为 $2^0+\cdots+2^p+q$ 的形式，前面 $2$ 的几个幂就可以配出 $1\sim k-q$ 的所有情况，加上 $q$ 就能配出 $1\sim k$ 的所有情况了，总物品数是 $O(\log k)$ 的，然后进行 01 背包。

也可以使用单调队列优化，此处先不提。

二维费用背包

多开一维记录状态即可。

分组背包

首先遍历每一组，内部首先从大到小枚举容量，再遍历每组中每个物品；外部遍历每个组即可。

板子题：P1757

// Problem: P1757 通天之分组背包
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1757
// Memory Limit: 128 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-03 20:11:30
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int n,m;
vector<pair<int,int> > v[101];
int a,b,k,ans;
int dp[1001];
int main(){
	ios::sync_with_stdio(0);
	cin>>m>>n;
	for(int i=1;i<=n;i++)cin>>a>>b>>k,v[k].push_back(make_pair(a,b));
	for(int i=0;i<=100;i++){
		for(int j=m;j>=0;j--){
			for(auto p:v[i]){
				if(j>=p.first)dp[j]=max(dp[j],dp[j-p.first]+p.second),ans=max(ans,dp[j]);
			}
		}
	}
	cout<<ans;
	return 0;
}

例题

P4141 消失之物

考虑 01 背包没有对顺序的要求，所以每次都可以把现在要撤销的贡献都当成最后一次加入的，那么可以直接撤销。转移方程式：$f_i=f_i+f_{i-w[j]}$。

// Problem: P4141 消失之物
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4141
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-03 20:43:35
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,m;
int w[10001];
int dp[10001]={1};
int cnt[10001];
signed main(){
	ios::sync_with_stdio(0);
	cin>>n>>m;
	for(int i=1;i<=n;i++)cin>>w[i];
	for(int i=1;i<=n;i++){
		for(int j=m;j>=w[i];j--){
			dp[j]+=dp[j-w[i]];
			dp[j]%=10;
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=0;j<=m;j++)cnt[j]=dp[j];
		for(int j=w[i];j<=m;j++)cnt[j]-=cnt[j-w[i]];
		for(int j=1;j<=m;j++)cout<<(cnt[j]%10+10)%10;
		cout<<"\n";
	}
	return 0;
}

LOJ 6089

小 Y 有一个大小为 $n$ 的背包，并且小 Y 有 $n$ 种物品。

对于第 $i$ 种物品，共有 $i$ 个可以使用，并且对于每一个 $i$ 物品，体积均为 $i$ 。

求小 Y 把该背包装满的方案数为多少，答案对于 $23333333$ 取模。

定义两种不同的方案为：当且仅当至少存在一种物品的使用数量不同。

考虑由于 $i\geq\sqrt n$ 时，可以发现每个物品都不可能选完，那么可以把这部分当做完全背包来做，所以我们根号分治来解决这个问题。

当 $i<\sqrt n$ 时，由于是计数题，可以使用模意义下的前缀和优化多重背包。

当 $i\geq \sqrt n$ 时，我们把操作拆分成两类：第一种是加入一个体积为 $\left\lceil \sqrt n \right\rceil$ 的物品，第二种是将所有物品的体积都加一，那么转移方程式就是 $g_{i,j}=g_{i-1,j-\left\lceil\sqrt n\right\rceil}+g_{i,j-i}$。

最后把两边卷起来即可，时间复杂度 $O(n\sqrt n)$。

// Problem: #6089. 小 Y 的背包计数问题
// Contest: LibreOJ
// URL: https://loj.ac/p/6089
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-04 18:46:54
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,B;
const int mod=23333333;
int f[100001],sum[100001],gsum[100001];
int g[320][100001];
signed main(){
	ios::sync_with_stdio(0);
	cin>>n;
	B=sqrt(n);
	f[0]=1;
	g[0][0]=1;
	for(int i=1;i<=B;i++){
		for(int j=0;j<i;j++)sum[j]=f[j];
		for(int j=i;j<=n;j++)sum[j]=(sum[j-i]+f[j])%mod;
		for(int j=n;j>=i;j--){
			if(j>=i*(i+1))f[j]=(sum[j]-sum[j-(i+1)*i]+mod)%mod;
			else f[j]=sum[j];
		}
	}
	for(int i=1;i<=B;i++){
		for(int j=B+1;j<=n;j++){
			g[i][j]=(g[i-1][j-B-1]+g[i][j-i])%mod;
		}
	}
	for(int j=0;j<=n;j++){
		for(int i=0;i<=B;i++)
			gsum[j]+=g[i][j],gsum[j]%=mod;
	}
	int ans=0;
	for(int i=0;i<=n;i++)ans+=f[i]*gsum[n-i],ans%=mod;
	cout<<ans;
	return 0;
}

P8392 物品

神仙 dp 题。

考虑弱化一下数据范围，我们首先贪心地全选，记和为 $s$。如果 $s>L$，那么就从大到小删除物品直到 $s\in[L-m,L]$；如果 $s<L$，那么从小到大删除物品直到 $s\in[L-m,L]$，如果这一步不能满足那么直接无解。这样做能使得在下面的背包中保证最优而保证不会使状态重复。

接下来考虑调整。首先，我们对于接下来的调整，一定能找到一种调整的顺序，使得背包里的物品和在 $[L-m,L+m]$ 之间，证明是简单的，当出现即将减出边界的时候，我们一定能在之后找到一个物品体积大于 $0$ 的来回到 $L$ 处，即将加出边界是一个道理。那么我们就证明了只可能有 $2m+1$ 种状态有效，即存在只使用 $\leq2m+1$ 次操作的方法进行调整。

那么极限情况下是减操作有 $m$ 个，加操作有 $m+1$ 个，背包值域开成 $[-m^2-m,m^2+m]$ 跑一遍二进制分组优化多重背包即可。值域开成这样而不是 $[-m^2,m^2]$ 是因为这样我感觉更严谨。

由于存在只用 $\leq 2m+1$ 次操作的方法进行调整，所以每个物品的个数最多有 $2m+1$ 个，时间复杂度就是 $O(m^3\log m)$。

注意用于反悔的物品的添加和体积为负时完全背包是正着扫的。

// Problem: P8392 [BalticOI 2022 Day1] Uplifting Excursion
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P8392
// Memory Limit: 128 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-05 09:35:09
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
#define int long long
using namespace std;
int used[1001],lef[1001];
int getid(int id){
	return id+301;
}
void use(int id,int num){
	used[getid(id)]+=num;
	lef[getid(id)]-=num;
	return;
}
void putb(int id,int num){
	used[getid(id)]-=num;
	lef[getid(id)]+=num;
	return;
}
int w[1000005],V[1000005],dp[5000005],ans,obcnt;
long long sum[10001];
long long m,l;
int s;
void insertobj(int val,int num,int v){
	// cout<<val<<" "<<num<<" "<<v<<"\n";
	// if(v==-6)return;
	if(num==0)return;
	int ed=log2(num)-1,nows=0;
	for(int o=0;o<=ed;o++){
		nows+=(1ll<<o);
		w[++obcnt]=val*(1ll<<o);
		V[obcnt]=v*(1ll<<o);
	}
	// cout<<num<<" "<<nows<<"\n";
	if(num==nows)return;
	w[++obcnt]=val*(num-nows);
	V[obcnt]=v*(num-nows);
	return;
}
signed main(){
	ios::sync_with_stdio(0);
	cin>>m>>l;
	for(int i=-m;i<=m;i++)cin>>sum[getid(i)],s+=sum[getid(i)]*i,use(i,sum[getid(i)]);
	// cerr<<s<<"\n";
	if(s>l){
		int now=m;
		while(s-sum[getid(now)]*now>l&&now>0)s-=sum[getid(now)]*now,putb(now,sum[getid(now)]),now--;
		if(now==0){
			cout<<"impossible";
			exit(0);
		}
		int divi=(s-l+now-1)/now;
		putb(now,divi);
		s=s-now*divi;
	}else if(s<l){
		int now=-m;
		while(s-sum[getid(now)]*now<l&&now<0)s-=sum[getid(now)]*now,putb(now,sum[getid(now)]),now++;
		// cout<<s<<" "<<now<<"\n";
		if(now==0){
			cout<<"impossible";
			exit(0);
		}
		int divi=(s-l)/now;
		putb(now,divi);
		s=s-now*divi;
	}
	for(int i=-m;i<=m;i++)ans+=used[getid(i)],lef[getid(i)]+=sum[getid(i)];
	// cout<<s<<" "<<l<<"\n";
	// for(int i=-m;i<=m;i++)cout<<used[getid(i)]<<" ";
	int goal=l-s+m*m+m;
	int pv=(m*m+m)*2;
	for(int i=0;i<=pv;i++)dp[i]=-1e18;
	dp[pv/2]=0;
	for(int i=-m;i<=m;i++){
		insertobj(-1,used[getid(i)],-i);
		insertobj(1,lef[getid(i)],i);
	}
	for(int i=1;i<=obcnt;i++){
		if(V[i]>0){
			for(int j=pv;j>=V[i];j--){
				dp[j]=max(dp[j],dp[j-V[i]]+w[i]);
			}
		}else{
			for(int j=0;j<=pv+V[i];j++){
				dp[j]=max(dp[j],dp[j-V[i]]+w[i]);
			}
		}
	}
	// cout<<dp[goal+6]<<"\n";
	if(dp[goal]<-2*m-1)cout<<"impossible";
	else cout<<(ans+dp[goal]);
	return 0;
}

区间 dp

简介

区间 dp 通常使用 $f_{l,r}$ 作为状态，来解决 $f_{1,n}$ 的问题。使用区间 dp 通常是因为求解的问题在区间上，并且答案可以从它的子区间转移过来。转移通常是枚举分界点 $mid$，从 $f_{l,mid-1}$ 和 $f_{mid,r}$ 转移过来，有时候也会从 $[l,r-1]$ 和 $[l+1,r]$ 转移过来。

转移时通常先枚举区间长度，再枚举左端点，再枚举其他参数（如分界点）。需要找到一个合适的方法将区间分割成的两个合法的区间可以简单合并。

例题

P1880 石子合并

有一个显然的转移： $f_{l,r}=\max_{mid\in[l,r)}(f_{l,mid}+f_{mid+1,r})+\sum_{i=l}^r a[i]$。

后面那部分使用前缀和，时间复杂度 $O(n^3)$，需要断环为链。

// Problem: P1880 [NOI1995] 石子合并
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1880
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-05 11:37:09
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int n,dp[201][201],a[1001],s[1001];
int main(){
	ios::sync_with_stdio(0);
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i],a[i+n]=a[i];
	for(int i=1;i<=2*n;i++)s[i]=s[i-1]+a[i];
	for(int i=2;i<=n;i++){
		for(int l=1;l<=2*n-i+1;l++){
			int r=l+i-1;
			for(int mid=l;mid<r;mid++){
				dp[l][r]=max(dp[l][r],dp[l][mid]+dp[mid+1][r]);
			}
			dp[l][r]+=s[r]-s[l-1];
		}
	}
	int maxx=0;
	for(int i=1;i<=n;i++){
		maxx=max(dp[i][i+n-1],maxx);
	}
	for(int i=2;i<=n;i++){
		for(int l=1;l<=2*n-i+1;l++){
			int r=l+i-1;
			for(int mid=l;mid<r;mid++){
				dp[l][r]=min(dp[l][r],dp[l][mid]+dp[mid+1][r]);
			}
			dp[l][r]+=s[r]-s[l-1];
		}
	}
	int minn=1e9;
	for(int i=1;i<=n;i++){
		minn=min(dp[i][i+n-1],minn);
	}
	cout<<minn<<"\n"<<maxx;
	return 0;
}

P5336 成绩单

首先想到设 $f_{l,r}$ 为区间 $[l,r]$ 的最优答案，不难发现这样仍无法转移，因为一个区间中可能选出多个区间使得剩余区间被分成 $O(n)$ 段。那么考虑我们直接暴力记录下剩余区间的最大最小值，则有状态 $g_{l,r,mx,mi}$ 表示区间 $[l,r]$ 中选出若干区间后剩余区间的最大最小值为 $mx$ 和 $mi$ 时，之前选出区间的代价最小值。

首先，有 $f_{l,r}=\min g_{l,r,mx,mi}+b\times(mx-mi)^2+a$。然后，我们再来思考如何转移 $g$ 数组。

我们把问题抽象成如果 $g$ 状态从右边又合并了一个元素时如何转移。

当新合并的元素 $r+1$ 分到了剩余区间中，那么有 $g_{l,r+1,\max(w[r+1],mx),\min(w[r+1],mi)}=\min(g_{l,r,mx,mi})$。

当新合并的元素随区间 $[k,r+1]$ 一起计算贡献时，有 $g_{l,r+1,mx,mi}=\min(g_{i,k,mx,mi}+f_{k+1,r+1})$。显然这里目前只能当前区间的 $mx,mi$ 内容，所以式子改写为 $g_{l,r,mx,mi}=\min(g+{i,k,mx,mi}+f_{k+1,r})$。

最后把 $g$ 数组里的内容转移到 $f$ 数组即可。

// Problem: P5336 [THUSC2016] 成绩单
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P5336
// Memory Limit: 500 MB
// Time Limit: 2000 ms
// Start coding at 2024-01-05 18:02:52
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int n;
int f[51][51],dp[52][52][52][52];
int d[51];
int w[51];
int a,b,tot;
int main(){
	ios::sync_with_stdio(0);
	cin>>n>>a>>b;
	for(int i=1;i<=n;i++)cin>>d[i],w[i]=d[i];
	for(int i=0;i<=n;i++)for(int j=0;j<=n;j++)f[i][j]=1e9;
	for(int i=0;i<=n;i++)for(int j=0;j<=n;j++)for(int k=0;k<=n;k++)for(int o=0;o<=n;o++)dp[i][j][k][o]=1e9;
	sort(d+1,d+n+1);
	tot=unique(d+1,d+n+1)-d-1;
	for(int i=1;i<=n;i++)w[i]=lower_bound(d+1,d+tot+1,w[i])-d,f[i][i]=a,dp[i][i][w[i]][w[i]]=0;
	for(int len=1;len<=n;len++){
		for(int l=1,r=len;r<=n;l++,r++){
			for(int mx=1;mx<=tot;mx++){
				for(int mi=1;mi<=mx;mi++){
					int &t1=dp[l][r][mx][mi];
					int &t2=dp[l][r+1][max(mx,w[r+1])][min(mi,w[r+1])];
					for(int k=l;k<r;k++)t1=min(t1,dp[l][k][mx][mi]+f[k+1][r]);
					t2=min(t2,t1);
					f[l][r]=min(f[l][r],t1+a+b*(d[mx]-d[mi])*(d[mx]-d[mi]));
				}
			}
		}
	}
	cout<<f[1][n];
	return 0;
}

AGC035D Add and Remove

考虑不难发现原序列左右两端的数只可能被统计到一次，那么我们可以给序列内的所有数一种分配对答案进行多少次贡献的方案使答案最小。

考虑对于任意两点中间插入一个值为 $a_p$ 的元素，而左右两元素对答案的贡献次数是 $xl$ 和 $xr$，那么中间这个元素对答案的贡献次数就是 $xl+xr$。

所以每次暴力枚举每个区间的端点，转移方程式为 $f_{l,r,xl,xr}=\min_{l<i<r}(f_{l,i,xl,xl+xr}+f_{i,r,xl+xr,xr}+a_i\times(xl+xr))$，其中，当 $r-l=1$ 时，不难发现所有贡献都已在之前的递归统计完毕，值为 $0$。

使用 dfs 实现。

// Problem: [AGC035D] Add and Remove
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/AT_agc035_d
// Memory Limit: 1 MB
// Time Limit: 2000 ms
// Start coding at 2024-01-05 20:26:39
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
#define int long long
using namespace std;
int a[21],n;
int dfs(int l,int r,int cntl,int cntr){
	if(r-l==1)return 0;
	int res=1e18;
	for(int i=l+1;i<=r-1;i++)res=min(res,dfs(l,i,cntl,cntl+cntr)+dfs(i,r,cntl+cntr,cntr)+a[i]*(cntl+cntr));
	return res;
}
signed main(){
	ios::sync_with_stdio(0);
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i];
	cout<<dfs(1,n,1,1)+a[1]+a[n];
	return 0;
}

留了一道 AGC039E 没补，因为感觉太抽象了。

树形 dp

简介

通常维护子树内的信息，然后在父亲处被遍历到然后转移。有些时候会求不同根的答案从而需要换根 dp。

TQX 给的例题太毒瘤了，之后再找几道。

数位 dp

简介

关键在于看出题目需要逐位进行 dp。

一般需要单独处理卡上界的情况，可以将卡上界作为一个状态，也可以把上界直接拆开。有时同时有上下界时需要转化成前缀和相减。

例题

P2657 windy 数

数位 dp 板子题。

首先我们定义状态 $f_{i,j}$ 是最高位为 $j$ 的 $i$ 位数中，有多少个数是 windy 数。这个易求，稍微拆一下式子可得：

\[f_{3,5}\to500\sim599\to\left\{\begin{matrix} 500\sim509\to00\sim09\to f_{2,0}\\ 510\sim519\to10\sim19\to f_{2,1}\\ 520\sim529\to20\sim29\to f_{2,2}\\ 530\sim539\to30\sim39\to f_{2,3}\\ \xcancel{540\sim549}(\abs{5-4}<2)\\ \xcancel{550\sim559}(\abs{5-5}<2)\\ \xcancel{560\sim569}(\abs{5-6}<2)\\ 570\sim579\to70\sim79\to f_{2,7}\\ 580\sim589\to80\sim89\to f_{2,8}\\ 590\sim599\to90\sim99\to f_{2,9} \end{matrix}\right. \]

由此我们对于任意 $f_{i,j}$，可以枚举每位的数判断转移是否合法，然后从 $f_{i-1,k}$ 转移过来。

这一步的代码实现：

int f[21][21];
void prework(){
    for(int i=0;i<10;i++)f[1][i]=1;
    for(int i=2;i<=10;i++){
        for(int j=0;j<10;j++){
            for(int k=0;k<10;k++){
                if(abs(j-k)>1)f[i][j]+=f[i-1][k];
            }
        }
    }
    return;
}

这时我们来拆贡献，以询问上界 $2952$ 为例。

\[2952\to\left\{\begin{matrix} 0\sim1999\\ 2000\sim2899\to000\sim899\\ 2900\sim2949\to00\sim49\\ 2950\sim2952 \end{matrix}\right. \]

根据 $f$ 的定义，计算 $0\sim1999$ 时，需要计算 $0\sim9$，$10\sim99$，$100\sim999$，$1000\sim1999$，极其复杂，所以我们另外定义一个数组 $pf$，来计算 $0\sim9\cdots 9$ 的 windy 数个数。而为什么不能直接用 $f_{4,0}$ 计算 $0\sim 999$ 呢，因为 $f_{4,0}$ 是针对于 $0000\sim0999$ 计算的，是带前导 $0$ 的。

这个 $pf$ 可以在 prework() 中一同处理出来。因为不难发现 $pf_i=pf_{i-1}+\sum_{j=1}^9f_{i,j}$。

int f[21][21],pf[21];
void prework(){
    for(int i=0;i<10;i++)f[1][i]=1;
    pf[0]=1,pf[1]=10;
    for(int i=2;i<=10;i++){
        for(int j=0;j<10;j++){
            for(int k=0;k<10;k++){
                if(abs(j-k)>1)f[i][j]+=f[i-1][k];
            }
        }
        pf[i]=pf[i-1];
        for(int j=1;j<10;j++)pf[i]+=f[i][j];
    }
    return;
}

这个时候就完全可以拆开 $2952$ 这个数了。

\[2952\to\left\{\begin{matrix}\begin{aligned} &0\sim1999\left\{\begin{matrix} 0\sim999\to pf_3\\ 1000\sim1999\to f_{4,1} \end{matrix}\right.\\ &2000\sim2899\left\{\begin{matrix} 000\sim099\to f_{3,0}\\ \xcancel{100\sim199}(\abs{2-1}<2)\\ \xcancel{200\sim299}(\abs{2-2}<2)\\ \xcancel{300\sim399}(\abs{2-3}<2)\\ 400\sim499\to f_{3,4}\\ \cdots\\ 800\sim899\to f_{3,8} \end{matrix}\right.\\ &2900\sim2949\to\sum_{k=0}^4f_{2,k}\\ &2950\sim2952\to\sum_{k=0}^2f_{1,k} \end{aligned}\end{matrix}\right. \]

当然，有些较特殊的数，比如 $2377$，算了 $0\sim2299$ 之后就不能算了，因为这个时候出现了固定的两位不合法的情况，无论后面填什么，这个数都会不合法。

那么可以依照拆的这个思路写出代码：

int tmp[11];
int calc(int x){
    int org=x,cnt=0,res=0;
    while(org){tmp[++cnt]=org%10,org/=10;}
    res=pf[cnt-1];
    for(int i=1;i<tmp[cnt];i++)res+=f[cnt][i];
    for(int i=cnt-1;i>0;i--){
        for(int j=0;j<tmp[i];j++){
            if(abs(j,tmp[i+1])>1)res+=f[i][j];
        }
        if(abs(tmp[i+1]-tmp[i])<2)break;
    }
    return res;
}

不难发现这份代码只求了 $0\sim2951$ 的数，因为再处理一遍 $2952$ 需要添加较多代码，为了精简省去了这些特判。

完整代码：

// Problem: P2657 [SCOI2009] windy 数
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2657
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-08 21:11:00
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int f[21][21],pf[21],tmp[11];
void prework(){
	for(int i=0;i<10;i++)f[1][i]=1;
	pf[0]=1;
	pf[1]=10;
	for(int i=2;i<=10;i++){
		for(int j=0;j<10;j++){
			for(int k=0;k<10;k++){
				if(abs(j-k)>1)f[i][j]+=f[i-1][k];
			}
		}
		pf[i]=pf[i-1];
		for(int j=1;j<10;j++)pf[i]+=f[i][j];
	}
	return;
}
int calc(int x){
	int cnt=0,res=0;
	while(x){
		tmp[++cnt]=x%10;
		x/=10;
	}
	res=pf[cnt-1];
	for(int i=1;i<tmp[cnt];i++)res+=f[cnt][i];
	for(int i=cnt-1;i>=1;i--){
		for(int j=0;j<tmp[i];j++){
			if(abs(j-tmp[i+1])>1)res+=f[i][j];
		}
		if(abs(tmp[i+1]-tmp[i])<2)break;
	}
	return res;
}
int l,r;
int main(){
	ios::sync_with_stdio(0);
	cin>>l>>r;
	prework();
	cout<<calc(r+1)-calc(l)<<"\n";
	return 0;
}

P4999 烦人的数学作业

同样定义 $f_{i,j}$ 为第 $i$ 位首位为 $j$ 时的答案，同样可以转移：$f_{i,j}=\sum_{k=0}^9f_{i-1,k}+10^{i-1}\times j$。

并且统计答案时不需要判断什么，较为简单。

// Problem: P4999 烦人的数学作业
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4999
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-09 20:14:44
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1e9+7;
int f[21][21],_10[21]={1};
void prework(){
	for(int i=0;i<10;i++)f[1][i]=i;
	for(int i=2;i<=19;i++){
		for(int j=0;j<10;j++){
			for(int k=0;k<10;k++){
				(f[i][j]+=f[i-1][k])%=mod;
			}
			f[i][j]+=_10[i-1]*j%mod;
			f[i][j]%=mod;
		}
	}
	return;
}
int T,l,r;
int tmp[21];
int calc(int x){
	int res=0,cnt=0;
	while(x){
		tmp[++cnt]=x%10;
		x/=10;
	}
	int nowsum=0;
	for(int i=cnt;i>=1;i--){
		for(int j=0;j<tmp[i];j++)res=(res+f[i][j])%mod;
		res=(res+_10[i-1]*nowsum%mod*tmp[i]%mod)%mod;
		nowsum+=tmp[i];
	}
	return res;
}
signed main(){
	ios::sync_with_stdio(0);
	for(int i=1;i<=20;i++)_10[i]=_10[i-1]*10%mod;
	cin>>T;
	prework();
	while(T--){
		cin>>l>>r;
		cout<<(calc(r+1)-calc(l)+mod)%mod<<"\n";
	}
	return 0;
}

P2602 数字计数

考虑定义一个结构体存每个数字的出现次数，然后按 P2657 的方式转移即可。

// Problem: P2602 [ZJOI2010] 数字计数
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2602
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-09 20:48:19
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
#define int long long
struct an{
	int cnt[10];
	an operator + (const an &a) const{
		an res;
		for(int i=0;i<10;i++)res.cnt[i]=cnt[i]+a.cnt[i];
		return res;
	}
	an operator - (const an &a) const{
		an res;
		for(int i=0;i<10;i++)res.cnt[i]=cnt[i]-a.cnt[i];
		return res;
	}
	void print(){
		for(int i=0;i<10;i++)cout<<cnt[i]<<" ";
		cout<<"\n";
		return;
	}
	void init(){
		for(int i=0;i<10;i++)cnt[i]=0;
		return;
	}
}f[21][21],pf[21];
int _10[21]={1};
void prework(){
	for(int i=0;i<10;i++)f[1][i].cnt[i]++;
	pf[0].cnt[0]++;
	for(int i=0;i<10;i++)pf[1].cnt[i]++;
	for(int i=2;i<=20;i++){
		for(int j=0;j<10;j++){
			for(int k=0;k<10;k++){
				f[i][j]=f[i][j]+f[i-1][k];
			}
			f[i][j].cnt[j]+=_10[i-1];
			// f[i][j].print();
		}
		pf[i]=pf[i-1];
		for(int j=1;j<10;j++)pf[i]=pf[i]+f[i][j];
	}
	return;
}
int tmp[21];
an calc(int x){
	an res;
	res.init();
	int cnt=0,org=x;
	while(x){
		tmp[++cnt]=x%10;
		x/=10;
	}
	res=res+pf[cnt-1];
	for(int i=1;i<tmp[cnt];i++)res=res+f[cnt][i];
	org-=tmp[cnt]*_10[cnt-1];
	for(int i=cnt-1;i>=1;i--){
		res.cnt[tmp[i+1]]+=org;
		for(int j=0;j<tmp[i];j++)res=res+f[i][j];
		org-=tmp[i]*_10[i-1];
	}
	return res;
}
signed main(){
	ios::sync_with_stdio(0);
	for(int i=1;i<=18;i++)_10[i]=_10[i-1]*10;
	prework();
	int l,r;
	cin>>l>>r;
	(calc(r+1)-calc(l)).print();
	return 0;
}

UOJ140【UER #4】被粉碎的数字

TQX 的题解省去了好多细节。

考虑仍然使用数位 dp 解决。我们来分析一下什么状态时必要的。

数位 dp 的通常转移方式是从低位到高位转移，于是对于每一位要乘 $k$ 来讲，我们要统计这一位像下一位进了多少位，还要统计到这一位了，$f(x)$ 与 $f(kx)$ 之间的差是多少。最重要的是，因为 $1\leq x\leq R$，我们要保证 $x$ 在范围内的话，我们就要再记录一个 当前位 x 是否超出 R 的边界 ，即 $x_{cur}$ 与 $R_{cur}$ 的关系，当 $x_i=R_i$ 时，$nxtlim$ 不变，即和准备转移过来的 $lim$ 一致。转移的时候就两边分别转移即可。

// Problem: #140. 【UER #4】被粉碎的数字
// Contest: UOJ
// URL: https://uoj.ac/problem/140
// Memory Limit: 256 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-10 15:37:35
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
#define int long long
int dp[31][411][1011][2];
int R,k,cnt;
int tmp[31];
signed main(){
	ios::sync_with_stdio(0);
	cin>>R>>k;
	while(R){
		tmp[++cnt]=R%10;
		R/=10;
	}
	cnt+=3;//k<=1000
	dp[0][200][0][0]=1;
	for(int i=0;i<cnt;i++){
		for(int j=0;j<=400;j++){
			for(int h=0;h<=999;h++){
				for(int lim=0;lim<=1;lim++){
					for(int x=0;x<10;x++){
						int nxtlim=(tmp[i+1]==x?lim:(tmp[i+1]<x));
						dp[i+1][j+x-(k*x+h)%10][(k*x+h)/10][nxtlim]+=dp[i][j][h][lim];
					}
				}
			}
		}
	}
	cout<<dp[cnt][200][0][0]-1;
	return 0;
}

恶补数位 dp。剩余的题详见 Problem_unruled_record。

状压 dp

简介

就是 dp 的时候出现了若干维，但是值域都很小（大多是选择是或不是），这个时候可以用进制压位。多数情况是压到 $2^n$，可能会与 meet in middle 或者什么 FWT 一起用，也出现在数据分治时用。

例题

P1879 Corn Fields

设状态 $f_{i,j}$ 为前 $i$ 行，第 $i$ 行状态为 $j$ 时的方案数。不难发现每一行选择哪些种草的状态能压到一个 int 里。以此作为状态，暴力枚举上一行和这一行的所有状态然后转移即可。时间复杂度 $O(n2^{2n})$。

// Problem: P1879 [USACO06NOV] Corn Fields G
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1879
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-11 19:38:31
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
const int mod=1e8;
int f[13][(1<<12)];
int n,m;
int g[13];
bool te[(1<<12)];
int tt;
int main(){
	ios::sync_with_stdio(0);
	cin>>m>>n;
	for(int i=1;i<=m;i++){
		for(int j=1;j<=n;j++){
			cin>>tt;
			g[i]+=(tt<<(n-j));
		}
	}
	for(int i=0;i<(1<<12);i++){
		te[i]=1;
		for(int j=1;j<12;j++)if(((i>>j)&1)&&((i>>(j-1))&1))te[i]=0;
	}
	f[0][0]=1;
	for(int i=1;i<=m;i++){
		for(int j=0;j<(1<<n);j++){
			for(int k=0;k<(1<<n);k++){
				if(!f[i-1][k])continue;
				if(te[j]&&((((1<<n)-1)^k)&g[i]&j)==j)(f[i][j]+=f[i-1][k])%=mod;
			}
		}
	}
	int ans=0;
	for(int i=0;i<=(1<<n)-1;i++)(ans+=f[m][i])%=mod;
	cout<<ans;
	return 0;
}

P3204 [HNOI2010] 公交线路

题解真的是没有一个是真正讲清楚了的。

考虑根据限制，我们可以转化一下贡献：即在任意一个 $[i,i+p-1]$ 的区间内，一定存在一个子序列是 $[1,K]$ 的排列。

我们设距离 $i$ 最近的且在区间 $[i,i+p-1]$ 内的 $[1,K]$ 之间的数为有效状态，那么这里就能使用 $0/1$ 状压，考虑如何转移。

首先不难发现，我们转移的对象就是删掉首位元素，然后再末尾补一个 $0$ 后的数。

我们举个例子：$p=5,K=3$ 时，假如有状态 $10110$，那么第二个 $0$ 必须被前面的 $1$ 转移，即 $10110\to 11100$。而如果有状态 $11001$，那么第一位实际上能转移到剩下的任何一个 $0$ 的位置上，于是有 $11001\to10110$ 和 $11001\to11010$ 和 $11001\to10011$。

从上面两个例子来看其实我们能枚举每一个数然后枚举每个操作后的 $0$，在 $O(p\times 2^{p})$ 的时间复杂度内完成转移的构建。

看到 $N\leq 10^9$ 的数据范围，想到矩阵转移，上面的转移明显是一个 $dp_{i,j}=\sum_{k}dp_{i-1,k}$ 的形式，直接构建转移矩阵然后转移即可。这个地方不难发现上面的所有状态的首位都是 $1$，然后我们离散化一下，状态数为 $\binom {P-1} {K-1}$，最大状态数为 $\binom 9 5=126$，设 $k=126$，时间复杂度为 $O(k^3\log N+p2^p)$，可以通过。

DP 的优化

数据结构优化 DP

单调队列优化 DP

首先复习一下单调队列。

单调队列就是维护一个双端队列，保证队内元素降序，每次移动区间时如果这个数的最大值就是弹出的数，那么就弹出这个下标，然后加入末尾的数。加入时保证序列内元素值有序。

而单调队列优化 DP 就是 $f_{i}$ 可以从 $\max_{l\leq k\leq r}(f_k)$ 转移过来，并且 $l,r$ 均单调不减时，可以使用单调队列优化。如果保证 $l=1$，那么左侧不用弹出，可以使用单调栈维护。

Slope Trick

非常难以理解的用堆维护的优化 DP 方式。

考虑我们现在得到了一个 DP 转移方程式 $f_{i,j}=\cdots$，并且可以用数学归纳法证明 $f_{i,*}$ 是有凸性并且是一次分段函数，如果该函数的所有斜率都能用整数表示，我们可以考虑使用记录拐点和最右侧无限延伸的一条射线的方式来来记录整个凸壳。假如说该拐点的左右两端的一次函数斜率相差为 $p$，那么就在此处放 $p$ 个相同的拐点坐标来记录。

设凸函数 $C$ 的拐点集合为 $S$，直线为 $f$，那么合并 $C_1,C_2$ 到 $C$ 处则需要进行 $S=S_1\cup S_2$，$f=f_1+f_2$（斜率相加，截距相加）。

显然可以用可并堆可以轻松维护。当然，每道题有不同的转移方式，就会有不同的合并方式，比如可能需要弹出某些元素再进行合并等。

其他数据结构优化 DP

使用我们熟知的线段树、树状数组等结构，可以用来处理一些区间转移或者类似

转移的 dp。基本上重点是在数据结构上，这里不多赘述。——TQX 课件

例题

Slope Trick 较为难懂，所以可能很大篇幅在说这个。

CF713C Sonya and Problem Wihtout a Legend

（这个题目名打错了吗？）

设 $f_{i,j}$ 为第 $i$ 个位置填 $j$ 时达成 严格递增 的最小代价，不难发现转移方程式：

\[f_{i,j}=\min_{k<j}(f_{i-1,k})+\abs{a_i-j} \]

但是 $a_i\leq10^9$ 的数据显然不允许我们用这个转移方程式转移，所以我们考虑离散化后怎么做。

首先我们不难发现此时 非降 很好做，此时：

\[f_{i,j}=\min_{k\leq j}(f_{i-1,k})+\abs{a_i-j} \]

并且满足离散化，因为最优情况下就是把这个数变到某个数一样的位置，这样给后面的空间最大，并且代价最小。

那么考虑如何把 严格递增 转化成 非降。

我们如果将 $a_i$ 减去 $i$，我们就能将严格递增变为非降，因为我们达成了 非降 时的最优时，我们加上 $i$ 就能保证严格递增，显然此时非降算出来的答案一定最优，因为此时相邻两数的差都扩大了 $1$，而我们之前转移时都是转移到已知的数上。

这个时候我们已经有 $O(n^2)$ 的做法了。但是这个做法并不优秀，我们可以考虑优化。

其实看到 $\min$ 和绝对值我们就已经可以想到凸性了。

考虑把 $f_{i,j}$ 改写为一个分段函数 $f_i(j)$。不难发现 $\min_{k\leq j}(f_{i-1}(k))$ 一定是随 $j$ 的增大递减的，而 $\abs{a_i-j}$ 是随着 $j$ 的增大先递减后递增的。所以 $f_i$ 这个函数一定是下凸的。用数学归纳法可以证明 $f_i$ 函数的图像连续，即每两段函数之间均仅有一个拐点。

由于只需维护 $\min$ 值，所以我们没有必要维护右侧递增的凸壳，只需维护左侧递减的凸壳即可。而 $\abs{a_i-j}$ 是一个一次函数，所以我们每次只用添加两个 $a_i$ 的拐点。因为每次我们加入的点有 $2$ 个，所以如果我们加入的点在最大的点之前，我们一定会把最后一段斜率为 $0$ 的一段变成斜率为 $1$ 的一段，此时要删除最大的拐点；

而加入第一个点是将该点之前的所有线段斜率减 $1$，加入第二个点是将该点之前的所有线段斜率加 $1$，所以当我们加入第二个点时统计答案。由于其右侧所有直线的斜率都增加 $1$，所以答案的增量就是该点与该点未加入时集合中的最大值的差。

如果我们加入的点在最大的点之后，我们显然只用加一个点就行了，因为另外那个点会被删掉。

// Problem: Sonya and Problem Wihtout a Legend
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/CF713C
// Memory Limit: 250 MB
// Time Limit: 5000 ms
// Start coding at 2024-01-15 09:14:47
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
// #define int long long
priority_queue<int> q;
int main(){
	ios::sync_with_stdio(0);
	int n,a;
	long long ans=0;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a;
		a-=i;
		q.push(a);
		if(a<q.top())q.push(a),ans+=q.top()-a,q.pop();
	}
	cout<<ans;
	return 0;
}

求方案：P4331

考虑首先记录下每次的 $\min$ 值所在下标 $a_i$。不难发现，当加入的数小于当前最大值，$\min$ 值对应下标变小，否则 $\min$ 值对应下标变大。

考虑我们模拟一下这个过程，把原序列看成 $O(n)$ 个非降序列和 $O(n)$ 个非升序列，那么假设有：

作为原序列值的走向，那么有：

作为其 $\min$ 值走向。

观察可得，每次删除等于是在与前面所有拐点的中位数（或：平衡状态）靠近，而加入一个最大值就是纯加入一个最大值。

显然我们对于一段先升后降的函数取其中位数一定不劣，并且在中位数附近微调确实能做到最优。所以我们不难得到式子 $a_{i}\leftarrow \min(a_{i},a_{i+1})$，因为每次 $a_i$ 每次都最靠近平衡时的的最优情况，而 $a_i$ 单调递增时此时原序列一定单调递增，不改一定最优。这样做就能保证该不该时就不改，该平衡时平衡。

// Problem: P4331 [BalticOI 2004] Sequence 数字序列
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4331
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-15 11:44:23
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int a[1000001];
priority_queue<int> q;
int x,n;
long long ans;
int main(){
	ios::sync_with_stdio(0);
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>x;
		x-=i;
		q.push(x);
		if(x<q.top())q.push(x),ans+=q.top()-x,q.pop();
		a[i]=q.top();
	}
	for(int i=n-1;i>=1;i--)a[i]=min(a[i],a[i+1]);
	cout<<ans<<"\n";
	for(int i=1;i<=n;i++)cout<<a[i]+i<<" ";
	return 0;
}

P3642 [APIO2016] 烟火表演

前置知识是可并堆，这个数据结构在我的数据结构学习笔记还没有提到，之后会补（毕竟 dp -> 数学 -> 图论（树论） -> ds -> 贪心 -> 字符串续 -> GEO -> 博弈）。

考虑设 $f_{i,j}$ 为 $i$ 点点燃后 $j$ 时刻其子树内所有烟花全部同时点燃所需要花费的最小代价。首先有一般树形 DP 方程式：

\[f_{i,j}=\sum_{v\in son_i}\min_{k\leq j}f_{v,k}+\abs{w_{i,v}-(j-k)} \]

看样子是函数至点的一个转移。但是对于每个点，由于 $j$ 每次增量固定为 $1$，所以其实还是可以从函数至函数转移。同样的，这个函数能用数学归纳法证明其为下凸函数，并且适用于 Slope Trick。

首先考虑原函数 $f_{i}(x)$ 整体加上一个数 $k$ 后的改变，首先这个函数会变成 $g(x+k)$，然后所有值均向上移 $k$。因为加上 $k$ 代表此时并不是 $x$ 时刻时全部被点燃，而是 $x+k$ 时刻时全部被点燃。那么对于拐点集合，加上一个数 $k$ 就代表所有拐点全部向右移动 $k$。下面就可以开始分讨了。设 $L,R$ 为函数 $f_v$ 斜率为 $0$ 一段的左右端点。

对于 $x<L$ 时，往右移动函数代表询问点向左移动，一定不优，所以我们干脆就不加任何数，所以 $f_i(x)=f_v(x)+w_{i,v}$。

对于 $L\leq x<L+w_{i,v}$ 时，询问点向左移动最多到 $L$ 之后再想向左移一定不优，所以移动到 $L$ 就要停止，这时移动量为 $x-L$，那么 $f_i(x)=f_v(L)+(w_{i,v}-(x-L))$。

对于 $L+w_{i,v}\leq x<R+w_{i,v}$，此时询问点左移 $w_{i,v}$ 一定在 $[L,R]$ 间。那么不需要任何修改即可， $f_i(x)=f_v(L)$。

对于 $x\geq R+w_{i,v}$ 时，此时询问点显然一直左移到 $R$ 一定不劣，而只移动 $w_{i,v}$ 是不够的，所以要加长导火索。有 $f_i(x)=f_v(L)+(x-R-w_{i,v})$。

我们一个函数一个函数的看。

对于 $f_i(x)=f_v(x)+w_{i,v}$，将原函数向上移动 $w_{i,v}$ 即可。

对与 $f_i(x)=f_v(L)+(w_{i,v}-(x-L))$，不难发现 $f_i(x)$ 随 $x$ 的增大而减小。因此我们要添加一段 $[L,L+w_{i,v}]$ 的斜率为 $-1$ 的一段，这一段和原来之前函数的一段斜率为 $-1$ 的一段正好接上，所以仅对于这个操作而言，我们可以删去 $L$ 的拐点并且添加上一个 $L+w_{i,v}$ 的拐点。

对于 $f_i(x)=f_v(L)$，就是把 $[L,R]$ 这段斜率为 $0$ 的部分平移到 $[L+w_{i,v},R+w_{i,v}]$ 上，此时根据前面两段的分析，我们不难发现此时这两段高度相同。所以我们删去 $R$ 这个拐点，并添加 $R+w_{i,v}$ 这个拐点。

最后，对于 $f_i(x)=f_v(L)+(x-R-w_{i,v})$，不难发现这个函数斜率为 $1$，而根据之前三个函数的拐点添加与删除，如果我们删除之前函数 $\geq R$ 的所有拐点，我们就能保证最后这个函数斜率一直为 $1$。

总结一下，我们删除原函数 $>L$ 的所有拐点并删除一次 $L$ 本身，然后添加 $L+w_{i,v},R+w_{i,v}$ 两个拐点。我们就做好了我们合并到下一个函数的准备工作。

考虑如何找到 $L$。对于一个函数，他的儿子处理后一定会有一个斜率为 $1$ 的直线，也就是说，在找 $L$ 时，其凸壳最大斜率为 $cnt_{son}$。那么我们就需要弹出 $cnt_{son}-1$ 个最大的拐点就能找到 $R$，弹出 $R$ 之后就能找到 $L$。使用可并大根堆维护。

最后就是讨论如何得到答案。首先有 $f_{1,0}=\sum_{i,j} w_{i,j}$。然后我们可以锁定 $L$，然后一直弹出并在 $f_{1,0}$ 中删除拐点的下标值直到拐点集合为空，最后得到的值就是 $f_{1,L}$。我们可以这样理解这个问题：我们正着想一下这个过程，设拐点集合大小为 $S$，那么最大斜率为 $S$。我们删除最小的拐点下标代表我们再继续删 $S-1$ 次这个下标，删除次小的代表我们会继续删 $S-2$ 次次小与最小的下标值差。这样正好和斜率导致的减量对应。

// Problem: P3642 [APIO2016] 烟火表演
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3642
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-15 19:45:06
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
long long val[600005];
int ch[600005][2],rt[300005],pa[300005];
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int cnt;
int addP(long long x){
	val[++cnt]=x;
	return cnt;
}
int merge(int x,int y){
	if(!x||!y)return x+y;
	if(val[x]<val[y])swap(x,y);
	int op=rnd()&1;
	ch[x][op]=merge(ch[x][op],y);
	return x;
}
void pop(int x){
	// cerr<<x<<" "<<rt[x]<<" "<<ch[x][0]<<" "<<ch[x][1]<<"\n";
	rt[x]=merge(ch[rt[x]][0],ch[rt[x]][1]);
	return;
}
int n,m;
int x,y,degs[300005],w[300005];
long long ans;
int main(){
	ios::sync_with_stdio(0);
	cin>>n>>m;
	for(int i=2;i<=n+m;i++){
		cin>>x>>y;
		pa[i]=x;
		degs[x]++;
		w[i]=y;
		ans+=w[i];
	}
	for(int i=n+m;i>=2;i--){
		// cerr<<i<<" now dealing\n";
		for(int j=1;j<=degs[i]-1;j++)pop(i);
		long long R=val[rt[i]];pop(i);
		long long L=val[rt[i]];pop(i);
		rt[i]=merge(rt[i],merge(addP(L+w[i]),addP(R+w[i])));
		rt[pa[i]]=merge(rt[pa[i]],rt[i]);
	}
	while(degs[1]--)pop(1);//,cerr<<degs[1]<<"\n";
	// cerr<<"\n";
	while(rt[1])ans-=val[rt[1]],pop(1);
	cout<<ans;
	return 0;
}

还有部分 Slope Trick 的题待补。

P2627 [USACO11OPEN] Mowing the Lawn G

考虑一般 dp 方程式。设 $f_{i,j}$ 为选到第 $i$ 个，此时不选第 $i$ 个的最大贡献。有：

\[f_{i}=\max_{1\leq p\leq k+1}(f_{i-p}+pre_{i-1}-pre_{i-p}) \]

观察式子可以发现把 $f_{i-p}-pre_{i-p}$ 单调队列优化掉。时间复杂度 $O(n)$。

// Problem: P2627 [USACO11OPEN] Mowing the Lawn G
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2627
// Memory Limit: 128 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-17 18:11:05
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
long long dp[100005],E[100005];
int n,k;
deque<long long> q;
int main(){
	ios::sync_with_stdio(0);
	cin>>n>>k;
	for(int i=1;i<=n;i++)cin>>E[i],E[i]+=E[i-1];
	E[n+1]=E[n];
	// for(int i=1;i<=n+1;i++){
		// for(int j=max(0,i-k-1);j<=i-1;j++){
			// dp[i]=max(dp[i],dp[j]+E[i-1]-E[j]);
		// }
	// }
	// cout<<dp[n+1];
	q.push_back(0);
	for(int i=1;i<=n+1;i++){
		if(q.front()+k+1<i)q.pop_front();
		dp[i]=dp[q.front()]+E[i-1]-E[q.front()];
		while(!q.empty()&&dp[i]-E[i]>dp[q.back()]-E[q.back()])q.pop_back();
		q.push_back(i);
	}
	cout<<dp[n+1];
	return 0;
}

P2569 [SCOI2010] 股票交易

考虑列出朴素 dp 方程式：

\[dp_{i,j}=\max_{p\leq i-W-1,j\leq k\leq \min(j+bs_i,maxp)}(dp_{p,k}+bp_i\times(k-j))\\ dp_{i,j}=\max_{p\leq i-W-1,\max(j-as_i,0)\leq k\leq j}(dp_{p,k}+ap_i\times(k-j)) \]

发现是一个 $O(n^4)$ 的 dp，用单调队列优化 $p$ 一维可以优化到 $O(n^3)$。

考虑重构 dp 方程式，提前优化掉一维。不难发现我们可以添加一条 $dp_{i,j}=\max(dp_{i,j},dp_{i-1,j})$。这一条就严格保证了 $dp_{i,j}$ 是在前 $i$ 个最优的，而不是第 $i$ 个最优的。那么在上面的 dp 方程式中，我们有 $p=i-W-1$。

发现我们可以单调队列优化 $k$ 一维，扫两次，单调队列比较的值是 $bp_i\times k$ 或 $ap_i\times k$ 加上 $dp_{i-W-1,k}$，因为 $-bp_i\times j$ 或 $-ap_i\times j$ 是可以提出 $\max$ 函数内的。

代码像坨史。

// Problem: P2569 [SCOI2010] 股票交易
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P2569
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-18 20:02:52
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
deque<int> q[2005][2];
int dp[2005][2005];
int n,maxp,W;
int ap[2005],bp[2005],as[2005],bs[2005];
int main(){
	ios::sync_with_stdio(0);
	cin>>n>>maxp>>W;
	for(int i=1;i<=n;i++)cin>>ap[i]>>bp[i]>>as[i]>>bs[i];
	for(int i=0;i<=n;i++){
		for(int j=0;j<=maxp;j++){
			dp[i][j]=INT_MIN+1e9;
		}
	}
	dp[0][0]=0;
	for(int i=1;i<=W;i++){
		dp[i][0]=0;
		for(int j=1;j<=maxp;j++){
			if(j<=as[i])dp[i][j]=-ap[i]*j;
			dp[i][j]=max(dp[i-1][j],dp[i][j]);
		}
	}
	for(int i=W+1;i<=n;i++){
		// cerr<<i<<"\n";
		for(int j=0;j<=maxp;j++)dp[i][j]=dp[i-1][j];
		for(int j=0;j<=maxp+bs[i]-1;j++){
			// cerr<<j<<" in1\n";
			if(!q[i][0].empty()&&q[i][0].front()<=j-bs[i])q[i][0].pop_front();
			if(j<=maxp){
				while(!q[i][0].empty()
				&& dp[i-W-1][q[i][0].back()]
				+ bp[i]*q[i][0].back()
				< dp[i-W-1][j]
				+ bp[i]*j)
					q[i][0].pop_back();
				q[i][0].push_back(j);
			}
			if(j>=bs[i])dp[i][j-bs[i]]=max(dp[i][j-bs[i]],
			dp[i-W-1][q[i][0].front()]+bp[i]*(q[i][0].front()-(j-bs[i])));
		}
		// cerr<<"end\n";
		for(int j=0;j<maxp;j++){
			if(!q[i][1].empty()&&q[i][1].front()<=j-as[i])q[i][1].pop_front();
			while(!q[i][1].empty()
			&& dp[i-W-1][q[i][1].back()]
			+ ap[i]*q[i][1].back()
			< dp[i-W-1][j]
			+ ap[i]*j)
				q[i][1].pop_back();
			q[i][1].push_back(j);
			dp[i][j+1]=max(dp[i][j+1],
			dp[i-W-1][q[i][1].front()]+ap[i]*(q[i][1].front()-(j+1)));
		}
	}
	// for(int i=0;i<=n;i++){
		// for(int j=0;j<=maxp;j++){
			// cout<<dp[i][j]<<" ";
		// }
		// cout<<"\n";
	// }
	cout<<dp[n][0];
	return 0;
}

CF939F Cutlet

比较好的一道 DP 题。

不难发现暴力转移：设 $dp_{i,j,k}$ 是第 $i$ 个时刻最开始朝上那一面煎了 $j$ 秒，目前正在煎第 $k$ 面。当 $i\in[l_p,r_p]$ 时有转移：

\[dp_{i,j,0}=\min(dp_{i-1,j-1,0},dp_{i-1,j,1}+1)\\ dp_{i,j,1}=\min(dp_{i-1,j,1},dp_{i-1,j-1,0}+1) \]

考虑优化这个 DP。

首先，后面的 $j,k$ 可以压成只有 $j$。状态为目前朝上的一面煎了 $j$ 秒。由于 $O(nk)$ 的复杂度可过，我们就把第一个状态 $i$ 改成 $O(k)$ 级别的，于是设 $dp_{i,j}$ 为第 $i$ 个区间的右端点时朝上的一面已经煎了 $j$ 秒的最小翻转次数。

显然，一个区间有三种选择，即翻转 $0,1,2$ 次，这里分开讨论。

当翻转 $0$ 次时，正面朝上的那面被煎秒数不变，有：

\[dp_{i,j}\leftarrow dp_{i-1,j} \]

当翻转 $1$ 次时，我们把之前煎的过程抽象成先煎了 $j'$ 秒目前朝上的一面，然后一直煎现在煎的这一面，然后在当前区间转回去了。设转回去一共 $k$ 秒，那么有 $dp_{i,r_i-(j'+k)}\leftarrow dp_{i,j'}+1$，令 $j=r_i-(j'+k)$，那么有 $j'=r_i-j-k$，有如下转移：

\[dp_{i,j}\leftarrow dp_{i-1,r_i-j-k}+1(0\leq k \leq r_i-l_i) \]

当翻转 $2$ 次时，同样将之前煎的过程抽象成先煎了 $j'$ 秒目前朝上的一面，那么翻转两次等同于朝上的一面不变，那么有 $dp_{i,j'+k}\leftarrow dp_{i-1,j'}+2$。令 $j=j'+k$，那么有转移：

\[dp_{i,j}\leftarrow dp_{i-1,j-k}+2(0\leq k\leq r_i-l_i) \]

对于翻转一次时，由于 $r_i-j-k\leq r_{i-1}$，那么就有 $j+k\geq r_i-r_{i-1}$。而 $k\leq r_i-l_i$，所以有 $j\geq l_i-r_{i-1}$。然后我们就直接讨论最极端情况 $j=0$，我们发现 $r_i-j-(r_i-l_i)=l_i>r_{i-1}$，此时 $dp_{i-1,r_i-k}$ 一定是 $+\infty$。其他情况手推也可发现直接计算是对答案没有影响的。

那么直接上单调队列优化 DP 即可。

// Problem: F. Cutlet
// Contest: Codeforces - Codeforces Round 464 (Div. 2)
// URL: https://codeforces.com/problemset/problem/939/F
// Memory Limit: 256 MB
// Time Limit: 4000 ms
// Start coding at 2024-01-22 16:32:33
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int n,k;
int l,r;
int dp[101][200005];
deque<int> q;
void clear(){
	while(!q.empty())q.pop_back();
	return;
}
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n>>k;
	for(int i=1;i<=2*n;i++)dp[0][i]=1e9;
	dp[0][0]=0;
	for(int i=1;i<=k;i++){
		cin>>l>>r;
		clear();
		for(int j=0;j<=2*n;j++)dp[i][j]=dp[i-1][j];
		//change 2 times
		q.push_back(0);
		int len=r-l;
		for(int j=1;j<=r;j++){
			if(!q.empty()&&q.front()<j-len)q.pop_front();
			while(!q.empty()&&dp[i-1][q.back()]>dp[i-1][j])q.pop_back();
			q.push_back(j);
			dp[i][j]=min(dp[i][j],dp[i-1][q.front()]+2);
		}
		clear();
		//change 1 time
		for(int ri_j=0;ri_j<=r;ri_j++){
			int j=r-ri_j;
			if(!q.empty()&&q.front()<ri_j-len)q.pop_front();
			while(!q.empty()&&dp[i-1][q.back()]>dp[i-1][ri_j])q.pop_back();
			q.push_back(ri_j);
			dp[i][j]=min(dp[i][j],dp[i-1][q.front()]+1);
		}
	}
	if(dp[k][n]>=1e9)cout<<"Hungry";
	else cout<<"Full\n"<<dp[k][n];
	return 0;
}

P9871 [NOIP2023] 天天爱打卡

最近考的一道线段树优化 dp。

继承上一题的思路，我们离散化左右端点。设 $dp_{i,j}$ 时此时为第 $i$ 个状态，而前面已经连续选了 $j$ 个状态极其其中的区间了。

一个 trival 的思路是我们把每一个端点都设成状态，然后再把中间的区间设为状态。我们发现我们有 $dp_{i,j}\leftarrow dp_{i-1,j-1}-d\times len$，那么我们就可以把之前的所有状态倒置加入，省去区间平移，这样可以把这个操作转化为区间加，而对于吃饭的操作也能转化成区间加。我们每次在线段树开头加一个状态，表示此时我们只选当前状态的代价。这样每次二分出 $k$ 步之前新建的线段树节点就能维护了，加状态需要询问区间最大值。

写完之后发现 T 了，被卡常了。其实不难发现可以把中间区间的状态压掉。那么我们每次先更新 $dp_{i,0}$，再进行修改与吃饭操作即可。也可以最后更新 $dp_{i+1,0}$，这是一个道理。注意更新时要特判两状态相邻，因为这个时候更新 $dp_{i+1,0}$ 不能从 $dp_{i,0}$ 更新，而是从更前面的状态的 $dp_{i-1,0}$ 转移，否则无法满足 不能连续超过 K 次打卡。

非常难调。而且压完状态也被卡常了。

// Problem: P9871 [NOIP2023] 天天爱打卡
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P9871
// Memory Limit: 512 MB
// Time Limit: 2000 ms
// Start coding at 2024-01-22 19:21:55
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
#define LL long long
LL xds[1600001],lazy[1600001];
int ll[400001],rr[400001],v[400001];
int apos[400001],acnt;
vector<pair<int,int> > R[800001];
int n,m,k,d,qcnt;
LL dp[400001];
inline void input(){
	acnt=0;
	qcnt=0;
	cin>>n>>m>>k>>d;
	for(int i=1;i<=m;i++){
		cin>>rr[i]>>ll[i]>>v[i];
		ll[i]=rr[i]-ll[i]+1;
		apos[++acnt]=ll[i];
		apos[++acnt]=rr[i];
	}
	return;
}
void bulid(const int &now,const int &l,const int &r){
	xds[now]=lazy[now]=0;
	if(l==r)return;
	int mid=(l+r)/2;
	bulid(now<<1,l,mid);
	bulid(now<<1|1,mid+1,r);
	return;
}
inline void pushdown(const int &now,const int &l,const int &r){
	if(lazy[now]){
		lazy[now<<1]+=lazy[now];
		lazy[now<<1|1]+=lazy[now];
		xds[now<<1]+=lazy[now];
		xds[now<<1|1]+=lazy[now];
		lazy[now]=0;
	}
	return;
}
inline void pushup(const int &now){
	xds[now]=max(xds[now<<1],xds[now<<1|1]);
	return;
}
void mdf(const int &now,const int &l,const int &r,const int &sl,const int &sr,const LL &v){
	if(l==sl&&r==sr)return xds[now]+=v,lazy[now]+=v,void();
	pushdown(now,l,r);
	int mid=(l+r)/2;
	if(sl<=mid)mdf(now<<1,l,mid,sl,min(sr,mid),v);
	if(sr>mid)mdf(now<<1|1,mid+1,r,max(sl,mid+1),sr,v);
	pushup(now);
	return;
}
LL qmax(const int &now,const int &l,const int &r,const int &sl,const int &sr){
	if(l==sl&&r==sr)return xds[now];
	pushdown(now,l,r);
	int mid=(l+r)/2;
	LL res=-1e18;
	if(sl<=mid)res=max(res,qmax(now<<1,l,mid,sl,min(sr,mid)));
	if(sr>mid)res=max(res,qmax(now<<1|1,mid+1,r,max(sl,mid+1),sr));
	pushup(now);
	return res;
}
int T;
signed main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>T>>T;
	while(T--){
		input();
		sort(apos+1,apos+acnt+1);
		int atot=unique(apos+1,apos+acnt+1)-apos-1;
		// int L=1;
		// for(int i=1;i<=atot;i++){
			// if(L!=apos[i]){
				// Ql[++qcnt]=L;
				// Qr[qcnt]=apos[i]-1;
			// }
			// Ql[++qcnt]=apos[i];
			// Qr[qcnt]=apos[i];
			// L=apos[i]+1;
		// }
		// n=L;
		for(int i=1;i<=m;i++){
			ll[i]=lower_bound(apos+1,apos+atot+1,ll[i])-apos;
			rr[i]=lower_bound(apos+1,apos+atot+1,rr[i])-apos;
			R[rr[i]].push_back(make_pair(rr[i]-ll[i]+1,v[i]));
		}
		LL dp_0=0;
		bulid(1,1,atot);
		// cerr<<qcnt<<"\n";
		for(int i=1;i<=atot;i++){
			int K=i-(lower_bound(apos+1,apos+atot+1,apos[i]-k+1)-apos);
			// cerr<<apos[i]<<"\n";
			// cerr<<i<<" "<<dp_0<<" "<<K<<"\n";
			int st=atot-i+1,ed=min(st+K,atot);//,lsted=min(st+1+Kl[i-1],atot);
			// cerr<<st<<" "<<ed<<"\n";
			mdf(1,1,atot,st,st,dp_0-d);
			if(st!=ed)mdf(1,1,atot,st+1,atot,-d*(apos[i]-apos[i-1]));
			// cerr<<i<<" "<<dp_0<<" "<<K<<"\n";
			// cerr<<"end of normal modify\n";
			for(auto pv:R[i])mdf(1,1,atot,st+pv.first-1,ed,pv.second);
			R[i].clear();
			dp[i]=max(dp[i-1],qmax(1,1,atot,st,atot));
			if(apos[i]==apos[i+1]-1)dp_0=max(dp_0,dp[i-1]);
			else dp_0=max(dp_0,dp[i]);
		}
		cout<<dp_0<<"\n";
	}
	return 0;
}

决策单调性

决策单调性就是指一个最优化 DP 的最优决策点是单调递增或单调递减的。

通常使用四边形不等式证明决策单调性。

四边形不等式

定义 $\forall\ l_1\leq l_2\leq r_1\leq r_2$，则四边形不等式即为 $w(l_1,r_1)+w(l_2,r_2)\leq w(l_1,r_2)+w(l_2,r_1)$。简记为 交叉小于包含。

特别的，如果在等号时成立，那么该式子叫做四边形恒等式。

如果我们能证得 $w(l-1,r)+w(l,r+1)\leq w(l,r)+w(l-1,r+1)$，那么可以归纳证明这个关系满足四边形不等式。

并且我们定义 $\forall\ l\leq l'\leq r' \leq r$，如果有 $w(l',r')\leq w(l,r)$，则称该函数满足区间包含单调性。

由于四边形不等式是证明决策单调性的较为重要的方法，这里给出几个性质助于证明其满足四边形不等式。

性质 1

如果 $w_1(l,r)$ 和 $w_2(l,r)$ 均满足四边形不等式或区间包含单调性，那么对于任意 $c_1,c_2\geq 0$，均满足 $c_1w_1+c_2w_2$ 满足四边形不等式或区间单调包含性。

证明显然，把拼凑出来的函数的式子拆开就能发现依然满足。

性质 2

若函数满足 $w(l,r)=f(r)-g(l)$，则 $w$ 函数满足四边形恒等式；当 $f,g$ 函数还均满足单调递增时，那么 $w$ 函数还满足区间包含单调性。

证明仍然可以把上面的式子拆成 $f,g$ 做。

性质 3

若函数 $h(x)$ 是一个单调递增的凸函数，且函数 $w(l,r)$ 满足四边形不等式和区间包含单调性，那么复合函数 $h(w(l,r))$ 也满足四边形不等式和区间包含单调性。

性质 3，4 不知道怎么证，硬记吧。

性质 4

若函数 $h(x)$ 是一个凸函数，且函数 $w(l,r)$ 满足四边形不等式和区间包含单调性，那么复合函数 $h(w(l,r))$ 满足四边形不等式。

2D/1D DP 的优化

我们做区间 DP 时基本都会列出这样的式子：

\[f_{l,r}=\min_{l\leq k<r}(f_{l,k},f_{k+1,r})+w(l,r) \]

引理：若 $w(l,r)$ 满足区间包含单调性和四边形不等式，那么 $f_{l,r}$ 满足四边形不等式。

此时有定理：设 $g_{l,r}$ 为计算 $f_{l,r}$ 时的决策点，若 $w(l,r)$ 满足区间包含单调性和四边形不等式，那么一定有：

\[g_{l,r-1}\leq g_{l,r}\leq g_{l+1,r} \]

此时做这种 DP 时，我们可以枚举 $[g_{l,r-1},g_{l+1,r}]$ 这个区间来枚举决策点。

这样可以使转移时对决策点的总枚举量做到 $O(n^2)$。

例题

P1880 [NOI1995] 石子合并

这个东西之前我们的做法是 $O(n^3)$ 的，而可以通过四边形不等式决策单调性优化到 $O(n^2)$。

首先，对于最小值，我们完全可以套上面的式子。此时 $w(l,r)=pre_r-pre_{l-1}$，肯定满足区间包含单调性和四边形不等式，那么可以使用决策单调性优化。

而最大值时，可以证明此时不满足决策单调性，但是此时一定会从最左极端和最右极端两个状态转移过来。因为最大时我们要尽量让大的状态尽可能的多被加。

总时间复杂度 $O(n^2)$。

// Problem: P1880 [NOI1995] 石子合并
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P1880
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-23 19:59:54
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int a[10001],pre[10001];
int dpma[201][201],dpmi[201][201];
int g[201][201],n;
int main(){
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	cin>>n;
	for(int i=1;i<=n;i++)cin>>a[i],a[i+n]=a[i];
	n*=2;
	for(int i=1;i<=n;i++)pre[i]=a[i]+pre[i-1];
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++){
			dpmi[i][j]=1e9;
			dpma[i][j]=-1e9;
		}
	}
	for(int i=1;i<=n;i++){
		g[i][i]=i;
		dpmi[i][i]=0;
		dpma[i][i]=0;
	}
	for(int len=2;len<=n/2;len++){
		for(int l=1;l<=n-len+1;l++){
			int r=l+len-1;
			dpma[l][r]=max(dpma[l][r-1],dpma[l+1][r])+pre[r]-pre[l-1];
			for(int k=g[l][r-1];k<=g[l+1][r];k++){
				if(dpmi[l][r]>dpmi[l][k]+dpmi[k+1][r]){
					dpmi[l][r]=dpmi[l][k]+dpmi[k+1][r];
					g[l][r]=k;
				}
			}
			dpmi[l][r]+=pre[r]-pre[l-1];
		}
	}
	int minn=1e9,maxx=-1e9;
	for(int i=1;i<=n/2;i++){
		minn=min(minn,dpmi[i][i+n/2-1]);
		maxx=max(maxx,dpma[i][i+n/2-1]);
	}
	cout<<minn<<"\n"<<maxx;
	return 0;
}

为什么复杂度是 $O(n^2)$：你可以理解为对于每一个 $len$，决策点 $k$ 都只是从 $1$ 遍历到了 $n\times 2$，所以是 $O(n^2)$ 的。

HDU3480 Division

首先对集合排序。

定义 $f_{i,j}$ 为前 $i$ 个数分成 $j$ 个集合的最小代价，有：

\[f_{i,j}=\min_p(f_{i-p,j-1}+w(i-p+1,i)) \]

其中 $w(l,r)=(a_r-a_l)^2$。拆开式子其实可以发现可以斜率优化，但是决策单调性优化也是可以的。

显然 $w(l,r)$ 满足四边形不等式与区间包含单调性。

而对于 $f_{i,j}=\min_{k\leq j}(f_{i-1,k}+w(k+1,j))$ 这种转移式，它其实是一种分层的 1D/1D DP。

此时同样满足上面的引理和定理。而这道题的 $w(l,r)$ 显然满足所有条件，所以有 $g_{i-1,j}\leq g_{i,j}\leq g_{i,j+1}$，需要倒着枚举状态。可以优化到 $O(nm)$。

转移时尽量用下面的式子，转移更加方便。

// Problem: Division
// Contest: HDOJ
// URL: https://acm.hdu.edu.cn/showproblem.php?pid=3480
// Memory Limit: 999 MB
// Time Limit: 10000 ms
// Start coding at 2024-01-23 21:24:52
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
//#define int long long
int dp[10005][5005],g[10005][5005];
int a[10001];
int n,m;
int T;
int geta(int l,int r){
	return (a[r]-a[l])*(a[r]-a[l]);
}
signed main(){
	ios::sync_with_stdio(0);
	cin>>T;
	int ci=0;
	while(T--){
		cin>>n>>m;
		for(int i=1;i<=n;i++)cin>>a[i];
		sort(a+1,a+n+1);
		for(int i=1;i<=n;i++){
			dp[i][1]=geta(1,i);
			g[i][1]=1;
		}
		for(int j=2;j<=m;j++){
			dp[n+1][j]=0;
			g[n+1][j]=n;
			for(int i=n;i>=j;i--){
				dp[i][j]=1e18;
				for(int p=g[i][j-1];p<=g[i+1][j];p++){
					if(dp[i][j]>dp[p][j-1]+geta(p+1,i)){
						dp[i][j]=dp[p][j-1]+geta(p+1,i);
						g[i][j]=p;
					}
				}
			}
		}
		cout<<"Case "<<++ci<<": "<<dp[n][m]<<"\n";
	}
	return 0;
}

P4767 [IOI2000] 邮局

定义 $dp_{i,j}$ 为前 $j$ 个村庄中设 $i$ 个邮局的最小代价，列出 DP 方程式：

\[dp_{i,j}=\min_{k\leq j}(dp_{i-1,k}+w(k+1,j)) \]

其中 $w(l,r)$ 表示在 $[l,r]$ 区间内设立一个邮局所需要的最小代价，显然取中位数最优。

发现和上面可以决策单调性优化的式子一模一样。尝试证明 $w$ 函数满足四边形不等式。

首先尝试解决 $O(1)$ 计算 $w$ 函数的问题。画个图来理解一下：

手玩发现从 $w(l,r)$ 到 $w(l,r+1)$ 只是把 $\left[\left\lfloor\frac{l+r}{2}\right\rfloor,r+1\right]$ 区间内点都经过了一遍，所以有式子：

\[w(l,r+1)=w(l,r)+a_{r+1}-a_{\left\lfloor\frac{l+r}{2}\right\rfloor} \]

接下来证明 $w(l,r)$ 满足四边形不等式。

使用归纳证明：证明 $w(l,r+1)+w(l-1,r)\leq w(l-1,r+1)+w(l,r)$。

拆开式子抵消可有：$a_{\left\lfloor\frac{l+r}{2}\right\rfloor}\leq a_{\left\lfloor\frac{l+r+1}{2}\right\rfloor}$，显然可证。那么有决策单调性：$g_{i-1,j}\leq g_{i,j}\leq g_{i,j+1}$，倒序 DP 即可。

时间复杂度 $O(PV+V^2)$。

// Problem: P4767 [IOI2000] 邮局
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P4767
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// Start coding at 2024-01-24 17:07:01
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
int w[3001][3001],V,P,a[3001];
int dp[305][3005],g[305][3005];
int main(){
	ios::sync_with_stdio(0);
	cin>>V>>P;
	for(int i=1;i<=V;i++)cin>>a[i];
	for(int l=1;l<=V;l++)
		for(int r=l;r<=V;r++)
			w[l][r]=w[l][r-1]+a[r]-a[(l+r)/2];
	for(int i=1;i<=V;i++)dp[0][i]=1e9;
	for(int i=1;i<=P;i++){
		g[i][V+1]=V;
		// for(int j=0;j<=V;j++)dp[i][j]=1e9;
		for(int j=V;j>=i;j--){
			dp[i][j]=1e9;
			for(int k=g[i-1][j];k<=g[i][j+1];k++){
				if(dp[i][j]>dp[i-1][k]+w[k+1][j]){
					dp[i][j]=dp[i-1][k]+w[k+1][j];
					g[i][j]=k;
				}
			}
		}
	}
	cout<<dp[P][V];
	return 0;
}

1D/1D DP 的优化

作者终于回来学 DP 了。

形如：

\[f_i=\min_{j=1}^{i-1}(f_{j}+w(j,i)) \]

的 DP 方程式，同样与决策单调性有关。

有定理：如果 $w(l,r)$ 满足四边形不等式，记 $g_i$ 为 $f$ 函数在 $i$ 处的最小最优决策点，那么有

\[\forall r_1\geq r_2,g_{r_1}\geq g_{r_2} \]

在解决该问题之前，我们首先来解决其的弱化版：

形如：

\[f_i=\min_{j=1}^{i-1}(w(j,i)) \]

的式子。同样满足上面的定理。

发现该转移根据 最优 一说，每次要枚举 $g_{i-1}\sim i-1$ 这个区间，时间复杂度仍是 $O(n^2)$ 的。

所以我们想办法求出上界。

因为这个 $g$ 数组一定是一个不降的数组，所以我们考虑对 $g$ 数组分治求。考虑首先算出 $g_{mid}$，然后对于左右区间就有一个上界或下界了。

例题 $1$：LOJ 6039「雅礼集训 2017 Day5」珠宝 /「NAIPC2016」Jewel Thief

这是一个分层 DP，所以列出来的 DP 式子让人以为这个 DP 是上面的非弱化版，而实际上，这个 DP 是刷表，于是如果这个 DP 满足决策单调性，那么就可以直接分治。

首先把 DP 式子列出来。

首先注意到此题 $c\leq 100$，而 $n$ 远大于 $c$，于是我们设 $dp_{i,j}$ 是选过前 $i$ 种价值，背包已有容量为 $j$ 时的最大价值。有：

\[dp_{i,j}=\max_{ki\leq j}(dp_{i-1,j-ki}+w(i,k)) \]

其中 $w(i,k)$ 指在容量为 $i$ 时选 $k$ 个的最大价值，也就是从大往小选。

此时考虑将 $j-ki$ 和 $j$ 放到一个同余系下转移，即 $\bmod i$ 同余系下，有：

\[dp_{i,j}=\max_{j\ \bmod \ i\ =\ k\ \bmod\ i}(dp_{i-1,k}+w'_i(k,j)) \]

其中 $w'_i(k,j)=w(i,\frac{k-j}{i})$。显然满足四边形不等式。

把 $i$ 滚掉，我们就把方程式化成了：

\[dp_{j}=\max_{k<j}(dp_k+w'(k,j)) \]

而这是一个刷表，所以在计算时，我们是知道了上一维的 $dp$ 数组的，也就是说，这里的每一个 $dp$ 数组都是可以直接算出来而不需要之前当前维的 $dp$ 方程组，所以可以直接分治。时间复杂度 $O(ck\log k)$。而对于 $\max$ 类问题，我们可以直接将所有数取反就能得到关于 $\min$ 的式子，两者其实是一样的。

注意这个式子满足决策单调性的前提是在同余系下，所以对于不同同余系我们分开分治。具体就是将一个同余系里的所有元素提出来分治，最后再赋值回去。

xingyuxuan

DP - 补

简介

背包

01 背包

完全背包

多重背包

二维费用背包

分组背包

例题

P4141 消失之物

LOJ 6089

P8392 物品

区间 dp

简介

例题

P1880 石子合并

P5336 成绩单

AGC035D Add and Remove

树形 dp

简介

数位 dp

简介

例题

P2657 windy 数

P4999 烦人的数学作业

P2602 数字计数

UOJ140【UER #4】被粉碎的数字

状压 dp

简介

例题

P1879 Corn Fields

P3204 [HNOI2010] 公交线路

DP 的优化

数据结构优化 DP

单调队列优化 DP

Slope Trick

其他数据结构优化 DP

例题

决策单调性

四边形不等式

2D/1D DP 的优化

例题

1D/1D DP 的优化

例题

另类优化

对于分治的优化

例题

斜率优化

李超线段树

例题

分治

类型一：删去一个点后的贡献（互相独立）

类型二：跨越 mid 的转移（非偏序题）

类型三：偏序类问题

类型四：数点

WQS 二分

矩阵加速

朴素

广义矩阵乘法

baka's trick

拓展

动态 DP

动态最大权独立集

动态防洪

容斥优化 DP

SOS DP

缩点 DP

后记

公告