完全背包总结

转自：点击打开链接

完全背包问题:

题目 有N种物品和一个容量为V的背包。第i种物品有若干件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本思路:

 这个问题和我们刚解决的01背包问题很像,不同的是该问题中的物品每一件有若干件,而01背包中的每一件物品只有一件.

动态规划（DP）：

        1） 子问题定义：F[i][j]表示前i种物品中选取若干件物品放入剩余空间为j的背包中所能得到的最大价值。

        2） 根据第i种物品放多少件进行决策,我们可以将该问题转化为01背包问题求解，对于特定的容量,每一件物品最多放V/C[i]件，然后按照01背包dp

                        

[cpp]  view plain  copy

1. dp[i][j]=max(dp[i][j],dp[i-1][j-k*need[i]]+k*value[i]);  

      (2-1)

        其中F[i-1][j-K*C[i]]+K*W[i]表示前i-1种物品中选取若干件物品放入剩余空间为j-K*C[i]的背包中所能得到的最大价值加上k件第i种物品；

       设物品种数为N，背包容量为V，第i种物品体积为C[i]，第i种物品价值为W[i]。

       与01背包相同，完全背包也需要求出NV个状态F[i][j]。但是完全背包求F[i][j]时需要对k分别取0,…，j/C[i]求最大F[i][j]值,耗时为j/C[i]。那么总的时间复

杂度为O(NV∑(j/C[i]))

[cpp]  view plain  copy

1. #include<bits/stdc++.h>  
2. using namespace std;   
3. const int maxn=555;  
4. int dp[maxn][111111];  
5. int need[maxn],value[maxn];  
6. int n,m;  
7. int main()  
8. {  
9.     int i,j,k;  
10.     while(~scanf("%d %d",&n,&m))  
11.     {  
12.         memset(dp,0,sizeof(dp));  
13.         for(i=1;i<=n;i++)  
14.             scanf("%d %d",&need[i],&value[i]);   
15.         for(i=1;i<=n;i++)  
16.         {  
17.             for(j=0;j<=m;j++)  
18.             {  
19.                 for(k=0;k*need[i]<=j;k++)      
20.                     dp[i][j]=max(dp[i][j],dp[i-1][j-k*need[i]]+k*value[i]);  
21.             }  
22.         }  
23.         printf("%d\n",dp[n][m]);  
24.     }  
25.     return 0;  
26. }  

[cpp]  view plain  copy

1. <span style="white-space:pre;"> </span>  

  简单优化：

        若两件物品满足C[i] ≤C[j]&&W[i] ≥W[j]时将第j种物品直接筛选掉。因为第i种物品比第j种物品物美价廉，用i替换j得到至少不会更差的方案。

       这个筛选过程如下：先找出体积大于背包的物品直接筛掉一部分（也可能一种都筛不掉）复杂度O(N)。利用计数排序思想对剩下的物品体积进行

排序，同时筛选出同体积且价值最大的物品留下，其余的都筛掉（这也可能一件都筛不掉）复杂度O(V)。整个过程时间复杂度为O(N+V)

 

       转化为01背包：

       因为同种物品可以多次选取，那么第i种物品最多可以选取V/C[i]件价值不变的物品，然后就转化为01背包问题。整个过程的时间复杂度并未减少。

如果把第i种物品拆成体积为C[i]×2^k价值W[i]×2^k的物品，其中满足C[i]×2^k≤V。那么在求状态F[i][j]时复杂度就变为O(log₂(V/C[i]))。整个时间复杂度就

变为O(NVlog₂(V/C[i]))

时间复杂度优化为O(NV)

将原始算法的DP思想转变一下。

设F[i][j]表示出在前i种物品中选取若干件物品放入容量为j的背包所得的最大价值。那么对于第i种物品的出现，我们对第i种物品放不放入背包

进行决策。如果不放那么F[i][j]=F[i-1][j]；如果确定放，背包中应该出现至少一件第i种物品，所以F[i][j]种至少应该出现一件第i种物品,

即F[i][j]=F[i][j-C[i]]+W[i]。为什么会是F[i][j-C[i]]+W[i]？因为我们前面已经最大限度的放了第i件物品,如果能放就放这最后的一件,

（或者理解为前面已经往背包中放入了第i件物品，我们每一次只增加一件的往背包里放,而且只能增加一件,多了放不下）

举个例子:

比方有重量为2的物品, dp[i][2]的时候放了一件了,当dp[i][4]的时候,dp[i][4]=max(dp[i-1][4],dp[i][4-2]+w[i]) 最多一件了

状态方程为：

                           (2-2)

[cpp]  view plain  copy

1. #include<bits/stdc++.h>  
2. using namespace std;   
3. const int maxn=555;  
4. int dp[maxn][111111];  
5. int need[maxn],value[maxn];  
6. int n,m;  
7. int main()  
8. {  
9.     int i,j,k;  
10.     while(~scanf("%d %d",&n,&m))  
11.     {  
12.         memset(dp,0,sizeof(dp));  
13.         for(i=1;i<=n;i++)  
14.             scanf("%d %d",&need[i],&value[i]);   
15.         for(i=1;i<=n;i++)  
16.         {  
17.             for(j=0;j<=m;j++)  
18.             {  
19.                 if(j>=need[i])  
20.                 dp[i][j]=max(dp[i-1][j],dp[i][j-need[i]]+value[i]);//注意和01背包的区别,这里是dp[i][j-need[i]]+value[i]  
21.                 else  
22.                 dp[i][j]=dp[i-1][j];  
23.             }  
24.         }  
25.         printf("%d\n",dp[n][m]);  
26.     }  
27.     return 0;}  

优化空间复杂度为O（V）

        和01背包问题一样，完全背包也可以用一维数组来保存数据。算法样式和01背包的很相似，唯一不同的是对V遍历时变为正序，而01背包为逆序

。01背包中逆序是因为F[i][]只和F[i-1][]有关，且第i件的物品加入不会对F[i-1][]状态造成影响。而完全背包则考虑的是第i种物品的出现的问题，

第i种物品一旦出现它势必应该对第i种物品还没出现的各状态造成影响。也就是说，原来没有第i种物品的情况下可能有一个最优解，现在第i种物品

出现了，而它的加入有可能得到更优解，所以之前的状态需要进行改变，故需要正序。

[cpp]  view plain  copy

1. #include<bits/stdc++.h>  
2. using namespace std;   
3. const int maxn=555;  
4. int dp[111111];  
5. int need[maxn],value[maxn];  
6. int n,m;  
7. int main()  
8. {  
9.     int i,j,k;  
10.     while(~scanf("%d %d",&n,&m))  
11.     {  
12.         memset(dp,0,sizeof(dp));  
13.         for(i=1;i<=n;i++)  
14.             scanf("%d %d",&need[i],&value[i]);   
15.         for(i=1;i<=n;i++)  
16.         {  
17.             for(j=need[i];j<=m;j++)  
18.             {  
19.                 if(j>=need[i])  
20.                   dp[j]=max(dp[j],dp[j-need[i]]+value[i]);  
21.                 }  
22.         }  
23.         printf("%d\n",dp[m]);  
24.     }  
25.     return 0;  
26. }  

感谢！http://blog.csdn.net/wumuzi520/article/details/7014830