首先说下动态规划，动态规划这东西就和递归一样，只能找局部关系，若想全部列出来，是很难的，比如汉诺塔。你可以说先把除最后一层的其他所有层都移动到2，再把最后一层移动到3，最后再把其余的从2移动到3，这是一个直观的关系，但是想列举出来是很难的，也许当层数n=3时还可以模拟下，再大一些就不可能了，所以，诸如递归，动态规划之类的，不能细想，只能找局部关系。
DP最关键的就是状态，在DP时用到的数组时，也就是存储的每个状态的最优值，也就是记忆化搜索。
要了解背包，首先得清楚动态规划：
动态规划算法可分解成从先到后的4个步骤：
1. 描述一个最优解的结构；
2. 递归地定义最优解的值；
3. 以“自底向上”的方式计算最优解的值；
4. 从已计算的信息中构建出最优解的路径。
其中步骤1~3是动态规划求解问题的基础。如果题目只要求最优解的值，则步骤4可以省略。
背包的基本模型就是给你一个容量为V的背包
在一定的限制条件下放进最多(最少?)价值的东西
当前状态→ 以前状态
首先我们把三种情况放在一起来看：
01背包（ZeroOnePack）: 有N件物品和一个容量为V的背包。（每种物品均只有一件）第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。
完全背包(CompletePack): 有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
多重背包(MultiplePack): 有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
比较三个题目，会发现不同点在于每种背包的数量，01背包是每种只有一件，完全背包是每种无限件，而多重背包是每种有限件。
1、【01背包】
01背包（ZeroOnePack）: 有N件物品和一个容量为V的背包。（每种物品均只有一件）第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。
这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。
用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程是：
f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}
把这个过程理解下：在前i件物品放进容量v的背包时，
它有两种情况：
第一种是第i件不放进去，这时所得价值为:f[i-1][v]
第二种是第i件放进去，这时所得价值为：f[i-1][v-c[i]]+w[i]
（第二种是什么意思？就是如果第i件放进去，那么在容量v-c[i]里就要放进前i-1件物品）
最后比较第一种与第二种所得价值的大小，哪种相对大，f[i][v]的值就是哪种！！（这是基础，要理解！）
这里是用二维数组存储的，可以把空间优化，用一维数组存储。
用f[0..v]表示，f[v]表示把前i件物品放入容量为v的背包里得到的价值。把i从1~n(n件)循环后，最后f[v]表示所求最大值！！
这里f[v]就相当于二位数组的f[i][v]。那么，如何得到f[i-1][v]和f[i-1][v-c[i]]+w[i]？（重点！思考）
首先要知道，我们是通过i从1到n的循环来依次表示前i件物品存入的状态。即：for i=1..N
现在思考如何能在是f[v]表示当前状态是容量为v的背包所得价值，而又使f[v]和f[v-c[i]]+w[i]标签前一状态的价值？
逆序！
这就是关键！
for i=1..N
for v=V..0 (V..v[i])
f[v]=max{f[v],f[v-c[i]]+w[i]};分析上面的代码：当内循环是逆序时，就可以保证后一个f[v]和f[v-c[i]]+w[i]是前一状态的！
这里给大家一组测试数据：
测试数据：
10,3
3,4
4,5
5,6
这个图表画得很好，借此来分析：
C[v]从物品i=1开始，循环到物品3，期间，每次逆序得到容量v在前i件物品时可以得到的最大值。（请在草稿纸上自己画一画）
分析：
具体根据上面的解释以及我给出的代码分析。这题很基础，看懂上面的知识应该就会做了。
2、【完全背包】
完全背包(CompletePack): 有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
完全背包按其思路仍然可以用一个二维数组来写出，且状态转移方程是：
f[i][v]=max{f[i-1][v-k*c[i]]+k*w[i]|0<=k*c[i]<=v}
但同样可以转换成一维数组来表示：
伪代码如下：
for i=1..N
for v=0..V （v[i]..V）
f[v]=max{f[v],f[v-c[i]]+w[i]}想必大家看出了和01背包的区别，这里的内循环是顺序的，而01背包是逆序的。
现在关键的是考虑：为何完全背包可以这么写？
在次我们先来回忆下，01背包逆序的原因？是为了是max中的两项是前一状态值，这就对了。
那么这里，我们顺序写，这里的max中的两项当然就是当前状态的值了，为何？
因为每种背包都是无限的。当我们把i从1到N循环时，f[v]表示容量为v在前i种背包时所得的价值，这里我们要添加的不是前一个背包，而是当前背包。所以我们要考虑的当然是当前状态。
（分析代码也是学习算法的一种途径，有时并不一定要看算法分析，结合题目反而更容易理解。）
3、【多重背包】
多重背包(MultiplePack): 有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
（1）基本算法 ：这题目和完全背包问题很类似。基本的方程只需将完全背包问题的方程略微一改即可，因为对于第i种物品有n[i]+1种策略：取0件，取1件……取 n[i]件。令f[i][v]表示前i种物品恰放入一个容量为v的背包的最大权值，则有状态转移方程：
f[i][v]=max{f[i-1][v-k*c[i]]+ k*w[i]|0<=k<=n[i]}。复杂度是O(V*∑n[i])。
（2）转化为01背包问题
另一种好想好写的基本方法是转化为01背包求解：把第i种物品换成n[i]件01背包中的物品，则得到了物品数为∑n[i]的01背包问题，直接求解，复杂度仍然是O(V*∑n[i])。
但是我们期望将它转化为01背包问题之后能够像完全背包一样降低复杂度。仍然考虑二进制的思想，我们考虑把第i种物品换成若干件物品，使得原问题中第i种物品可取的每种策略——取0..n[i]件——均能等价于取若干件代换以后的物品。另外，取超过n[i]件的策略必不能出现。
方法是：将第i种物品分成若干件物品，其中每件物品有一个系数，这件物品的费用和价值均是原来的费用和价值乘以这个系数。使这些系数分别为 1,2,4,...,2^(k-1),n[i]-2^k+1，且k是满足n[i]-2^k+1>0的最大整数。例如，如果n[i]为13，就将这种物品分成系数分别为1,2,4,6的四件物品。
分成的这几件物品的系数和为n[i]，表明不可能取多于n[i]件的第i种物品。另外这种方法也能保证对于0..n[i]间的每一个整数，均可以用若干个系数的和表示，这个证明可以分0..2^k-1和2^k..n[i]两段来分别讨论得出，并不难，希望你自己思考尝试一下。
这样就将第i种物品分成了O(log n[i])种物品，将原问题转化为了复杂度为O(V*∑log n[i])的01背包问题，是很大的改进。
（3）O(VN)的算法
多重背包问题同样有O(VN)的算法。这个算法基于基本算法的状态转移方程，但应用单调队列的方法可以使每个状态的值可以以均摊O(1)的时间求解。
多重背包小结：在这里，我们将一个算法的复杂度由O(V*∑n[i])改进到O(V*∑log n[i])，还知道它有O(VN)算法。要特别注意“拆分物品”的思想和方法。
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
01 背包
有n 种不同的物品，每个物品有两个属性，size 体积，value 价值，现在给一个容量为 w 的背包，问最多可带走多少价值的物品。
int f[w+1]; //f[x] 表示背包容量为x 时的最大价值
for (int i=0; i<n; i++)
for (int j=w; j>=size[i]; j--)
f[j] = max(f[j], f[j-size[i]]+value[i]);
完全背包
如果物品不计件数，就是每个物品不只一件的话，稍微改下即可
for (int i=0; i<n; i++)
for (int j=size[i]; j<=w; j++)
f[j] = max(f[j], f[j-size[i]]+value[i]);
f[w] 即为所求
初始化分两种情况：
1、如果背包要求正好装满则初始化 f[0] = 0, f[1~w] = -INF;
2、如果不需要正好装满 f[0~v] = 0;
举例：
01背包
V=10，N=3，c[]={3,4,5}, w={4,5,6}
（1）背包不一定装满
计算顺序是：从右往左，自上而下：因为每个物品只能放一次，前面的体积小的会影响体积大的
（2）背包刚好装满
计算顺序是：从右往左，自上而下。注意初始值，其中-inf表示负无穷
V=10，N=3，c[]={3,4,5}, w={4,5,6}
（1）背包不一定装满
计算顺序是：从左往右，自上而下： 每个物品可以放多次，前面的会影响后面的
（2）背包刚好装满
计算顺序是：从左往右，自上而下。注意初始值，其中-inf表示负无穷
多重背包：
多重背包问题要求很简单，就是每件物品给出确定的件数，求可得到的最大价值
多重背包转换成 01 背包问题就是多了个初始化，把它的件数C 用二进制分解成若干个件数的集合，这里面数字可以组合成任意小于等于C的件数，而且不会重复，之所以叫二进制分解，是因为这样分解可以用数字的二进制形式来解释
比如：7的二进制 7 = 111 它可以分解成 001 010 100 这三个数可以组合成任意小于等于7 的数，而且每种组合都会得到不同的数
15 = 1111 可分解成 0001 0010 0100 1000 四个数字
如果13 = 1101 则分解为 0001 0010 0100 0110 前三个数字可以组合成 7以内任意一个数，即1、2、4可以组合为1——7内所有的数，加上 0110 = 6 可以组合成任意一个大于6 小于等于13的数，比如12，可以让前面贡献6且后面也贡献6就行了。虽然有重复但总是能把 13 以内所有的数都考虑到了，基于这种思想去把多件物品转换为，多种一件物品，就可用01 背包求解了。
看代码：
int n; //输入有多少种物品
int c; //每种物品有多少件
int v; //每种物品的价值
int s; //每种物品的尺寸
int count = 0; //分解后可得到多少种物品
int value[MAX]; //用来保存分解后的物品价值
int size[MAX]; //用来保存分解后物品体积
scanf("%d", &n); //先输入有多少种物品，接下来对每种物品进行分解
while (n--) //接下来输入n中这个物品
{
scanf("%d%d%d", &c, &s, &v); //输入每种物品的数目和价值
for (int k=1; k<=c; k<<=1) //<<右移 相当于乘二
{
value[count] = k*v;
size[count++] = k*s;
c -= k;
}
if (c > 0)
{
value[count] = c*v;
size[count++] = c*s;
}
}
定理：一个正整数n可以被分解成1,2,4,…,2^(k-1),n-2^k+1（k是满足n-2^k+1>0的最大整数）的形式，且1～n之内的所有整数均可以唯一表示成1,2,4,…,2^(k-1),n-2^k+1中某几个数的和的形式。
证明如下：
（1） 数列1,2,4,…,2^(k-1),n-2^k+1中所有元素的和为n，所以若干元素的和的范围为：[1, n]；
（2）如果正整数t<= 2^k – 1,则t一定能用1,2,4,…,2^(k-1)中某几个数的和表示，这个很容易证明：我们把t的二进制表示写出来，很明显，t可以表示成n=a0*2^0+a1*2^1+…+ak*2^（k-1），其中ak=0或者1，表示t的第ak位二进制数为0或者1.
（3）如果t>=2^k,设s=n-2^k+1，则t-s<=2^k-1，因而t-s可以表示成1,2,4,…,2^(k-1)中某几个数的和的形式，进而t可以表示成1,2,4,…,2^(k-1)，s中某几个数的和（加数中一定含有s）的形式。
（证毕！）
现在用count 代替 n 就和01 背包问题完全一样了 ， 杭电2191题解：此为多重背包用01和完全背包：
#include<stdio.h>
#include<string.h>
int dp[102];
int p[102],h[102],c[102];
int n,m;
void comback(int v,int w)//经费，重量。完全背包；
{
for(int i=v; i<=n; i++)
if(dp[i]<dp[i-v]+w)
dp[i]=dp[i-v]+w;
}
void oneback(int v,int w)//经费，重量；01背包；
{
for(int i=n; i>=v; i--)
if(dp[i]<dp[i-v]+w)
dp[i]=dp[i-v]+w;
}
int main()
{
int ncase,i,j,k;
scanf("%d",&ncase);
while(ncase--)
{
memset(dp,0,sizeof(dp));
scanf("%d%d",&n,&m);//经费，种类；
for(i=1; i<=m; i++)
{
scanf("%d%d%d",&p[i],&h[i],&c[i]);//价值，重量，数量;
if(p[i]*c[i]>=n) comback(p[i],h[i]);
else
{
for(j=1; j<c[i]; j<<1)
{
oneback(j*p[i],j*h[i]);
c[i]=c[i]-j;
}
oneback(p[i]*c[i],h[i]*c[i]);
}
}
printf("%d\n",dp[n]);
}
return 0;
}
只是用01背包，用二进制优化：
#include <iostream>
using namespace std;
int main()
{
int nCase,Limit,nKind,i,j,k, v[111],w[111],c[111],dp[111];
//v[]存价值，w[]存尺寸，c[]存件数
//在本题中，价值是米的重量，尺寸是米的价格
int count,Value[1111],size[1111];
//count存储分解完后的物品总数
//Value存储分解完后每件物品的价值
//size存储分解完后每件物品的尺寸
cin>>nCase;
while(nCase--)
{
count=0;
cin>>Limit>>nKind;
for(i=0; i<nKind; i++)
{
cin>>w[i]>>v[i]>>c[i];
//对该种类的c[i]件物品进行二进制分解
for(j=1; j<=c[i]; j<<=1)
{
//<<右移1位，相当于乘2
Value[count]=j*v[i];
size[count++]=j*w[i];
c[i]-=j;
}
if(c[i]>0)
{
Value[count]=c[i]*v[i];
size[count++]=c[i]*w[i];
}
}
//经过上面对每一种物品的分解，
//现在Value[]存的就是分解后的物品价值
//size[]存的就是分解后的物品尺寸
//count就相当于原来的n
//下面就直接用01背包算法来解
memset(dp,0,sizeof(dp));
for(i=0; i<count; i++)
for(j=Limit; j>=size[i]; j--)
if(dp[j]<dp[j-size[i]]+Value[i])
dp[j]=dp[j-size[i]]+Value[i];
cout<<dp[Limit]<<endl;
}
return 0;
}
未优化的：
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int Value[105];
int Cost[105];
int Bag[105];
int dp[105];
int main()
{
int C,m,n;
scanf("%d",&C);
while(C--)
{
scanf("%d%d",&n,&m);
for(int i = 1; i <= m; i++)
scanf("%d%d%d",&Cost[i],&Value[i],&Bag[i]);
memset(dp,0,sizeof(dp));
for(int i=1; i<= m; i++)
for(int j=1; j<=Bag[i]; j++)
for(int k=n; k>=Cost[i]; k--)
dp[k]=max(dp[k], dp[k-Cost[i]]+Value[i]);
printf("%d\n",dp[n]);
}
return 0;
}
做完背包后，自己总结了一下各种背包问题以及需要注意的地方，以下是在总结的过程中参考的文章。
参考：
http://www.cnblogs.com/tanky_woo/archive/2010/07/31/1789621.html
http://blog.csdn.net/lyhvoyage/article/details/8545852
http://www.cnblogs.com/devil-91/archive/2012/05/16/2502710.html
背包九讲
2290
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
