01背包问题

http://blog.csdn.net/jiahui524/article/details/6656342

问题描述：

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

 

问题特点：每种物品仅有一件，可以选择放或不放。（0：不放  1：放）

 

基本思路：

这是最基础的背包问题，用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]} 。 可以压缩空间，f[v]=max{f[v],f[v-c[i]]+w[i]} 　　这个方程非常重要，基本上所有跟背包相关的问题的方程都是由它衍生出来的。所以有必要将它详细解释一下：“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值为f[i-1][v]；如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，此时能获得的最大价值就是f [i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。

注意f[v]有意义当且仅当存在一个前i件物品的子集，其费用总和为v。所以按照这个方程递推完毕后，最终的答案并不一定是f[N] [V]，而是f[N][0..V]的最大值。如果将状态的定义中的“恰”字去掉，在转移方程中就要再加入一项f[v-1]，这样就可以保证f[N] [V]就是最后的答案。至于为什么这样就可以，由你自己来体会了。

 

代码实现：

 

[cpp] view plaincopyprint?

1.    
2.   
3. #include<stdio.h>  
4.   
5. #include<string.h>  
6.   
7. #define MINUSINF 0x80000000  
8.   
9. #define MAXN 100  
10.   
11. #define MAXV 1000  
12.   
13.    
14.   
15. int max(int a,int b)  
16.   
17. {  
18.   
19.     return a>b?a:b;  
20.   
21. }   
22.   
23. //n件物品和一个容量为v的背包。第i件物品的费用是c[i]，价值是w[i]，装满与否要求为full  
24.   
25. //算法1：经典DP二维数组解法，时间复杂度及空间复杂度均为O(nv)   
26.   
27. int ZeroOnePack1(int n,int v,int c[],int w[],int full)  
28.   
29. {  
30.   
31.     int i,j;  
32.   
33.     int f[MAXN][MAXV];  
34.   
35.     if(full){  
36.   
37.         for(i=0;i<=n;i++)  
38.   
39.             for(j=0;j<=v;j++)   
40.   
41.                 f[i][j]=MINUSINF;  
42.   
43.         f[0][0]=0;  
44.   
45.     }   
46.   
47.     else {  
48.   
49.               memset(f,0,sizeof(f));  
50.   
51.        }  
52.   
53.     for(i=1;i<=n;i++){  
54.   
55.         for(j=0;j<=v;j++){  
56.   
57.             if(j>=c[i])  
58.   
59.                 f[i][j]=max(f[i-1][j],f[i-1][j-c[i]]+w[i]);  
60.   
61.             else f[i][j]=f[i-1][j];  
62.   
63.         }  
64.   
65.     }  
66.   
67.     if(f[n][v]<0) return -1;  
68.   
69.     else return f[n][v];  
70.   
71. }  
72.   
73.    
74.   
75. //算法2：算法1的一维数组解法，时间复杂度为O(nv)，空间复杂度为O(v)  
76.   
77. int ZeroOnePack2(int n,int v,int c[],int w[],int full){  
78.   
79.     int i,j;  
80.   
81.     int f[MAXV];  
82.   
83.     if(full){  
84.   
85.         f[0]=0;  
86.   
87.         for(i=1;i<=v;i++)   
88.   
89.             f[i]=MINUSINF;  
90.   
91.     }  
92.   
93.     else{  
94.   
95.               memset(f,0,sizeof(f));  
96.   
97.        }  
98.   
99.     for(i=1;i<=n;i++){  
100.   
101.         for(j=v;j>=0;j--){  
102.   
103.             if(j>=c[i])  
104.   
105.                 f[j]=max(f[j],f[j-c[i]]+w[i]);  
106.   
107.         }  
108.   
109.     }  
110.   
111.     if(f[v]<0) return -1;  
112.   
113.     else return f[v];  
114.   
115. }  
116.   
117. //算法3：算法2的优化，去掉了无必要的判断，时间复杂度为O(nv)，空间复杂度为O(v)  
118.   
119. int ZeroOnePack3(int n,int v,int c[],int w[],int full){  
120.   
121.     int i,j;  
122.   
123.     int f[MAXV];  
124.   
125.     if(full){  
126.   
127.         f[0]=0;  
128.   
129.         for(i=1;i<=v;i++)   
130.   
131.             f[i]=MINUSINF;  
132.   
133.     }  
134.   
135.     else {  
136.   
137.               memset(f,0,sizeof(f));  
138.   
139.        }  
140.   
141.     for(i=1;i<=n;i++){  
142.   
143.         for(j=v;j>=c[i];j--){  
144.   
145.             f[j]=max(f[j],f[j-c[i]]+w[i]);  
146.   
147.         }  
148.   
149.     }  
150.   
151.     if(f[v]<0) return -1;  
152.   
153.     else return f[v];  
154.   
155. }  
156.   
157.    
158.   
159. //算法4：算法3的常数优化，在v较大时优势明显，时间复杂度为O(nv)，空间复杂度为O(v)  
160.   
161. int ZeroOnePack4(int n,int v,int c[],int w[],int full)  
162.   
163. {  
164.   
165.     int i,j,sum=0,bound;  
166.   
167.     int f[MAXV];  
168.   
169.     if(full)  
170.   
171.     {  
172.   
173.         f[0]=0;  
174.   
175.         for(i=1;i<=v;i++)   
176.   
177.             f[i]=MINUSINF;  
178.   
179.     }  
180.   
181.     else memset(f,0,sizeof(f));  
182.   
183.     for(i=1;i<=n;i++) sum+=w[i];  
184.   
185.     for(i=1;i<=n;i++)  
186.   
187.     {  
188.   
189.         if(i>1) sum-=w[i-1];  
190.   
191.         bound=max(v-sum,c[i]);  
192.   
193.         for(j=v;j>=bound;j--)  
194.   
195.         {  
196.   
197.             f[j]=max(f[j],f[j-c[i]]+w[i]);  
198.   
199.         }  
200.   
201.     }  
202.   
203.     if(f[v]<0) return -1;  
204.   
205.     else return f[v];  
206.   
207. }  
208.   
209.    
210.   
211. int main(){  
212.   
213.     int i,j;  
214.   
215.     int n,v,c[MAXN],w[MAXN];  
216.   
217.     while(scanf("%d %d",&n,&v)!=EOF){  
218.   
219.         for(i=1;i<=n;i++) {  
220.   
221.                      scanf("%d %d",&c[i],&w[i]);  
222.   
223.               }  
224.   
225.         printf("%d\n",ZeroOnePack1(n,v,c,w,0));  
226.   
227.     }  
228.   
229.     return 0;  
230.   
231. }