背包九讲

前言

都说动态规划是$OIer$神犇与蒟蒻的分水岭，而背包问题又是动态规划中的基础，此篇博客的创作目的就是为了方便和我一样蒟蒻的$OIer$或$ACMer$学习动态规划，还望大佬路过如果看到有什么错误及时指正。
另外，此篇博客正文大抵来源于崔添翼大神（Tianyi Cui）发布在github上的作品——《背包问题九讲》点击下载PDF版，在此基础上加上我的个人整理总结和每种类型的例题以及亲自手打AC的C++代码。
写作这篇博客耗时将近一周，期间也有几天因为上课被搁置了，但在总结与亲自做题的过程中，我感觉自己确实学到了很多东西，以前在做动态规划的问题时，总以玄学的态度去看待，但是如果真正理解了各种递推式的来龙去脉和其中的奥妙，我会不由惊叹：动态规划真的就是算法中的一门艺术。

一.01背包

题目描述
有$N$件物品和一个容量为$W$的背包。第$i$件物品的费用是$w[i]$，价值是$v[i]$，求将哪些物品装入背包可使价值总和最大。
基本思路
这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。
用子问题定义状态：即$f[i][j]$表示前$i$件物品恰放入一个容量为$j$的背包可以获得的最大价值。则其状态转移方程便是：
$$f[i][j]=max(f[i-1][j],f[i-1][j-w[i]]+v[i])$$
这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来的。所以有必要将它详细解释一下：“将前$i$件物品放入容量为$j$的背包中”这个子问题，若只考虑第$i$件物品的策略（放或不放），那么就可以转化为一个只牵扯前$i-1$件物品的问题。如果不放第$i$件物品，那么问题就转化为“前$i-1$件物品放入容量为$j$的背包中”，价值为$f[i-1][j]$；如果放第$i$件物品，那么问题就转化为“前$i-1$件物品放入剩下的容量为$j-w[i]$的背包中”，此时能获得的最大价值就是$f[i-1][j-w[i]]$再加上通过放入第$i$件物品获得的价值$v[i]$。
优化空间复杂度
以上方法的时间和空间复杂度均为$O(WN)$，其中时间复杂度已经不能再优化了，但空间复杂度却可以优化到$O(N)$。
先上代码：

​for (int i = 1; i <= N; i++)
    for (int j = W; j >= w[i]; j--)
        f[j] = max(f[j], f[j - w[i]] + v[i]);

其中的$f[j]=max(f[j],f[j-w[i]])$一句恰就相当于我们的转移方程$f[i][j]=max(f[i-1][j],f[i-1][j-w[i]])$，因为现在的$f[j-w[i]]$就相当于原来的$f[i-1][j-w[i]]$。如果将$W$的循环顺序从上面的逆序改成顺序的话，那么则成了$f[i][j]$由$f[i][j-w[i]]$推知，与本题意不符，但它却是另一个重要的背包问题（完全背包）最简捷的解决方案，故学习只用一维数组解01背包问题是十分必要的。
初始化的细节问题
我们看到的求最优解的背包问题题目中，事实上有两种不太相同的问法。有的题目要求"恰好装满背包"时的最优解，有的题目则并没有要求必须把背包装满。这两种问法的区别是在初始化的时候有所不同。
如果是第一种问法，要求恰好装满背包，那么在初始化时除了$f[0]$为$0$其它$f[1...W]$均设为$-\infty$，这样就可以保证最终得到的$f[N]$是一种恰好装满背包的最优解。
如果并没有要求必须把背包装满，而是只希望价格尽量大，初始化时应该将$f[0...W]$全部设为$0$。
为什么呢？可以这样理解：初始化的$f$数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满，那么此时只有容量为$0$的背包可能被价值为$0$的$nothing$“恰好装满”，其它容量的背包均没有合法的解，属于未定义的状态，它们的值就都应该是$-\infty$了。如果背包并非必须被装满，那么任何容量的背包都有一个合法解“什么都不装”，这个解的价值为$0$，所以初始时状态的值也就全部为$0$了。这个小技巧完全可以推广到其它类型的背包问题，后面也就不再对进行状态转移之前的初始化进行讲解。
01背包的应用

• 采药
  基本思路：典型的01背包问题，求在规定时间内采到药的最大价值
  c++参考代码（附上压缩空间前与后的代码）

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e3+7;
ll f[maxn],v[maxn],w[maxn],dp[maxn][maxn];
int n,m;

int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>v[i]>>w[i];
	}
	//空间压缩前
	for(int i=1;i<=m;i++)
	for(int j=0;j<=n;j++)
    if(j>=v[i])
	dp[i][j]=max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
    else dp[i][j]=dp[i-1][j];
    //空间压缩后
	for(int i=0;i<m;i++)
	for(int j=n;j>=v[i];j--)
	f[j]=max(f[j],f[j-v[i]]+w[i]);
	cout<<dp[m][n];
	//cout<<f[n];
	return 0;
}

二.完全背包

题目描述
有$N$种物品和一个容量为$W$的背包，每种物品都有无限件可用。第$i$种物品的费用是$w[i]$，价值是$v[i]$。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
基本思路
这个问题非常类似于01背包问题，所不同的是每种物品有无限件。也就是从每种物品的角度考虑，与它相关的策略已并非取或不取两种，而是有取0件、取1件、取2件……等很多种。如果仍然按照解01背包时的思路，令$f[i][j]$表示前$i$种物品恰放入一个容量为$W$的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程，像这样：
$$f[i][j]=max(f[i-1][j-k\ast w[i]]+k\ast v[i])\mid 0<=k\ast w[i]<=j$$
这跟01背包问题一样有$O(WN)$个状态需要求解，但求解每个状态的时间已经不是常数了，求解状态$f[i][j]$的时间是$O(W/w[i])$，总的复杂度可以认为是$O(N\ast \Sigma (W/w[i]))$，是比较大的。将01背包问题的基本思路加以改进，得到了这样一个清晰的方法。这说明01背包问题的方程的确是很重要，可以推及其它类型的背包问题。但我们还是试图改进这个复杂度。
$O(WN)$的算法
这个算法使用一维数组，先看代码：

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

细心的读者会发现，这个代码与01背包的代码只有$j$的循环次序不同而已。为什么这样一改就可行呢？首先想想为什么01背包中要按照$j=V...0$的逆序来循环。这是因为要保证第$i$次循环中的状态$f[i][j]$]是由状态$f[i-1][j-w[i]]$递推而来。换句话说，这正是为了保证每件物品只选一次，保证在考虑“选入第$i$件物品”这件策略时，依据的是一个绝无已经选入第$i$件物品的子结果$f[i-1][j-w[i]]$。而现在完全背包的特点恰是每种物品可选无限件，所以在考虑“加选一件第$i$种物品”这种策略时，却正需要一个可能已选入第$i$种物品的子结果$f[i][j-w[i]]$，所以就可以并且必须采用$j=0...V$的顺序循环。这就是这个简单的程序为何成立的道理。值得一提的是，上面的伪代码中两层$for$循环的次序可以颠倒。这个结论有可能会带来算法时间常数上的优化。
这个算法也可以以另外的思路得出。例如，将基本思路中求解$f[i][j-w[i]]$的状态转移方程显式地写出来，代入原方程中，会发现该方程可以等价地变形成这种形式：
$$f[i][j]=max(f[i-1][j],f[i][j-w[i]]+v[i])$$
将这个方程用一维数组实现，便得到了上面的代码。
完全背包的应用

• 疯狂的采药
  基本思路：和采药那道题不同的是，这道题里每种草药可以疯狂无限制地采摘，属于完全背包的问题。
  c++参考代码

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e5+7;
ll f[maxn],v[maxn],w[maxn];
int n,m;

int main(){
	cin>>n>>m;
	for(int i=0;i<m;i++){
		cin>>v[i]>>w[i];
	}
	for(int i=0;i<m;i++)
	for(int j=v[i];j<=n;j++)
	f[j]=max(f[j],f[j-v[i]]+w[i]);
	cout<<f[n];
	return 0;
}

三.多重背包

题目描述
有$N$种物品和一个容量为$W$的背包。第$i$种物品最多有$p[i]$件可用，每件费用是$w[i]$，价值是$v[i]$。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
基本思路
这题目和完全背包问题很类似。基本的方程只需将完全背包问题的方程略微一改即可，因为对于第$i$种物品有$p[i]+1$种策略：取0件，取1件……取$p[i]$件。令$f[i][j]$表示前$i$种物品恰放入一个容量为$j$的背包的最大权值，则有状态转移方程：
$$f[i][j]=max(f[i-1][j-k\ast w[i]]+k\ast v[i])\mid 0<=k<=p[i]$$
复杂度是$O(W\ast \Sigma p[i])$。
转换为01背包问题
另一种好想好写的基本方法是转化为01背包求解：把第$i$种物品换成$p[i]$件01背包中的物品，则得到了物品数为$\Sigma p[i]$的01背包问题，直接求解，复杂度仍然是$O(W\ast \Sigma p[i])$。但是我们期望将它转化为01背包问题之后能够像完全背包一样降低复杂度。考虑二进制的思想，我们考虑把第$i$种物品换成若干件物品，使得原问题中第$i$种物品可取的每种策略——取$0...p[i]$件——均能等价于取若干件代换以后的物品。另外，取超过$p[i]$件的策略必不能出现。
方法是：将第$i$种物品分成若干件物品，其中每件物品有一个系数，这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为$1,2,4,...,2^{k-1},p[i]-2^k+1$，且$k$是满足$p[i]-2^k+1>0$的最大整数。例如，如果$p[i]$为$13$，就将这种物品分成系数分别为$1,2,4,6$的四件物品。分成的这几件物品的系数和为$p[i]$，表明不可能取多于$p[i]$件的第$i$种物品。另外这种方法也能保证对于$0...p[i]$间的每一个整数，均可以用若干个系数的和表示，这个证明可以分$0...2^{k-1}$和$2^k...p[i]$两段来分别讨论得出，并不难，希望你自己思考尝试一下。这样就将第$i$种物品分成了$O(log(p[i]))$种物品，将原问题转化为了复杂度为$O(W\ast \Sigma log(p[i]))$的01背包问题，是很大的改进。二进制拆分代码如下：

for (int i = 1; i <= n; i++) {
    int num = min(p[i], V / w[i]);
    for (int k = 1; num > 0; k <<= 1) {
        if (k > num) k = num;
        num -= k;
        for (int j = V; j >= w[i] * k; j--)
            f[j] = max(f[j], f[j - w[i] * k] + v[i] * k);
    }
}

多重背包的应用

• 宝物筛选
  基本思路：裸的多重背包
  c++参考代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+7;
int n,m,v[maxn],w[maxn],p[maxn],f[maxn];

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>v[i]>>w[i]>>p[i];
		int num=min(p[i],m/w[i]);
		for(int k=1;num;k<<=1){
			if(k>num) k=num;
			num-=k;
			for(int j=m;j>=w[i]*k;j--){
				f[j]=max(f[j],f[j-k*w[i]]+k*v[i]);
			}
		} 
	}
	cout<<f[m]; 
	return 0;
}

四.混合背包

问题描述
如果将前面三个背包混合起来，也就是说，有的物品只可以取一次（01背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包），应该怎么求解呢？
基本思路
考虑到在01背包和完全背包中给出的伪代码只有一处不同，故如果只有两类物品：一类物品只能取一次，另一类物品可以取无限次，那么只需在对每个物品应用转移方程时，根据物品的类别选用顺序或逆序的循环即可，复杂度是$O(WN)$。如果再加上有的物品最多可以取有限次，用多重背包中将每个这类物品分成$O(log(p[i]))$个01背包的物品就可以了。当然，更清晰的写法是调用我们前面给出的三个相关过程。代码：

p[i]:每个物品的件数，0代表无穷个
for (int i = 1; i <= n; i++)
    if (p[i] == 0)
        for (int j = w[i]; j <= V; j++)
            f[j] = max(f[j], f[j - w[i]] + v[i]);
    else
    for (int k = 1; k <= p[i]; k++)
        for (int j = V; j >= w[i]; j--)
            f[j] = max(f[j], f[j - w[i]] + v[i]);

混合背包的应用

• 樱花
  基本思路：此题糅合了前面三种类型的背包，分类讨论即可
  c++参考代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+7;
int m,a,b,c,d,n,w[maxn],v[maxn],p[maxn],f[maxn];

int main(){
	scanf("%d:%d%d:%d%d",&a,&b,&c,&d,&n);
	m=(c-a)*60+d-b;
	for(int i=1;i<=n;i++){
		cin>>w[i]>>v[i]>>p[i];
		if(p[i]==0){
			for(int j=w[i];j<=m;j++){
				f[j]=max(f[j],f[j-w[i]]+v[i]); 
			}
		}
		else{
			int num=min(p[i],m/w[i]);
			for(int k=1;num;k<<=1){
				if(k>num) k=num;
				num-=k;
				for(int j=m;j>=w[i]*k;j--){
					f[j]=max(f[j],f[j-w[i]*k]+v[i]*k);
				}
			}
		} 
	}
	cout<<f[m];
	return 0;
}

五.二维费用背包

题目描述
二维费用的背包问题是指：对于每件物品，具有两种不同的费用；选择这件物品必须同时付出这两种代价；对于每种代价都有一个可付出的最大值（背包容量）。问怎样选择物品可以得到最大的价值。设这两种代价分别为代价$1$和代价$2$，第$i$件物品所需的两种代价分别为$w[i]$和$g[i]$。两种代价可付出的最大值（两种背包容量）分别为$V$和$T$。物品的价值为$v[i]$。
基本思路
费用加了一维，只需状态也加一维即可。设$f[i][j][k]$表示前$i$件物品付出两种代价分别为$j$和$k$时可获得的最大价值。状态转移方程就是：
$$f[i][j][k]=max(f[i-1][j][k],f[i-1][j-w[i]][k-g[i]]+v[i])$$
如前述方法，可以只使用二维的数组：当每件物品只可以取一次时变量$j$和$k$采用逆序的循环，当物品有如完全背包问题时采用顺序的循环。当物品有如多重背包问题时拆分物品。代码：

for (int i = 1; i <= n; i++)
    for (int j = V; j >= w[i]; j--)
        for (int k = T; k >= g[i]; k--)
            f[j][k] = max(f[j][k], f[j - w[i]][k - g[i]] + v[i]);

二维费用背包问题的应用

• NASA的食物计划
  基本思路：二维费用01背包问题，开个二维数组逆序循环就可以了。
  c++参考代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=500;
int n,V,W,v[maxn],w[maxn],c[maxn],f[maxn][maxn];

int main(){
	cin>>V>>W>>n;
	for(int i=1;i<=n;i++){
		cin>>v[i]>>w[i]>>c[i];
		for(int j=V;j>=v[i];j--){
			for(int k=W;k>=w[i];k--){
				f[j][k]=max(f[j][k],f[j-v[i]][k-w[i]]+c[i]);
			}
		}
	}
	cout<<f[V][W];
	return 0;
}

六.分组背包

问题描述
有$N$件物品和一个容量为$W$的背包。第$i$件物品的费用是$w[i]$，价值是$v[i]$。这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
基本思路
这个问题变成了每组物品有若干种策略：是选择本组的某一件，还是一件都不选。也就是说设$f[k][j]$表示前$k$组物品花费费用$j$能取得的最大权值，则有：
$$f[k][j]=max(f[k-1][j],f[k-1][j-w[i]]+v[i]\mid 物品i属于组k)$$
伪代码如下：

for (所有的组k)
    for (int j = V; j >= 0; j--)
        for (所有属于组k的i)
            f[j] = max{f[j], f[j - w[i]] + v[i]}

注意这里的三层循环的顺序，$for(j...0)$这一层循环必须在$for(所有的i属于组k)$之外。这样才能保证每一组内的物品最多只有一个会被添加到背包中。
分组背包的应用

• 通天之分组背包
  基本思路：分组背包题，开一个数组记录每个物品的组号，再套用01背包模板即可。
  c++参考代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=1010;
int m,n,num,w[maxn],v[maxn],p[maxn],c[maxn][maxn],cc[maxn],f[maxn];

int main(){
	cin>>m>>n;
	for(int i=1;i<=n;i++){
		cin>>w[i]>>v[i]>>p[i];
		num=max(num,p[i]);
		c[p[i]][++cc[p[i]]]=i;
	}
	for(int i=1;i<=num;i++){
		for(int j=m;j>=0;j--){
			for(int k=1;k<=cc[i];k++){
				if(j>=w[c[i][k]])
				f[j]=max(f[j],f[j-w[c[i][k]]]+v[c[i][k]]);
			}
		}
	}
	cout<<f[m];
	return 0;
}

七.有依赖背包

问题描述
这种背包问题的物品间存在某种“依赖”的关系。也就是说，$i$依赖于$j$，表示若选物品$i$，则必须选物品$j$。为了简化起见，我们先设没有某个物品既依赖于别的物品，又被别的物品所依赖；另外，没有某件物品同时依赖多件物品。
基本思路
这个问题由$NOIP2006$金明的预算方案一题扩展而来。遵从该题的提法，将不依赖于别的物品的物品称为“主件”，依赖于某主件的物品称为“附件”。由这个问题的简化条件可知所有的物品由若干主件和依赖于每个主件的一个附件集合组成。
按照背包问题的一般思路，仅考虑一个主件和它的附件集合。可是，可用的策略非常多，包括：一个也不选，仅选择主件，选择主件后再选择一个附件，选择主件后再选择两个附件…无法用状态转移方程来表示如此多的策略。（事实上，设有$n$个附件，则策略有$2^{n+1}$个，为指数级。）
考虑到所有这些策略都是互斥的（也就是说，你只能选择一种策略），所以一个主件和它的附件集合实际上对应于分组背包中的一个物品组，每个选择了主件又选择了若干个附件的策略对应于这个物品组中的一个物品，其费用和价值都是这个策略中的物品的值的和。但仅仅是这一步转化并不能给出一个好的算法，因为物品组中的物品还是像原问题的策略一样多。
一个简单有效的优化就是，对于一个物品组中的物品，所有费用相同的物品只留一个价值最大的，不影响结果。
所以，我们可以对主件i的“附件集合”先进行一次01背包，得到费用依次为$0...V-c[i]$所有这些值时相应的最大价值$f\prime [0...V-c[i]]$。那么这个主件及它的附件集合相当于$V-c[i]+1$个物品的物品组，其中费用为$c[i]+k$的物品的价值为$f\prime [k]+w[i]$。也就是说原来指数级的策略中有很多策略都是冗余的，通过一次01背包后，将主件$i$转化为$V-c[i]+1$个物品的物品组，就可以直接应用分组背包的算法解决问题了。
依赖背包的应用

• 金明的预算方案
  基本思路：本题属于非树形有依赖的背包问题（只有两类物品：主件，附件）。首先我们注意到对于每一个主件，有很多种购买的方案：可以不买，可以只买主件，或者买主件外加几种附件，当附件个数较少的时候枚举就可以 $AC$。但我们正解的话，可以先对每种主件的 附件的集合 进行一次 $01$背包处理，就可以先求出 对于每一种主件包括其附件的组合中，每种花费的最大价值（读不懂的同学可以看后面解释）。
  对于每一种主件的01背包处理：

for i：主件k的所有附件
    for j：价值（0 ~ n-主件价值）
        01背包递推

这样可以得到主件$k$的附件中费用依次为$0～n-v[k]$时的相应最大价值$f[0\sim n-v[k]]$，那么我们就得到了主件 $k$ 及其附件集合的 $n-v[k]+1$种不同选择情况，其中费用为 $v[k]+t$ 的物品的价值就是$f[t]+v[k]\ast p[k]$。
对于每一个主件处理出的情况，在$n-v[k]+1$ 种情况之中只能最多选择一种选入最终答案之中（把上面文字多读几遍吧），原问题便转化成一个分组背包问题。

for 所有的主件数k
    for j = n ... 0
        for 所有的主件和附件的组合属于组k
            f[j]=max{f[j],f[j-v[i]]+v[i]*p[i]}

另外，本题的情况状态01背包计算需要使用 “恰好背包”。
c++参考代码

#include <bits/stdc++.h>
using namespace std;
const int maxn=100,N=40000;
int n,m,f[N],num[maxn],cnt[maxn],W[maxn][maxn],V[maxn][maxn];
struct node{
	int w,v,p;
}a[maxn],t[maxn][maxn];

int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		cin>>a[i].w>>a[i].v>>a[i].p;
		if(a[i].p){
			num[a[i].p]++;
			t[a[i].p][num[a[i].p]].w=a[i].w;
			t[a[i].p][num[a[i].p]].v=a[i].v;
		}
	}
	for(int i=1;i<=m;i++){
		if(num[i]){
			memset(f,-1,sizeof(f));
			f[0]=0;
			for(int j=1;j<=num[i];j++){
				for(int k=n-a[i].w;k>=t[i][j].w;k--){
					if(f[k-t[i][j].w]!=-1)
					f[k]=max(f[k],f[k-t[i][j].w]+t[i][j].w*t[i][j].v);
				}
			}
			for(int j=1;j<=n-a[i].w;j++){
				if(f[j]!=-1){
					cnt[i]++;
					W[i][cnt[i]]=j+a[i].w;
					V[i][cnt[i]]=f[j]+a[i].w*a[i].v;
				}
			}
		}
		if(!a[i].p){
			cnt[i]++;
			W[i][cnt[i]]=a[i].w;
			V[i][cnt[i]]=a[i].w*a[i].v;
		}
	}
	memset(f,0,sizeof(f));
	for(int i=1;i<=m;i++){
		for(int j=n;j>=0;j--){
			for(int k=1;k<=cnt[i];k++){
				if(j>=W[i][k])
				f[j]=max(f[j],f[j-W[i][k]]+V[i][k]);
			}
		}
	}
    cout<<f[n];
	return 0;
}

八.泛化物品

定义
考虑这样一种物品，它并没有固定的费用和价值，而是它的价值随着你分配给它的费用而变化。这就是泛化物品的概念。
更严格的定义之。在背包容量为$V$的背包问题中，泛化物品是一个定义域为$0...V$中的整数的函数$h$，当分配给它的费用为$v$时，能得到的价值就是$h(v)$。
这个定义有一点点抽象，另一种理解是一个泛化物品就是一个数组$h[0...V]$，给它费用$v$，可得到价值$h[V]$。
一个费用为$c$价值为$w$的物品，如果它是$01$背包中的物品，那么把它看成泛化物品，它就是除了$h(c)=w$其它函数值都为$0$的一个函数。如果它是完全背包中的物品，那么它可以看成这样一个函数，仅当$v$被$c$整除时有$h(v)=v/c\ast w$，其它函数值均为$0$。如果它是多重背包中重复次数最多为$n$的物品，那么它对应的泛化物品的函数有$h(v)=v/c\ast w$仅当$v$被$c$整除且$v/c<=n$，其它情况函数值均为$0$。一个物品组可以看作一个泛化物品$h$。对于一个$0...V$中的$v$，若物品组中不存在费用为$v$的的物品，则$h(v)=0$，否则$h(v)$为所有费用为$v$的物品的最大价值。有依赖的背包问题中每个主件及其附件集合等价于一个物品组，自然也可看作一个泛化物品。
泛化物品的和
如果面对两个泛化物品$h$和$l$，要用给定的费用从这两个泛化物品中得到最大的价值，怎么求呢？事实上，对于一个给定的费用$v$，只需枚举将这个费用如何分配给两个泛化物品就可以了。同样的，对于$0...V$的每一个整数$v$，可以求得费用$v$分配到$h$和$l$中的最大价值$f(v)$。也即
$$f(v)=max(h(k)+l(v-k)\mid 0<=k<=v)$$
可以看到，$f$也是一个由泛化物品$h$和$l$决定的定义域为$0...V$的函数，也就是说，$f$是一个由泛化物品$h$和$l$决定的泛化物品。
由此可以定义泛化物品的和：$h、l$都是泛化物品，若泛化物品$f$满足以上关系式，则称$f$是$h$与$l$的和。这个运算的时间复杂度取决于背包的容量，是$O(V^2)$。
泛化物品的定义表明：在一个背包问题中，若将两个泛化物品代以它们的和，不影响问题的答案。事实上，对于其中的物品都是泛化物品的背包问题，求它的答案的过程也就是求所有这些泛化物品之和的过程。设此和为$s$，则答案就是$s[0...V]$中的最大值。
背包问题的泛化物品
一个背包问题中，可能会给出很多条件，包括每种物品的费用、价值等属性，物品之间的分组、依赖等关系等。但肯定能将问题对应于某个泛化物品。也就是说，给定了所有条件以后，就可以对每个非负整数$v$求得：若背包容量为$v$，将物品装入背包可得到的最大价值是多少，这可以认为是定义在非负整数集上的一件泛化物品。这个泛化物品——或者说问题所对应的一个定义域为非负整数的函数——包含了关于问题本身的高度浓缩的信息。一般而言，求得这个泛化物品的一个子域（例如$0...V$）的值之后，就可以根据这个函数的取值得到背包问题的最终答案。
综上所述，一般而言，求解背包问题，即求解这个问题所对应的一个函数，即该问题的泛化物品。而求解某个泛化物品的一种方法就是将它表示为若干泛化物品的和然后求之。

九.背包问题问法的变化

以上涉及的各种背包问题都是要求在背包容量（费用）的限制下求可以取到的最大价值，但背包问题还有很多种灵活的问法，在这里值得提一下。但是我认为，只要深入理解了求背包问题最大价值的方法，即使问法变化了，也是不难想出算法的。例如，求解最多可以放多少件物品或者最多可以装满多少背包的空间。这都可以根据具体问题利用前面的方程求出所有状态的值（f数组）之后得到。还有，如果要求的是“总价值最小”“总件数最小”，只需简单的将上面的状态转移方程中的$max$改成$min$即可。下面说一些变化更大的问法。
输出方案
一般而言，背包问题是要求一个最优值，如果要求输出这个最优值的方案，可以参照一般动态规划问题输出方案的方法：记录下每个状态的最优值是由状态转移方程的哪一项推出来的，换句话说，记录下它是由哪一个策略推出来的。便可根据这条策略找到上一个状态，从上一个状态接着向前推即可。还是以$01$背包为例，方程为
$$f[i][j]=max(f[i-1][j],f[i-1][j-w[i]]+v[i])$$
再用一个数组$g[i][j]$，设$g[i][j]=0$表示推出$f[i][j]$的值时是采用了方程的前一项（也即$f[i][j]=f[i-1][j]$），$g[i][j]=1$表示采用了方程的后一项。注意这两项分别表示了两种策略：未选第$i$个物品及选了第$i$个物品。那么输出方案的伪代码可以这样写（设最终状态为$f[N][V]$）：

i=N
v=V
while(i>0)
    if(g[i][v]==0)
        print "未选第i项物品"
    else if(g[i][v]==1)
        print "选了第i项物品"
        v=v-c[i]

另外，采用方程的前一项或后一项也可以在输出方案的过程中根据$f[i][j]$的值实时地求出来，也即不须纪录$g$数组，将上述代码中的$g[i][j]==0$改成$f[i][j]==f[i-1][j]$，$g[i][j]==1$改成$f[i][j]==f[i-1][j-w[i]]+v[i]$也可。
输出字典序最小的最优方案
这里“字典序最小”的意思是$1...N$号物品的选择方案排列出来以后字典序最小。以输出$01$背包最小字典序的方案为例。
一般而言，求一个字典序最小的最优方案，只需要在转移时注意策略。首先，子问题的定义要略改一些。我们注意到，如果存在一个选了物品$1$的最优方案，那么答案一定包含物品$1$，原问题转化为一个背包容量为$j-w[1]$，物品为$2...N$的子问题。反之，如果答案不包含物品$1$，则转化成背包容量仍为$V$，物品为$2...N$的子问题。不管答案怎样，子问题的物品都是以$i...N$而非前所述的$1...i$的形式来定义的，所以状态的定义和转移方程都需要改一下。但也许更简易的方法是先把物品逆序排列一下，以下按物品已被逆序排列来叙述。
在这种情况下，可以按照前面经典的状态转移方程来求值，只是输出方案的时候要注意：从$N$到$1$输入时，如果$f[i][j]==f[i-1][j]$及$f[i][j]==f[i-1][j-w[i]]+v[i]$同时成立，应该按照后者（即选择了物品$i$）来输出方案。
求方案总数
对于一个给定了背包容量、物品费用、物品间相互关系（分组、依赖等）的背包问题，除了再给定每个物品的价值后求可得到的最大价值外，还可以得到装满背包或将背包装至某一指定容量的方案总数。
对于这类改变问法的问题，一般只需将状态转移方程中的$max$改成$sum$即可。例如若每件物品均是完全背包中的物品，转移方程即为
$$f[i][j]=\sum f[i-1][j],f[i][j-w[i]]$$
初始条件$f[0][0]=1$。事实上，这样做可行的原因在于状态转移方程已经考察了所有可能的背包组成方案。
最优方案的总数
这里的最优方案是指物品总价值最大的方案。以01背包为例。
结合求最大总价值和方案总数两个问题的思路，最优方案的总数可以这样求：$f[i][j]$意义同前述，$g[i][j]$表示这个子问题的最优方案的总数，则在求$f[i][j]$的同时求$g[i][j]$的伪代码如下：

g[0][0]=1
for i=1..N
   for v=0..V
        f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}
        g[i][v]=0
        if(f[i][v]==f[i-1][v])
            g[i][v]+=g[i-1][v]
        if(f[i][v]==f[i-1][v-c[i]]+w[i])
            g[i][v]+=g[i-1][v-c[i]]

求次优解、第$K$优解
对于求次优解、第$K$优解类的问题，如果相应的最优解问题能写出状态转移方程、用动态规划解决，那么求次优解往往可以相同的复杂度解决，第$K$优解则比求最优解的复杂度上多一个系数$K$。
其基本思想是将每个状态都表示成有序队列，将状态转移方程中的$max/min$转化成有序队列的合并。这里仍然以01背包为例讲解一下。
首先看01背包求最优解的状态转移方程：
$$f[i][j]=max(f[i-1][j],f[i-1][j-w[i]]+v[i])$$
如果要求第K优解，那么状态$f[i][v]$就应该是一个大小为K的数组$f[i][v][1..K]$。其中$f[i][v][k]$表示前$i$个物品、背包大小为$v$时，第$k$优解的值。“$f[i][v]$是一个大小为$K$的数组”这一句，熟悉C语言的同学可能比较好理解，或者也可以简单地理解为在原来的方程中加了一维。显然$f[i][v][1..K]$这$K$个数是由大到小排列的，所以我们把它认为是一个有序队列。
然后原方程就可以解释为：$f[i][v]$这个有序队列是由$f[i-1][v]$和$f[i-1][v-c[i]]+w[i]$这两个有序队列合并得到的。有序队列$f[i-1][v]$即$f[i-1][v][1..K]，f[i-1][v-c[i]]+w[i]$则理解为在$f[i-1][v-c[i]][1..K]$的每个数上加上$w[i]$后得到的有序队列。合并这两个有序队列并将结果的前$K$项储存到$f[i][v][1..K]$中的复杂度是$O(K)$。最后的答案是$f[N][V][K]$。总的复杂度是$O(VNK)$。
为什么这个方法正确呢？实际上，一个正确的状态转移方程的求解过程遍历了所有可用的策略，也就覆盖了问题的所有方案。只不过由于是求最优解，所以其它在任何一个策略上达不到最优的方案都被忽略了。如果把每个状态表示成一个大小为$K$的数组，并在这个数组中有序的保存该状态可取到的前$K$个最优值。那么，对于任两个状态的$max$运算等价于两个由大到小的有序队列的合并。
另外还要注意题目对于“第$K$优解”的定义，将策略不同但权值相同的两个方案是看作同一个解还是不同的解。如果是前者，则维护有序队列时要保证队列里的数没有重复的。代码：

int kth(int n, int V, int k) {
    for (int i = 1; i <= n; i++) {
        for (int j = V; j >= w[i]; j--) {
            for (int l = 1; l <= k; l++) {
                a[l] = f[j][l];
                b[l] = f[j - w[i]][l] + v[i];
            }
            a[k + 1] = -1;
            b[k + 1] = -1;
            int x = 1, y = 1, o = 1;
            while (o != k + 1 and (a[x] != -1 or b[y] != -1)) {
                if (a[x] > b[y]) f[j][o] = a[x], x++;
                else f[j][o] = b[y], y++;
                if (f[j][o] != f[j][o - 1]) o++;
            }
        }
    }
    return f[V][k];
}

$完$

$2019.10.3019:27byWarrenChou$

如果想要得到更多知识，请关注我博客：wlis.blog.csdn.net

此博客不定期更新内容！！！感谢大家！！！