【0/1背包问题】
在0/1背包问题中，需对容量为c 的背包进行装载。从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高，即p1*x1+p2*x1+...+pi*xi(其1<=i<=n，x取0或1，取1表示选取物品i) 取得最大值。
【输入文件】
第一行一个数c，为背包容量。
第二行一个数n，为物品数量
第三行n个数，以空格间隔，为n个物品的重量
第四行n个数，以空格间隔，为n个物品的价值
【输出文件】
能取得的最大价值。
【分析】
初看这类问题，第一个想到的会是贪心，但是贪心法却无法保证一定能得到最优解，看以下实例：
贪心准则1：从剩余的物品中，选出可以装入背包的价值最大的物品，利用这种规则，价值最大的物品首先被装入（假设有足够容量），然后是下一个价值最大的物品，如此继续下去。这种策略不能保证得到最优解。例如，考虑n=2, w=[100,10,10], p =[20,15,15], c =105。当利用价值贪婪准则时，获得的解为x= [1,0,0]，这种方案的总价值为20。而最优解为[0,1,1]，其总价值为30。
贪心准则2：从剩下的物品中选择可装入背包的重量最小的物品。虽然这种规则对于前面的例子能产生最优解，但在一般情况下则不一定能得到最优解。考虑n= 2 ,w=[10,20], p=[5,100], c= 2 5。当利用重量贪婪策略时，获得的解为x =[1,0], 比最优解[ 0 , 1 ]要差。
贪心准则3：价值密度pi /wi 贪婪算法，这种选择准则为：从剩余物品中选择可 装入包的pi /wi 值最大的物品，但是这种策略也不能保证得到最优解。利用此策略解 n=3 ,w=[20,15,15], p=[40,25,25], c=30 时的得到的就不是最优解。
由此我们知道无法使用贪心算法来解此类问题。我们采用如下思路：
在该问题中需要决定x1 .. xn的值。假设按i = 1，2，...，n 的次序来确定xi 的值。如果置x1 = 0，则问题转变为相对于其余物品(即物品2，3，.，n)，背包容量仍为c 的背包问题。若置x1 = 1，问题就变为关于最大背包容量为c-w1 的问题。现设r={c，c-w1} 为剩余的背包容量。在第一次决策之后，剩下的问题便是考虑背包容量为r 时的决策。不管x1 是0或是1，[x2 ，.，xn ] 必须是第一次决策之后的一个最优方案。也就是说在此问题中，最优决策序列由最优决策子序列组成。
假设f (i,j) 表示剩余容量为j，剩余物品为i，i + 1，...，n 时的最优解的值，即：利用最优序列由最优子序列构成的结论，可得到f 的递归式为：
当j≥wi时： f(i,j)=max{f(i+1,j),f(i+1,j-wi)+pi}
当0≤j<wi时：f(i,j)=f(i+1,j)
这是一个递归的算法，其时间效率较低，为指数级。
考虑用动态规划的方法来解决:
阶段：在前i件物品中，选取若干件物品放入背包中；
状态：在前i件物品中，选取若干件物品放入所剩空间为c的背包中的所能获得的最大价值；
决策：第i件物品放或者不放；
由此可以写出动态转移方程：
用f[i,j]表示在前 i 件物品中选择若干件放在所剩空间为 j 的背包里所能获得的最大价值
f[i,j]=max{f[i-1,j-wi]+pi (j>=wi), f[i-1,j]}
这样，就可以自底向上地得出在前n件物品中取出若干件放进背包能获得的最大价值，也就是f[n,c]
算法框架如下：
for i:=0 to c do {i=0也就是没有物品时清零}
f[0,i]:=0;
for i:=1 to n do {枚举n件物品}
for j:=0 to c do {枚举所有的装入情况}
begin
f[i,j]:=f[i-1,j]; {先让本次装入结果等于上次结果}
if (j>=w[i]) and (f[i-1,j-w[i]]+p[i]>f[i,j]) {如果能装第i件物品}
then f[i,j]:=f[i-1,j-w[i]]+p[i]; {且装入后价值变大则装入}
end;
writeln(f[n,c]);
为了进一步说明算法的执行原理，下面给出一个实例：
【输入文件】
10
4
5 1 4 3
40 10 25 30
【输出结果】下面列出所有的f[i,j]
0 0 0 0 40 40 40 40 40 40
10 10 10 10 40 50 50 50 50 50
10 10 10 25 40 50 50 50 65 75
10 10 30 40 40 50 55 70 80 80
从以上的数据中我们可以清晰地看到每一次的枚举结果，每一行都表示一个阶段。
1.递归思想
0- 1 背包问题如果采用递归算法来描述则非常清楚明白, 它的算法根本思想是假设用布尔函数
knap( s, n) 表示n 件物品放入可容质量为s 的背包中是否有解( 当knap 函数的值为真时
说明问题有解,其值为假时无解) . 我们可以通过输入s 和n 的值, 根据它们的值可分为以下几种情况讨论:
( 1) 当s= 0时可知问题有解, 即函数knap( s, n) 的值为true; ( 2) 当s< 0 时这时不可能,
所以函数值为false; ( 3) 当输入的s> 0 且n< 1 时即总物品的件数不足1, 这时函数值为false,
只有s> 0 且n \1 时才符合实际情况,这时又分为两种情况: ( 1) 选择的一组物体中不包括Wn
则knap( s, n) 的解就是knap( s, n- 1) 的解. ( 2) 选择的一组物体中包括Wn 则knap( s, n) 的解
就是knap( s- Wn, n- 1) 的解. 这样一组Wn 的值就是问题的最佳解. 这样就将规模为n 的问题转化为
规模为n- 1 的问题. 综上所述0- 1 背包问题的递归函数定义为:
knap( s, n) =∕true, s= 0
︳false, s< 0
︳false, s> 0 且n< 1
\knap( s, n- 1) 或knap( s- Wn, n- 1) , s> 0 且n>= 1
采用此法求解0- 1 背包问题的时间复杂度为O( n) . 上述算法对于所有物品中的某几件恰能装满背包
时能准确求出最佳解. 但一般情况是对于某一些物品无论怎么装都不能装满背包, 必须要按背包的最大
容量来装. 如物品件数为4, 其质量分别为: 10, 2, 5, 4, 背包的容量为20, 则这四件物品无论怎么放都不
能恰好装满背包, 但应能最大限度装, 即必须装下10, 5, 4 这三件物品, 这样就能得到最大质量19. 对于
这种装不满的背包它的解决办法是这样的: 按所有物品的组合质量最大的方法装背包, 如果还装不满,
则我们可以考虑剩余空间能否装下所有物品中最小的那件, 如果连最小的都装不下了则说明这样得到
的解是最佳解, 问题解决. 这样我们必须先找出所有n 件物品中质量最小的那件( 它的质量为Min) , 但
是为了问题的解决我们不能增加运算次数太多, 并且必须运用上述递归函数. 那么我们可通过修改s 的
值即背包的容量, 从背包容量s 中减去k( 它的值是从0 到Min- 1 之间的一个整数值) , 再调用递归函
数. 当k= 0 时即能装满背包, 其它值也能保证背包能最大限度装满, 这样所有问题都解决了.
①例题一：
简单背包问题
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 2217 Accepted: 408
Description
设有一个背包可以放入的物品重量为S，现有n件物品，重量分别是w1，w2，w3，…wn。
问能否从这n件物品中选择若干件放入背包中，使得放入的重量之和正好为S。
如果有满足条件的选择，则此背包有解，否则此背包问题无解。
Input输入数据有多行，包括放入的物品重量为s，物品的件数n，以及每件物品的重量（输入数据均为正整数）
多组测试数据。
Output对于每个测试实例，若满足条件则输出“YES”，若不满足则输出“NO“
Sample Input
20 5
1 3 5 7 9
Sample Output
YES
View Code
1 # include<stdio.h> 2 # include<string.h> 3 int date[1005]; 4 int f(int w,int s) 5 { 6 if(w==0) return 1;//正好 7 if(w<0||w>0 &&s==0) return 0; 8 if(f(w-date[s],s-1)) return 1;//退出来再选下一个 9 return f(w,s-1);//选择下一个 10 } 11 12 int main() 13 { 14 int i,Weight,n; 15 while(scanf("%d %d",&Weight,&n)!=EOF) 16 { 17 memset(date,0,sizeof(date)); 18 for(i=1;i<=n;i++) 19 scanf("%d",&date[i]); 20 if(f(Weight,n)) 21 printf("YES\n"); 22 else printf("NO\n"); 23 } 24 return 0; 25 } 26 }
01背包问题
01背包问题：
1.递归思想
0- 1 背包问题如果采用递归算法来描述则非常清楚明白, 它的算法根本思想是假设用布尔函数
knap( s, n) 表示n 件物品放入可容质量为s 的背包中是否有解( 当knap 函数的值为真时
说明问题有解,其值为假时无解) . 我们可以通过输入s 和n 的值, 根据它们的值可分为以下几种情况讨论:
( 1) 当s= 0时可知问题有解, 即函数knap( s, n) 的值为true; ( 2) 当s< 0 时这时不可能,
所以函数值为false; ( 3) 当输入的s> 0 且n< 1 时即总物品的件数不足1, 这时函数值为false,
只有s> 0 且n \1 时才符合实际情况,这时又分为两种情况: ( 1) 选择的一组物体中不包括Wn
则knap( s, n) 的解就是knap( s, n- 1) 的解. ( 2) 选择的一组物体中包括Wn 则knap( s, n) 的解
就是knap( s- Wn, n- 1) 的解. 这样一组Wn 的值就是问题的最佳解. 这样就将规模为n 的问题转化为
规模为n- 1 的问题. 综上所述0- 1 背包问题的递归函数定义为:
knap( s, n) =∕true, s= 0
︳false, s< 0
︳false, s> 0 且n< 1
\knap( s, n- 1) 或knap( s- Wn, n- 1) , s> 0 且n>= 1
采用此法求解0- 1 背包问题的时间复杂度为O( n) . 上述算法对于所有物品中的某几件恰能装满背包
时能准确求出最佳解. 但一般情况是对于某一些物品无论怎么装都不能装满背包, 必须要按背包的最大
容量来装. 如物品件数为4, 其质量分别为: 10, 2, 5, 4, 背包的容量为20, 则这四件物品无论怎么放都不
能恰好装满背包, 但应能最大限度装, 即必须装下10, 5, 4 这三件物品, 这样就能得到最大质量19. 对于
这种装不满的背包它的解决办法是这样的: 按所有物品的组合质量最大的方法装背包, 如果还装不满,
则我们可以考虑剩余空间能否装下所有物品中最小的那件, 如果连最小的都装不下了则说明这样得到
的解是最佳解, 问题解决. 这样我们必须先找出所有n 件物品中质量最小的那件( 它的质量为Min) , 但
是为了问题的解决我们不能增加运算次数太多, 并且必须运用上述递归函数. 那么我们可通过修改s 的
值即背包的容量, 从背包容量s 中减去k( 它的值是从0 到Min- 1 之间的一个整数值) , 再调用递归函
数. 当k= 0 时即能装满背包, 其它值也能保证背包能最大限度装满, 这样所有问题都解决了.
①例题一：
简单背包问题
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 2217 Accepted: 408
Description
设有一个背包可以放入的物品重量为S，现有n件物品，重量分别是w1，w2，w3，…wn。
问能否从这n件物品中选择若干件放入背包中，使得放入的重量之和正好为S。
如果有满足条件的选择，则此背包有解，否则此背包问题无解。
Input输入数据有多行，包括放入的物品重量为s，物品的件数n，以及每件物品的重量（输入数据均为正整数）
多组测试数据。
Output对于每个测试实例，若满足条件则输出“YES”，若不满足则输出“NO“
Sample Input
20 5
1 3 5 7 9
Sample Output
YES
2.贪心算法
用贪心法设计算法的特点是一步一步地进行，根据某个优化测度（可能是目标函数，也可能不是目标函数），每一步上都要保证能获得局部最优解。
每一步只考虑一个数据，它的选取应满足局部优化条件。若下一个数据与部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，
直到把所有数据枚举完，或者不能再添加为止。
View Code
1 #include<iostream> 2 #include<algorithm> 3 using namespace std; 4 struct good//表示物品的结构体 5 { 6 double p;//价值 7 double w;//重量 8 double r;//价值与重量的比 9 }; 10 good a[2000]; 11 bool bigger(good a,good b) 12 { 13 if(a.r==b.r)return a.w<b.w; 14 else return a.r>b.r; 15 } 16 int main() 17 { 18 double s,value,m; 19 int i,n; 20 cin>>m>>n;//读入包的容量和物品个数 21 for (i=0;i<n;i++) 22 { 23 cin>>a[i].w>>a[i].p; 24 a[i].r=a[i].p/a[i].w; 25 } 26 sort(a,a+n,bigger);//调用sort排序函数，按照价值与重量比和质量排序贪心 27 s=0;//包内现存货品的重量 28 value=0;//包内现存货品总价值 29 for (i=0;i<n;i++) 30 if(s+a[i].w<=m) 31 { 32 value+=a[i].p; 33 s+=a[i].w; 34 } 35 cout<<"The total value is "<<value<<endl;//输出结果 36 return 0; 37 }
01背包问题
01背包问题：
1.递归思想
0- 1 背包问题如果采用递归算法来描述则非常清楚明白, 它的算法根本思想是假设用布尔函数
knap( s, n) 表示n 件物品放入可容质量为s 的背包中是否有解( 当knap 函数的值为真时
说明问题有解,其值为假时无解) . 我们可以通过输入s 和n 的值, 根据它们的值可分为以下几种情况讨论:
( 1) 当s= 0时可知问题有解, 即函数knap( s, n) 的值为true; ( 2) 当s< 0 时这时不可能,
所以函数值为false; ( 3) 当输入的s> 0 且n< 1 时即总物品的件数不足1, 这时函数值为false,
只有s> 0 且n \1 时才符合实际情况,这时又分为两种情况: ( 1) 选择的一组物体中不包括Wn
则knap( s, n) 的解就是knap( s, n- 1) 的解. ( 2) 选择的一组物体中包括Wn 则knap( s, n) 的解
就是knap( s- Wn, n- 1) 的解. 这样一组Wn 的值就是问题的最佳解. 这样就将规模为n 的问题转化为
规模为n- 1 的问题. 综上所述0- 1 背包问题的递归函数定义为:
knap( s, n) =∕true, s= 0
︳false, s< 0
︳false, s> 0 且n< 1
\knap( s, n- 1) 或knap( s- Wn, n- 1) , s> 0 且n>= 1
采用此法求解0- 1 背包问题的时间复杂度为O( n) . 上述算法对于所有物品中的某几件恰能装满背包
时能准确求出最佳解. 但一般情况是对于某一些物品无论怎么装都不能装满背包, 必须要按背包的最大
容量来装. 如物品件数为4, 其质量分别为: 10, 2, 5, 4, 背包的容量为20, 则这四件物品无论怎么放都不
能恰好装满背包, 但应能最大限度装, 即必须装下10, 5, 4 这三件物品, 这样就能得到最大质量19. 对于
这种装不满的背包它的解决办法是这样的: 按所有物品的组合质量最大的方法装背包, 如果还装不满,
则我们可以考虑剩余空间能否装下所有物品中最小的那件, 如果连最小的都装不下了则说明这样得到
的解是最佳解, 问题解决. 这样我们必须先找出所有n 件物品中质量最小的那件( 它的质量为Min) , 但
是为了问题的解决我们不能增加运算次数太多, 并且必须运用上述递归函数. 那么我们可通过修改s 的
值即背包的容量, 从背包容量s 中减去k( 它的值是从0 到Min- 1 之间的一个整数值) , 再调用递归函
数. 当k= 0 时即能装满背包, 其它值也能保证背包能最大限度装满, 这样所有问题都解决了.
①例题一：
简单背包问题
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 2217 Accepted: 408
Description
设有一个背包可以放入的物品重量为S，现有n件物品，重量分别是w1，w2，w3，…wn。
问能否从这n件物品中选择若干件放入背包中，使得放入的重量之和正好为S。
如果有满足条件的选择，则此背包有解，否则此背包问题无解。
Input输入数据有多行，包括放入的物品重量为s，物品的件数n，以及每件物品的重量（输入数据均为正整数）
多组测试数据。
Output对于每个测试实例，若满足条件则输出“YES”，若不满足则输出“NO“
Sample Input
20 5
1 3 5 7 9
Sample Output
YES
2.贪心算法
用贪心法设计算法的特点是一步一步地进行，根据某个优化测度（可能是目标函数，也可能不是目标函数），每一步上都要保证能获得局部最优解。
每一步只考虑一个数据，它的选取应满足局部优化条件。若下一个数据与部分最优解连在一起不再是可行解时，就不把该数据添加到部分解中，
直到把所有数据枚举完，或者不能再添加为止。
但仔细想就会发现有个很大的问题，
10 4
5 10
8 16
5 5
10 10
就会出问题，被装进去就不会拿出来，可见“拿来主义”行不通！
接下来介绍另一种算法：动规
3.动态规划【正解】
有N件物品和一个容量为V的背包。第i件物品的体积是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。
状态转移方程：
f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}
这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来的
伪码：
for i=1..N
for v=V..0
f[v]=max{f[v],f[v-c[i]]+w[i]};
如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，
价值为f[i-1][v]；
如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，
此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。
②例题二：
采药
Time Limit: 1000MS Memory Limit: 65535KB
Submissions: 155 Accepted: 50
Description辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他
的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自
身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”
如果你是辰辰，你能完成这个任务吗？
Input
输入的第一行有两个整数T（1 <= T <= 1000）和M（1 <= M <=
100），用一个空格隔开，T代表总共能够用来采药的时间，M代表山洞里的草药的数目。接下来的M行每行包括两个在1到100之间（包括1和100）的整
数，分别表示采摘某株草药的时间和这株草药的价值。
Output输出包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。
Sample Input
70 3
71 100
69 1
1 2
Sample Output
3
View Code
1 #include<iostream> 2 # include<cstring> 3 # define max(a,b) a>b?a:b 4 using namespace std; 5 int main() 6 { 7 8 int dp[101][1001],m,T,w[101],val[101],i,j; 9 cin>>T>>m; 10 for(i=1;i<=m;i++) 11 cin>>w[i]>>val[i]; 12 memset(dp,0,sizeof(dp)); 13 for(i=1;i<=m;i++) 14 for(j=0;j<=T;j++)//j相当于上面说的V-c[i] 15 { 16 if(j>=w[i]) 17 dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+val[i]);//放还是不放的选择 18 else dp[i][j]=dp[i-1][j]; 19 } 20 cout<<dp[m][T]<<endl; 21 return 0; 22 }
动态规划解决01背包问题程序:
View Code
1 // 动态规划解决01背包问题 2 #include <iostream> 3 #include <iomanip> 4 //问题描述 五个物体 背包容量W=17 5 //体积数据 v[5]={3,4,7,8,9} 6 //价值数据 w[5]={4,5,10,11,13} 7 using namespace std; 8 void fn(int k,int m); 9 int w[6]={0,4,5,10,11,13};//价值 10 int v[6]={0,3,4,7,8,9};//体积 11 int x[6]; 12 int a[6][18]; 13 int i,j,k,m; 14 int main () 15 { 16 17 //初始化 第0行0列赋值为0 18 for ( i=0;i<=5;i++) a[i][0]=0; 19 for ( j=0;j<=5;j++) a[0][j]=0; 20 21 22 for ( i=1;i<=5;i++) //i表示第几个物品 23 { for (j=1;j<=17;j++) //j表示容量大小 24 { 25 if (v[i]>j) 26 a[i][j]=a[i-1][j]; 27 else 28 a[i][j]=(a[i-1][j]>a[i-1][j-v[i]]+w[i])? a[i-1][j]:a[i-1][j-v[i]]+w[i]; 29 30 } 31 } 32 //输出数据表用于观察 33 for ( i=0;i<=5;i++) //i表示第几个物品 34 { 35 for (j=0;j<=17;j++) //j表示容量大小 36 { cout<<setw(3)<<a[i][j];} 37 cout<<endl; 38 } 39 40 //找出装入的物体，输出到x[] 41 i=5; 42 j=17; 43 while (i>=0&&j>=0) 44 { 45 if (a[i][j]==a[i-1][j]) 46 { 47 x[i]=0; 48 i--; 49 } 50 else 51 { 52 x[i]=1; 53 i--; 54 j=j-v[i]; 55 } 56 } 57 //输出x[] 58 cout<<endl; 59 for (int i=1;i<=5;i++) 60 cout<<x[i]<<" "; 61 62 return 0; 63 }