背包问题的应用——（0/1背包，完全背包，多重背包）

参考链接：http://blog.csdn.net/wzy_1988/article/details/12260343

多重背包问题：参考：http://blog.csdn.net/LYHVOYAGE/article/details/8545852

将多重背包问题转化为0/1背包问题：http://blog.csdn.net/kyriesnow/article/details/44256701

给出了5种多重背包的解决办法http://blog.csdn.net/QiaoRuoZhuo/article/details/76259876

前言

对于背包问题的初始化的说明：参考：https://github.com/tianyicui/pack/blob/master/V2.pdf

这个是一个17页的pdf文档，里面详细讲了背包9讲的内容，结合本篇博客看

我们看到的求最优解的背包问题题目中，事实上有两种不太相同的问法。有的题目要求“恰好装满背包”时的最优解，有的题目则并没有要求必须把背包装满。一种区别这两种问法的实现方法是在初始化的时候有所不同。

1）如果是第一种问法，要求恰好装满背包，那么在初始化时除了 F [0] 为 0 ，其它 F [1 ::V ] 均设为 -1 ，这样就可以保证最终得到的 F [ V ] 是一种恰好装满背包的最优解。

2）如果并没有要求必须把背包装满，而是只希望价格尽量大，初始化时应该将 F [0 ::V ] 全部设为 0 。

这是为什么呢？可以这样理解：初始化的 F 数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满，那么此时只有容量为 0 的背包可以在什么也不装且价值为 0 的情况下被“恰好装满”，其它容量的背包均没有合法的解，属于未定义的状态，应该被赋值为 -∞ 了。如果背包并非必须被装满，那么任何容量的背包都有一个合法解“什么都不装”，这个解的价值为 0 ，所以初始时状态的值也就全部为 0 了。

01背包

题目

有N件物品和一个容量为V的背包。第i建物品的费用是c[i],价值是w[i]。求解将哪些物品装入背包可使价值总和最大

思路

这是最基础的背包问题，特点是：每种物品只有一件，可以选择放或者不放

用子问题定义状态：即dp[i][j]表示前i件物品放入一个容量为j的背包可以获得的最大价值。则其状态转移方程为：

[cpp]  view plain  copy

1. dp[i][j] = max{dp[i - 1][j], dp[i - 1][j - c[i]] + w[i]}  

这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来。这里详细解释一下：

将前i件物品放入容量为j的背包中这个子问题，若只考虑第i件物品的策略（放或者不放），那么就可以转换为一个只牵扯前i-1件物品的问题。

• 如果不放第i件物品，那么问题就转换为前i-1件物品放入容量为j的背包中的最大价值，价值为dp[i - 1][j]
• 如果放入第i件物品，那么问题就转换为前i-1件物品放入容量为j-c[i]的背包中，此时能获得的最大价值是dp[i-1][j-c[i]],再加上放入第i件物品获得的价值w[i]

优化空间复杂度

先考虑一下上面的状态转移方程如何实现，肯定有一个主循环i = 1...N,每次算出来二维数组dp[i][0..V]的所有值。那么如果只用一个数组f[0...V],能不能保证第i次循环结束后f[v]就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1][v-c[i]]两个子问题递推而来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1][v-c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V...0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i-1][v-c[i]]的值。伪代码如下：

[cpp]  view plain  copy

1. for i  in 0 ... N  
2.     for  v = V ... 0  
3.         f[v] = max{f[v], f[v-c[i]] + w[i]}  

练习题目

题目： http://acm.hdu.edu.cn/showproblem.php?pid=2602

代码：

[cpp]  view plain  copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4.  #include<math.h>
5. #define N 1010  
6.   
7. int value[N], volume[N], dp[N];  
8.   
9. // 0-1背包，优化空间  
10. void dpPackage(int n, int v)  
11. {  
12.     int i, j;  
13.   
14.     memset(dp, 0, sizeof(dp));  
15.   
16.     for (i = 1; i <= n; i ++) {  
17.         for (j = v; j >= volume[i]; j --) //容量从大到小进行遍历，v表示背包的总容量，volume[i]表示第i个物品所占的空间
18.   {
19.    dp[j] =max(dp[j], dp[j - volume[i]] + value[i])  
20.          }  
21.     }  
22.   
23.     printf("%d\n", dp[v]);  
24. }  
25.   
26. int main(void)  
27. {  
28.     int i, t, n, v;  //t表示use_case的数量，n表示物品的总数,v表示背包容量
29.   
30.     scanf("%d", &t);  
31.   
32.     while (t --) {  
33.         // 接收参数  
34.         scanf("%d %d", &n, &v);  
35.   
36.         for (i = 1; i <= n; i ++)    scanf("%d", value + i);  
37.         for (i = 1; i <= n; i ++)    scanf("%d", volume + i);  
38.   
39.         // 0-1背包  
40.         dpPackage(n, v);  
41.     }  
42.   
43.     return 0;  
44. }  

完全背包问题

题目

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

思路

这个问题类似于01背包问题，所不同的是每种物品有无限件。也就是从每种物品的角度考虑，与它相关的策略 已非取或不取两种，而且右取0件、取1件、取2件...等很多种。如果仍然按照01背包的思路，令dp[i][v]表示前i种物品恰好放入一个容量为v的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程：

[html]  view plain  copy

1. dp[i][v] = max{dp[i-1][v - k * c[i]] + k * w[i] | 0 <= k * c[i]<= v}  

转化为01背包求解

最简单的想法是：考虑到第i种物品最多选V/c[i]件，于是可以把第i种物品转换为V/c[i]件费用及价值均不变的物品，然后求解这个01背包问题。但是这样完全没有改进时间复杂度，但这毕竟给了我们将完全背包转换为01背包问题的思路：将一种物品拆成多件物品

O(VN)的算法

这个算法使用一维数组，先看伪代码：

[cpp]  view plain  copy

1. for i = 1 ... N  //有的时候为了效率，可以将这两层循环进行互换
2.     for v = 0 ... V  
3.         f[v] = max{f[v], f[v-cost] + weight}  

你会发现，这个伪代码与01背包的伪代码只有v的循环次序不同而已。为什么这样一改就行呢？首先，想想为什么01背包问题中要按照v=V...0的逆序来循环。这是因为要保证第i次循环中的状态f[i][v]是由状态f[i-1][v-c[i]]递推而来。换句话说， 这正是为了保证每件物品只选一次，保证在考虑“选入第i件物品”这件策略时，依据的是一个肯定没有已经选入第i件物品的子结果f[i-1][v-c[i]]。而现在完全背包的特点恰好是每种物品可选无限件，所以在考虑“加选一件第i种物品”这种策略时，却正需要一个可能已选入第i种物品的子结果f[i][c-v[i]],所以就可以并且必须采用v=0...V的顺序循环

练习题目

题目链接： http://ac.jobdu.com/problem.php?pid=1454

代码：

[cpp]  view plain  copy

1. /** 
2.  * 完全背包问题 
3.  */  
4.   
5. #include <stdio.h>  
6. #include <stdlib.h>  
7.   
8. #define INF 50000000  
9.   
10. typedef struct coin {  
11.     int price, weight;  
12. } coin;  
13.   
14. void dynamicPackage(coin *coins, int n, int v)  
15. {  
16.     if (v < 0) {  
17.         printf("This is impossible.\n");  
18.         return;  
19.     }  
20.   
21.     int i, j, *dp;  
22.   
23.     // 动态分配内存  
24.     dp = (int *)malloc(sizeof(int) * (v + 1));  
25.   
26.     // 初始化  
27.     dp[0] = 0;  
28.     for (i = 1; i <= v; i ++)    dp[i] = INF;  
29.   
30.     // 完全背包问题  
31.     for (i = 1; i <= n; i ++) {  
32.         for (j = coins[i].weight; j <= v; j ++) //和0/1背包的区别，仅仅在于这层循环的顺序问题，0/1背包是逆序遍历，完全背包问题是顺序遍历
33. {  
34. //f[v] = max{f[v], f[v-cost] + weight} 
35.             dp[j] = (dp[j] < dp[j - coins[i].weight] + coins[i].price) ? dp[j] : dp[j - coins[i].weight] + coins[i].price;  
36.         }  
37.     }  
38.   
39.     if (dp[v] >= INF)  
40.         printf("This is impossible.\n");  
41.     else  
42.         printf("The minimum amount of money in the piggy-bank is %d.\n", dp[v]);  
43.   
44.   
45.     // 清理内存  
46.     free(dp);  
47.     dp = NULL;  
48. }  
49.   
50.   
51. int main(void)  
52. {  
53.     int t, e, f, n, i;  
54.     coin *coins;  
55.   
56.     scanf("%d", &t);  
57.   
58.     while (t --) {  
59.         scanf("%d %d", &e, &f);  
60.         scanf("%d", &n);  
61.   
62.         // 接收货币  
63.         coins = (coin *)malloc(sizeof(coin) * (n + 1));  
64.         if (coins == NULL)  exit(-1);  
65.   
66.         for (i = 1; i <= n; i ++) {  
67.             scanf("%d %d", &coins[i].price, &coins[i].weight);  
68.         }  
69.   
70.         // 完全背包  
71.         dynamicPackage(coins, n, f - e);  
72.   
73.   
74.         free(coins);  
75.         coins = NULL;     
76.     }     
77.   
78.     return 0;  
79. }  

多重背包问题

         多重背包问题要求很简单，就是每件物品给出确定的件数，求 可得到的最大价值  
         多重背包转换成 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 以内所有的数都考虑到了，基于这种思想去把多件物品转换为，多种一件物品，就可用0/1 背包求解了。  

------------------------------------------------------------------------------------

以下为程序流程：
void MultiplePack(int w, int p, int m)
{
if (w * m >= p)
{
CompletePack(w, p);
return;
}
int k = 1;
while (k < m)
{
ZeroOnePack(k * w, k * p);
m -= k;
k *= 2;
}
ZeroOnePack(m * w, m * p);

}

下面附上多重背包的模板：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <algorithm>  
3. using namespace std;  
4. #define MAXL 10001  
5.   
6. int dp[MAXL], V, n, w, p, m;  
7.   
8. void ZeroOnePack(int w, int p);  
9. void CompletePack(int w, int p);  
10. void MultiplePack(int w, int p, int m);  
11.   
12. int main()  
13. {  
14.     cin >> V >> n;  //输入总的空间V，以及总的物品种类n
15.     for (int i = 1; i <= n; i++)  //n表示物品种类的数量num
16.     {  
17.         cin >> w >> p >> m;  
18.         MultiplePack(w, p, m);  
19.     }  
20.     cout << dp[V] << endl;  
21.     return 0;  
22. }  
23.   
24. void MultiplePack(int w, int p, int m)  
25. {  
26.     if (w * m >= p)  
27.     {  
28.         CompletePack(w, p);  
29.         return;  
30.     }  
31.     int k = 1;  
32.     while (k < m)  
33.     {  
34.         ZeroOnePack(k * w, k * p);  
35.         m -= k;  
36.         k *= 2;  
37.     }  
38.     ZeroOnePack(m * w, m * p);  
39. }  
40.   
41. void ZeroOnePack(int w, int p)  
42. {  
43.     for (int j = V; j >= w; j--)  
44.         dp[j] = max(dp[j - w] + p, dp[j]);  
45. }  
46.   
47. void CompletePack(int w, int p)  
48. {  
49.     for (int j = w; j <= V; j++)  
50.         dp[j] = max(dp[j - w] + p, dp[j]);  
51. }  

--------------------------------------------------------------------------------

       看代码：  
      

[cpp]  view plain  copy

1. int n;  //输入有多少种物品  
2. int c;  //每种物品有多少件  
3. int v;  //每种物品的价值  
4. int s;  //每种物品的尺寸  
5. int count = 0; //分解后可得到多少种物品  
6. int value[MAX]; //用来保存分解后的物品价值  
7. int size[MAX];  //用来保存分解后物品体积  
8.   
9. scanf("%d", &n);    //先输入有多少种物品，接下来对每种物品进行分解  
10.   
11. while (n--)     //接下来输入n中这个物品  
12. {  
13.     scanf("%d%d%d", &c, &s, &v);  //输入每种物品的数目和价值  
14.     for (int k=1; k<=c; k*=2)   //<<左移 相当于乘二  
15.     {  
16.         value[count] = k*v;  
17.         size[count++] = k*s;  
18.         c -= k;  
19.     }  
20.     if (c > 0)  
21.     {  
22.         value[count] = c*v;  
23.         size[count++] = c*s;  
24.     }  
25. }  

定理：一个正整数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题解：

此为多重背包<====>用0/1背包+完全背包：

[cpp]  view plain  copy

1. #include<stdio.h>  
2. #include<string.h>  
3. int dp[102];  
4. int p[102],h[102],c[102];  //p[]表示，h[],c[]表示每个物品最多可以使用个数
5. int n,m;  
6. void comback(int v,int w)//经费，重量。完全背包；  
7. {  
8.     for(int i=v; i<=n; i++)  
9.         if(dp[i]<dp[i-v]+w)  
10.             dp[i]=dp[i-v]+w;  
11. }  
12. void oneback(int v,int w)//经费，重量；01背包；  
13. {  
14.     for(int i=n; i>=v; i--)  
15.         if(dp[i]<dp[i-v]+w)  
16.             dp[i]=dp[i-v]+w;  
17. }  
18. int main()  
19. {  
20.     int ncase,i,j,k;  
21.     scanf("%d",&ncase);  
22.     while(ncase--)  
23.     {  
24.         memset(dp,0,sizeof(dp));  
25.         scanf("%d%d",&n,&m);//经费，种类；  
26.         for(i=1; i<=m; i++)  
27.         {  
28.             scanf("%d%d%d",&p[i],&h[i],&c[i]);//每个物品的价值，每个物品的重量，每个物品最多使用的数量;  
29.             if(p[i]*c[i]>=n)//c[i]的数量足够多，完全可以满足经费限制，那么就转化为完全背包问题（不限制每种物品的数量）
30.     comback(p[i],h[i]); //完全背包问题 
31.             else  //c[i]数量有限，需要进行二进制拆分，然后转化为0/1背包问题
32.             {  
33.                 for(j=1; j<c[i]; j*=2)  //进行二进制拆分，c[i]表示每种物品最大可用个数
34.                 {  
35.                     oneback(j*p[i],j*h[i]);  
36.                     c[i]=c[i]-j;  
37.                 }  
38.                 oneback(p[i]*c[i],h[i]*c[i]);  //因为上面是j<c[i],因此还需要用c[i]替换j，即j*p[i]===>c[i]*p[i]
39.             }  
40.         }  
41.         printf("%d\n",dp[n]);  
42.     }  
43.     return 0;  
44. }  

只是用01背包，用二进制优化：

[cpp]  view plain  copy

1. #include <iostream>  
2. using namespace std;  
3. int main()  
4. {  
5.     int nCase,Limit,nKind,i,j,k,  v[111],w[111],c[111],dp[111];  
6.     //v[]存价值，w[]存尺寸，c[]存件数  
7.     //在本题中，价值是米的重量，尺寸是米的价格  
8.     int count,Value[1111],size[1111];  
9.     //count存储分解完后的物品总数  
10.     //Value存储分解完后每件物品的价值  
11.     //size存储分解完后每件物品的尺寸  
12.     cin>>nCase;  
13.     while(nCase--)  
14.     {  
15.         count=0;  
16.         cin>>Limit>>nKind;  
17.         for(i=0; i<nKind; i++)  
18.         {  
19.             cin>>w[i]>>v[i]>>c[i];  
20.             //对该种类的c[i]件物品进行二进制分解  
21.             for(j=1; j<=c[i]; j<<=1)  
22.             {  
23.                 //<<左移1位，相当于乘2  
24.                 Value[count]=j*v[i];  
25.                 size[count++]=j*w[i];  
26.                 c[i]-=j;  
27.             }  
28.             if(c[i]>0)  
29.             {  
30.                 Value[count]=c[i]*v[i];  
31.                 size[count++]=c[i]*w[i];  
32.             }  
33.         }  
34.         //经过上面对每一种物品的分解，  
35.         //现在Value[]存的就是分解后的物品价值  
36.         //size[]存的就是分解后的物品尺寸  
37.         //count就相当于原来的n  
38.         //下面就直接用01背包算法来解  
39.         memset(dp,0,sizeof(dp));  
40.         for(i=0; i<count; i++)  
41.             for(j=Limit; j>=size[i]; j--)  
42.                 if(dp[j]<dp[j-size[i]]+Value[i])  
43.                     dp[j]=dp[j-size[i]]+Value[i];  
44.   
45.         cout<<dp[Limit]<<endl;  
46.     }  
47.     return 0;  
48. }  

未优化的：

[cpp]  view plain  copy

1. #include<iostream>  
2. #include<cstdio>  
3. #include<cstring>  
4. using namespace std;  
5.   
6. int Value[105];  
7. int Cost[105];  
8. int Bag[105];  
9. int dp[105];  
10.   
11. int main()  
12. {  
13.     int C,m,n;  
14.     scanf("%d",&C);  
15.     while(C--)  
16.     {  
17.         scanf("%d%d",&n,&m);  
18.         for(int i = 1; i <= m; i++)  
19.             scanf("%d%d%d",&Cost[i],&Value[i],&Bag[i]);  
20.         memset(dp,0,sizeof(dp));  
21.         for(int i=1; i<= m; i++)  
22.             for(int j=1; j<=Bag[i]; j++)  
23.                 for(int k=n; k>=Cost[i]; k--)  
24.                     dp[k]=max(dp[k], dp[k-Cost[i]]+Value[i]);  
25.         printf("%d\n",dp[n]);  
26.     }  
27.     return 0;  
28. }  

----------------------------------------------------------------------------------------------------------

未优化的多重背包问题：时间复杂度O(N^3)

容量为10的背包，有5种物品，每种物品数量分别为1，2，1，2，1，其重量分别为5，4，3，2，1，其价值分别为1，2，3，4，5。 
设计算法，实现背包内物品价值最大。 
代码如下（输出16）

#include <iostream>
#include<algorithm>

using namespace std;

int main()
{
    int total_weight = 10;
    int w[6] = { 0,5,4,3,2,1 };
    int v[6] = { 0,1,2,3,4,5 };
    int cot[6] = { 0,1,2,1,2,1 };
    int dp[11] = { 0 };

    for (int i = 1; i <= 5; i++)
        for (int k = 1; k <= cot[i];k++)
            for (int j = 10; j >= w[i]; j--)
                dp[j] = max(dp[j], dp[j - w[i]] + v[i]);

    cout << "总的价值为: " << dp[10] << endl;
    return 0;
}

后记

主要还是为了巩固01背包问题并且多做点题目，所以记录了一下学习《背包九讲》的过程，大家真想搞清楚背包问题，建议还是参考原文链接： http://love-oriented.com/pack/