0022算法笔记——【贪心算法】背包问题,最优装载问题

 1、背包问题

     (1)0-1背包问题：给定n种物品和一个背包。物品i的重量是Wi，其价值为Vi，背包的容量为C。应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
     注：在选择装入背包的物品时，对每种物品i只有2种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。

      0-1背包问题可用动态规划算法来求解，具体过程可参看笔者博文《0019算法笔记——0-1背包问题动态规划求解》。

     (2)背包问题：与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，1≤i≤n。
     这2类问题都具有最优子结构性质，极为相似，但背包问题可以用贪心算法求解，而0-1背包问题却不能用贪心算法求解。用贪心算法解背包问题的基本步骤是，首先计算每种物品单位重量的价值Vi/Wi，然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后，背包内的物品总重量未超过C，则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去，直到背包装满为止。

     具体代码如下：

[cpp]  view plain

1. //4d2 贪心算法 背包问题  
2. #include "stdafx.h"  
3. #include <iostream>   
4. using namespace std;   
5.   
6. const int N = 3;  
7.   
8. void Knapsack(int n,float M,float v[],float w[],float x[]);  
9.   
10. int main()  
11. {  
12.     float M = 50;//背包所能容纳的重量  
13.     //这里给定的物品按单位价值减序排序  
14.     float w[] = {0,10,20,30};//下标从1开始  
15.     float v[] = {0,60,100,120};  
16.   
17.     float x[N+1];  
18.   
19.     cout<<"背包所能容纳的重量为："<<M<<endl;  
20.     cout<<"待装物品的重量和价值分别为："<<endl;  
21.     for(int i=1; i<=N; i++)  
22.     {  
23.         cout<<"["<<i<<"]:("<<w[i]<<","<<v[i]<<")"<<endl;  
24.     }  
25.       
26.     Knapsack(N,M,v,w,x);  
27.   
28.     cout<<"选择装下的物品比例如下："<<endl;  
29.     for(int i=1; i<=N; i++)  
30.     {  
31.         cout<<"["<<i<<"]:"<<x[i]<<endl;  
32.     }  
33.   
34.     return 0;  
35. }  
36.   
37. void Knapsack(int n,float M,float v[],float w[],float x[])  
38. {  
39.     //Sort(n,v,w);//这里假定w[],v[]已按要求排好序  
40.     int i;  
41.     for (i=1;i<=n;i++)  
42.     {  
43.         x[i]=0;//初始化数组x[]  
44.     }  
45.   
46.     float c=M;  
47.     for (i=1;i<=n;i++)//物品整件被装下,x[i]=1  
48.     {  
49.         if (w[i]>c)  
50.         {  
51.             break;  
52.         }  
53.         x[i]=1;  
54.         c-=w[i];  
55.     }  
56.   
57.     //物品i只有部分被装下  
58.     if (i<=n)  
59.     {  
60.         x[i]=c/w[i];  
61.     }  
62. }  

     程序运行结果为：

     算法knapsack的主要计算时间在于将各种物品依其单位重量的价值从大到小排序。因此，算法的计算时间上界为O(nlogn)。为了证明算法的正确性，还必须证明背包问题具有贪心选择性质。这种贪心选择策略对0-1 背包问题就不适用了。看下图例子，其中有3中物品，背包的容量为50千克。物品1重10千克；价值60元；物品2重20千克；价值100元；物品3重30千克，价值120元。因此，物品1每千克价值6元，物品2每千克价值5元，物品3每千克价值4元。若依贪心选择策略，应首先选择物品1装入背包，然而从图b中各种情况可以看出，最优的选择方案是选择物品2和物品3装入背包。首选物品1的两种方案都不是最优的。对于背包问题，贪心选择最终可得到最优解，其选择方案如图c所示。

     对于0-1背包问题，贪心选择之所以不能得到最优解是因为在这种情况下，它无法保证最终能将背包装满，部分闲置的背包空间使每公斤背包空间的价值降低了。事实上，在考虑0-1背包问题时，应比较选择该物品和不选择该物品所导致的最终方案，然后再作出最好选择。由此就导出许多互相重叠的子问题。这正是该问题可用动态规划算法求解的另一重要特征。

     2、最优装载问题

    问题描述：有一批集装箱要装上一艘载重量为c的轮船。其中集装箱i的重量为Wi。最优装载问题要求确定在装载体积不受限制的情况下，将尽可能多的集装箱装上轮船。

    最优子结构性质：设(x1,x2,……xn)是最优装载问题的满足贪心选择性质的最优解，则易知，x1=1,(x2,x3,……xn)是轮船载重量为c-w1，待装船集装箱为{2,3，……n}时相应最优装载问题的最优解。因此，最优装载问题具有最优子结构性质。

    求解过程：最优装载问题可用贪心算法求解。采用重量最轻者先装的贪心选择策略，可产生最优装载问题的最优解。具体代码如下：

[cpp]  view plain

1. //4d3 贪心算法 最优装载问题  
2. #include "stdafx.h"  
3. #include <iostream>   
4. using namespace std;   
5.   
6. const int N = 4;  
7.   
8. template <class Type>    
9. void Swap(Type &x,Type &y);   
10.   
11. template<class Type>  
12. void Loading(int x[],  Type w[], Type c, int n);  
13.   
14. template<class Type>  
15. void SelectSort(Type w[],int *t,int n);  
16.   
17. int main()  
18. {  
19.     float c = 70;  
20.     float w[] = {0,20,10,26,15};//下标从1开始  
21.     int x[N+1];  
22.   
23.     cout<<"轮船载重为："<<c<<endl;  
24.     cout<<"待装物品的重量分别为："<<endl;  
25.     for(int i=1; i<=N; i++)  
26.     {  
27.         cout<<w[i]<<" ";  
28.     }  
29.     cout<<endl;  
30.     Loading(x,w,c,N);  
31.   
32.     cout<<"贪心选择结果为:"<<endl;  
33.     for(int i=1; i<=N; i++)  
34.     {  
35.         cout<<x[i]<<" ";  
36.     }  
37.     cout<<endl;  
38.   
39.     return 0;  
40. }  
41.   
42. template<class Type>  
43. void Loading(int x[],Type w[], Type c, int n)  
44. {  
45.     int *t = new int [n+1];//存储排完序后w[]的原始索引  
46.     SelectSort(w, t, n);  
47.   
48.     for(int i=1; i<=n; i++)  
49.     {  
50.         x[i] = 0;//初始化数组x[]  
51.     }  
52.     for(int i=1; i<=n && w[t[i]]<=c; i++)  
53.     {  
54.         x[t[i]] = 1;  
55.         c -= w[t[i]];  
56.     }  
57. }  
58.   
59. template<class Type>  
60. void SelectSort(Type w[],int *t,int n)  
61. {  
62.     Type tempArray[N+1],temp;  
63.     memcpy(tempArray,w,(n+1)*sizeof(Type));//将w拷贝到临时数组tempArray中  
64.     int min;  
65.   
66.     for(int i=1;i<=n;i++)  
67.     {  
68.         t[i] = i;  
69.     }  
70.   
71.     for(int i=1;i<n;i++)  
72.     {  
73.         min=i;  
74.         for(int j=i+1;j<=n;j++)  
75.         {  
76.             if(tempArray[min]>tempArray[j])  
77.             {  
78.                 min=j;  
79.             }  
80.         }  
81.         Swap(tempArray[i],tempArray[min]);  
82.         Swap(t[i],t[min]);  
83.     }  
84. }  
85.   
86. template <class Type>    
87. void Swap(Type &x,Type &y)  
88. {  
89.     Type temp = x;    
90.     x = y;    
91.     y = temp;    
92. }  

     算法loading的主要计算量在于将集装箱依其重量从小到大排序，故算法所需的计算时间为 O(nlogn)。运行结果如下：