线性dp与背包dp

01背包

问题描述：

给定 $N$ 个物品，其中第 $i$ 个物品的重量为 $w_i$，价值为 $v_i$。有一容积为 $M$ 的背包，要求选择一些物品存入背包，使得物品的总重量不超过 $M$ 的前提下，物品的价值总和最大。

设 $dp[i][j]$ 表示，使用前 $i$ 个物品，当背包重量为 $j$ 时，装入价值的最大值。

考虑第 $i$ 个物品有拿与不拿两种选择，若拿，则 $dp[i][j]=dp[i-1][j-w_i]+v_i$；若不拿，则 $dp[i][j]=dp[i-1][j]$。

所以：
$$dp[i][j]=\{\begin{array}{l}dp[i-1][j]\\ dp[i-1][j-w_i]+v_i\end{array}$$

代码

for(int i=1;i<=n;i++){
	for(int j=0;j<=m;j++)
		f[i][j]=f[i-1][j];
	for(int j=w[i];j<=m;j++)
		f[i][j]=max(f[i][j],f[i-1][j-w[i]]+v[i]);
}

滚动数组优化空间

for(int i=1;i<=n;i++){
	for(int j=0;j<=m;j++)
		f[i&1][j]=f[(i-1)&1][j];
	for(int j=w[i];j<=m;j++)
		f[i&1][j]=max(f[i&1][j],f[(i-1)&1][j-w[i]]+v[i]);
}

倒序循环

直接将空间压缩成一维，如果继续使用正序循环，那么一个物品可能重复装入背包多次。

当有一个物品的重量为3，正序循环时，更新情况如下：

使用了一个已更新的状态来更新当前状态，也即是说，重复使用了第 $i$ 个物品两次。

倒序循环永远使用未更新之前的数据来更新当前结点，也即是说，每个物品只会使用一次。

完全背包

给定 $N$ 个物品，其中第 $i$ 种物品的重量为 $w_i$，价值为 $v_i$，并且有无数个。有一容积为 $M$ 的背包，要求选择一些物品存入背包，使得物品的总重量不超过 $M$ 的前提下，物品的价值总和最大。

多重背包

给定 $N$ 种物品，其中第 $i$ 种物品的重量为 $w_i$，价值为 $v_i$，并且有 $c_i$ 个。有一容积为 $M$ 的背包，要求选择一些物品存入背包，使得物品的总重量不超过 $M$ 的前提下，物品的价值总和最大。

直接拆分法

$01$ 背包的复杂度为$O(MN)$；

多重背包的复杂度为 $O(M\times {\sum }_{i=1}^N{C}_i)$

把每种物品拆分为 $C_i$ 个，效率较低。

二进制拆分法

设 $2^0+2^1+\dots +2^p\le C_i$，$R_i=C_i-(2^{p+1}-1)$。

可以把 $C_i$ 拆为 $2^0$、$2^1$、…… 、$2^p$ 、$R_i$。

$2^0$、$2^1$、…… 、$2^p$ 、$R_i$ 可以组成 $0$ ~ $C_i$ 之间的任意整数。

把每种物品拆分为 $log{C}_i$ 个，效率较高。

使用单调队列优化的动态规划算法可以进一步降低时间复杂度。

【例题】Coins

链接

简化题意：

有 $N$ 种硬币，第 $i$ 种面值为 $A_i$，有 $C_i$ 个。求 $1$ ~ $M$ 之间可以被拼成的面值数量。
$1\le N\le 100$ ， $1\le M\le 10^5$ ， $1\le A_i\le 10^5$ ， $1\le C_i\le 1000$ 。

#include<bits/stdc++.h>
using namespace std;
int n,m,v[110],dp[100010],b[110];
vector<int> c[110];

void solve(int n,int m){
	for(int i=0;i<110;i++) c[i].clear();
	memset(dp,0,sizeof(dp)); dp[0]=1;
	for(int i=1;i<=n;i++) cin>>v[i];	
	for(int i=1;i<=n;i++) cin>>b[i];	
	for(int i=1;i<=n;i++){
		int bit=2;
		while(bit-1<=b[i]){
			c[i].push_back(bit>>1);	
			bit<<=1;
		}
		bit=(bit-1)>>1;
		if(b[i]>bit) c[i].push_back(b[i]-bit);
	}
	for(int i=1;i<=n;i++){
		for(int j=0;j<(int)c[i].size();j++){
			int y=v[i]*c[i][j];
			for(int k=m;k>=y;k--)
				dp[k]|=dp[k-y];
		}
	}
	int ans=0;	
	for(int i=1;i<=m;i++) if(dp[i]) ans++;
	cout<<ans<<"\n";
}

int main(){
	ios::sync_with_stdio(false);
	while(cin>>n>>m,n!=0&&m!=0) solve(n,m);
}

分组背包

给定 $N$ 组物品，其中第 $i$ 组有 $C_i$ 个物品。第 $i$ 组的第 $j$ 个物品的重量为 $w_{ij}$，价值为 $v_{ij}$ 。有一容积为 $M$ 的背包，要求选择一些物品存入背包，使得每组最多选择一个并且物品，且总重量不超过 $M$ 的前提下，物品的价值总和最大。

【例题】NIH Budget

链接

简化题意：

给出 $n$ 个疾病治疗方案，每个方案有四个阶段：投入资金 $a_i$，挽救生命 $b_i$。求拥有研发资金m时，最优的分配策略下可以挽救的生命数量。

思路：

可以将 $n$ 种治疗方案看作是 $n$ 种物品，每种方案中的四个阶段看作是同一类背包中的四个物品，题意恰好有 “每组最多选择一个物品” 这个要求，那么原题就转换为分组背包问题。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int T,n,m,ca,dp[N],w[12][5],v[12][5];

void solve(){
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=4;j++)
			cin>>w[i][j]>>v[i][j];
	for(int i=1;i<=n;i++)
		for(int j=m;j>=0;j--)
			for(int k=1;k<=4;k++)
				if(j-w[i][k]>=0)
					dp[j]=max(dp[j],dp[j-w[i][k]]+v[i][k]);
	cout<<"Budget #"<<++ca<<": Maximum of "<<dp[m]<<" lives saved.\n";
	for(int i=0;i<=m;i++) dp[i]=0;
}

int main(){
	ios::sync_with_stdio(false);
	for(cin>>T;T;T--) solve();
}

【例题】Jury Compromise

链接

简化题意：

给出 $n$ 个物品，每个物品有两个属性 $a[i]、b[i]$（$0\le a[i],b[i]\le 20$）。从中选出 $m$ 个物品，使得 $\sum |a[i]-b[i]|$ 最小，若方案不唯一，再从中选择 $\sum a[i]+b[i]$ 最大的方案。( $1\le n\le 200$ , $1\le m\le 20$ )

思路：

$dp[i][j][k]$ 表示前 $i$ 个物品，已经选择了 $j$ 个，当 $\sum |a[i]-b[i]|$ 为 $k$ 时，$\sum a[i]+b[i]$ 的最大值。

$d_i$ 为 $a[i]-b[i]$，$s_i$ 为 $a[i]+b[i]$。

若没有选择第 $i$ 个物品，那么 $dp[i][j][k]=dp[i-1][j][k]$。
若选择第 $i$ 个物品，那么 $dp[i-1][j-1][k-d[i]]+s[i]$

状态转移方程：
$$dp[i][j][k]=max\{\begin{array}{l}dp[i-1][j][k]\\ dp[i-1][j-1][k-d_i]+s_i\end{array}$$

初始化 $dp[0][0][0]=0$ ，其余为负无穷。

目标为 $dp[n][m][k]$ ，$k$ 尽量小。

#include<bits/stdc++.h>
#define H(x) ((x)+N)
using namespace std;
const int N=450;
int n,m,dp[22][2*N],a[210],b[210],ca,sel[22],D[22][2*N];
int ver[500000],Next[500000],tot;

void dfs(int x,int y){
	if(y==0||x==0) return;
	sel[x]=ver[y];
	dfs(x-1,Next[y]);
}

void solve(int n,int m){
	memset(dp,0xcf,sizeof(dp)); dp[0][H(0)]=0;
	memset(D,0,sizeof(D)); tot=0;
	memset(sel,0,sizeof(sel));
	for(int i=1;i<=n;i++) cin>>b[i]>>a[i];
	for(int i=1;i<=n;i++)
		for(int j=m;j>=1;j--)
			for(int k=-N;k<=N;k++)
				if(H(k-(a[i]-b[i]))>=0&&dp[j-1][H(k-(a[i]-b[i]))]>=0)
					if(dp[j-1][H(k-(a[i]-b[i]))]+a[i]+b[i]>dp[j][H(k)]){
						dp[j][H(k)]=dp[j-1][H(k-(a[i]-b[i]))]+a[i]+b[i];
						ver[++tot]=i,Next[tot]=D[j-1][H(k-(a[i]-b[i]))],D[j][H(k)]=tot;
					}
	for(int i=0;i<=N;i++){
		if(dp[m][N+i]>=0&&dp[m][N+i]>=dp[m][N-i]){ dfs(m,D[m][N+i]); break; }
		if(dp[m][N-i]>=0&&dp[m][N-i]>=dp[m][N+i]){ dfs(m,D[m][N-i]); break; }
	}
	int retA=0,retB=0;
	for(int i=1;i<=m;i++) retA+=a[sel[i]],retB+=b[sel[i]];
	cout<<"Jury #"<<++ca<<"\n";
	cout<<"Best jury has value "<<retB<<" for prosecution and value "<<retA<<" for defence:"<<"\n";
	sort(sel+1,sel+m+1);
	for(int i=1;i<=m;i++) cout<<" "<<sel[i];
	cout<<"\n\n";
}

int main(){
	ios::sync_with_stdio(false);
	while(cin>>n>>m,n!=0&&m!=0) solve(n,m);
}

线性dp

【例题】Armchairs

链接

简化题意：

给出一个长度为 $n$ 的 $01$ 序列，代表有 $n$ 个位置，每个位置上的数字若为 $1$ ，则该位置上有人；若为 $0$ ，则该位置空闲。
将一个人从座位 $i$ 移动到座位 $j$ 的花费为 $|i-j|$ ，求一个最小花费，使得最初有人的位置都变得空闲。保证存在这样的移动方案。$(2\le n\le 5000)$

一个性质：
若有 $x$ 个人，移动到 $x$ 个位置上（起点、终点都已知），那么最优的移动策略为，将人与座位从左到右排序，第 $i$ 个人移动到第 $i$ 个位置上。

设前 $i$ 个人，可以移动到前 $j$ 个位置($i\le j$)，最优解为 $dp[i][j]$，那么
$$dp[i][j]=min\{\begin{array}{lr}dp[i][j-1]& (不占用第j个0的位置)\\ dp[i-1][j-1]+abs(ful[i]-emp[j])& (第i个1占用第j个0的位置)\end{array}$$

#include<bits/stdc++.h>
using namespace std;
const int N=5010;
int n,a[N],emp[N],ful[N],t1,t2,dp[N][N];

int main(){
	ios::sync_with_stdio(false);
	cin>>n;
	for(int i=1;i<=n;i++) cin>>a[i];
	for(int i=1;i<=n;i++) if(a[i]) ful[++t1]=i;
	for(int i=1;i<=n;i++) if(!a[i]) emp[++t2]=i;
	for(int i=1;i<=n;i++) dp[i][i]=dp[i-1][i-1]+abs(emp[i]-ful[i]);
	for(int i=1;i<=t1;i++)
		for(int j=i+1;j<=t2;j++)
			dp[i][j]=min(dp[i][j-1],dp[i-1][j-1]+abs(emp[j]-ful[i]));
	cout<<dp[t1][t2]<<"\n";
}

【例题】匹配正则表达式

链接

【例题】Mobile Service

链接

简化题意：

有三个服务员，最初的位置在 $1$， $2$ ，$3$ 处。

有一个长度为 $n$ 的请求序列，要求派遣员工去位置 $a[i]$，从位置 $i$ 到 $j$ 的花费为 $c(i,j)$。花费函数 $c(i,j)$ 不一定对称，不过保证 $c(i,i)=0$。

要求移动员工，按照顺序依次满足所有请求，并且计算最小花费。
同一时间同一个位置只能有一个员工。

$N\le 1000$ , 位置为 $1$ ~ $200$ 之间的整数。

思路：

首先构造一个状态的表示方法：

设 $dp[i][x][y][z]$ 表示，满足前 $i$ 个要求，三个员工的位置分别在 $x$ , $y$ , $z$ 的最小花费。

$dp[i][x][y][z]$ 可以更新 $dp[i+1][][][]$ 的三个状态：

• 派 $x$ 位置的人去 $p_{i+1}$ 位置
  $$dp[i+1][p_{i+1}][y][z]=min(dp[i+1][p_{i+1}][y][z],dp[i][x][y][z]+c(x,p_{i+1}))$$

• 派 $y$ 位置的人去 $p_{i+1}$ 位置
  $$dp[i+1][x][p_{i+1}][z]=min(dp[i+1][x][p_{i+1}][z],dp[i][x][y][z]+c(y,p_{i+1}))$$

• 派 $z$ 位置的人去 $p_{i+1}$ 位置
  $$dp[i+1][x][y][p_{i+1}]=min(dp[i+1][x][y][p_{i+1}],dp[i][x][y][z]+c(z,p_{i+1}))$$

这个方法的规模为 $1000\times 200^3$ ，会超时。

其实上面这种表示状态的方法存在着冗余，当满足了前 $i$ 个请求的时候，必定有一个人当前位置在 $p_i$ 。只需要再知道其他两个人的位置，就能描述当前的状态。所以设 $dp[i][x][y]$ 表示，满足了前 $i$ 个请求，现在一个人的位置在 $p_i$ ，另外两个人的位置在 $x$ 与 $y$ 的状态下，花费的最小值。

那么 $dp[i][x][y]$ 也能更新三个状态：

• 派 $p_i$ 位置的人去 $p_{i+1}$ 位置
  $$dp[i+1][x][y]=min(dp[i+1][x][y],dp[i][x][y]+c(p_i,p_{i+1}))$$

• 派 $x$ 位置的人去 $p_{i+1}$ 位置
  $$dp[i+1][p_i][y]=min(dp[i+1][p_i][y],dp[i][x][y]+c(x,pi+1))$$

• 派 $y$ 位置的人去 $p_{i+1}$ 位置
  $$dp[i+1][p_i][x]=min(dp[i+1][p_i][x],dp[i][x][y]+c(y,pi+1))$$

现在，这个算法的规模变为 $1000\times 200^2$。

#include<bits/stdc++.h>
using namespace std;
const int N=210;
int T,n,m,c[N][N],dp[2][N][N],p[1010],ans=0x3f3f3f3f;

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			cin>>c[i][j];
	for(int i=1;i<=m;i++) cin>>p[i];
	p[0]=3;
	memset(dp,0x3f,sizeof(dp));
	dp[0][1][2]=dp[0][2][1]=0;
	for(int i=1;i<=m;i++){
		for(int j=0;j<=n;j++)
			for(int k=0;k<=n;k++)
				dp[i&1][j][k]=(int)1e8;
		for(int x=1;x<=n;x++){
			for(int y=1;y<=n;y++){
				if(x==y||x==p[i-1]||y==p[i-1]) continue;
				if(x!=p[i]&&y!=p[i]) dp[i&1][x][y]=min(dp[i&1][x][y],dp[(i-1)&1][x][y]+c[p[i-1]][p[i]]);
				if(y!=p[i]&&p[i]!=p[i-1]) dp[i&1][p[i-1]][y]=min(dp[i&1][p[i-1]][y],dp[(i-1)&1][x][y]+c[x][p[i]]);
				if(x!=p[i]&&p[i]!=p[i-1]) dp[i&1][x][p[i-1]]=min(dp[i&1][x][p[i-1]],dp[(i-1)&1][x][y]+c[y][p[i]]);
			}
		}
	}
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
			ans=min(ans,dp[m&1][i][j]);
	cout<<ans<<"\n";
}