《ACM算法详解》— 贪心算法详解

                                         贪心算法

一、基本概念：

 

     所谓贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。必须注意的是，贪心算法不是对所有问题都能得到整体最优解，选择的贪心策略必须具备无后效性，即某个状态以后的过程不会影响以前的状态，只与当前状态有关。所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。

 

二、贪心算法的基本思路：

 

    1.建立数学模型来描述问题。

    2.把求解的问题分成若干个子问题。

    3.对每一子问题求解，得到子问题的局部最优解。

    4.把子问题的解局部最优解合成原来解问题的一个解。

 

三、贪心算法适用的问题

 

      贪心策略适用的前提是：局部最优策略能导致产生全局最优解。

    实际上，贪心算法适用的情况很少。一般，对一个问题分析是否适用于贪心算法，可以先选择该问题下的几个实际数据进行分析，就可做出判断。

 

四、贪心算法的实现框架

 

    从问题的某一初始解出发；

    while （能朝给定总目标前进一步）

    { 

          利用可行的决策，求出可行解的一个解元素；

    }

    由所有解元素组合成问题的一个可行解；

  

五、贪心策略的选择

       

贪心算法的基本要素

贪心选择性质

         所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。对于一个具体的问题，要确定它是否具有贪心性质，我们必须证明每一步所作的贪心选择最终导致问题的一个整体最优解。

 最优子结构性质

         当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用动态规划算法或贪心算法求解的关键特征。

 

     因为用贪心算法只能通过解局部最优解的策略来达到全局最优解，因此，一定要注意判断问题是否适合采用贪心算法策略，找到的解是否一定是问题的最优解。

 

六、例题分析

1.活动选择问题
 这是《算法导论》上的例子，也是一个非常经典的问题。有n个需要在同一天使用同一个教室的活动a1,a2,…,an，教室同一时刻只能由一个活动使用。每个活动ai都有一个开始时间si和结束时间fi 。一旦被选择后，活动ai就占据半开时间区间[si,fi)。如果[si,fi]和[sj,fj]互不重叠，ai和aj两个活动就可以被安排在这一天。该问题就是要安排这些活动使得尽量多的活动能不冲突的举行。例如下图所示的活动集合S，其中各项活动按照结束时间单调递增排序。

考虑使用贪心算法的解法。为了方便，我们用不同颜色的线条代表每个活动，线条的长度就是活动所占据的时间段，蓝色的线条表示我们已经选择的活动；红色的线条表示我们没有选择的活动。
如果我们每次都选择开始时间最早的活动，不能得到最优解：

如果我们每次都选择持续时间最短的活动，不能得到最优解：

可以用数学归纳法证明，我们的贪心策略应该是每次选取结束时间最早的活动。直观上也很好理解，按这种方法选择相容活动为未安排活动留下尽可能多的时间。这也是把各项活动按照结束时间单调递增排序的原因。

[cpp] view plain copy

1. #include<cstdio>  
2. #include<iostream>   
3. #include<algorithm>   
4. using namespace std;      
5. int N;  
6. struct Act  
7. {  
8.     int start;  
9.     int end;  
10. }act[100010];  
11.   
12. bool cmp(Act a,Act b)    
13. {    
14.     return a.end<b.end;    
15. }   
16.   
17. int greedy_activity_selector()    
18. {    
19.     int num=1,i=1;     
20.     for(int j=2;j<=N;j++)    
21.     {    
22.         if(act[j].start>=act[i].end)    
23.         {    
24.             i=j;    
25.             num++;    
26.         }    
27.     }    
28.     return num;  
29. }  
30.   
31. int main()    
32. {    
33.     int t;  
34.     scanf("%d",&t);  
35.     while(t--)  
36.     {  
37.         scanf("%d",&N);  
38.         for(int i=1;i<=N;i++)  
39.         {  
40.             scanf("%lld %lld",&act[i].start,&act[i].end);  
41.         }  
42.         act[0].start=-1;  
43.         act[0].end=-1;  
44.         sort(act+1,act+N+1,cmp);   
45.         int res=greedy_activity_selector();  
46.         cout<<res<<endl;    
47.     }  
48. }    

2.钱币找零问题
这个问题在我们的日常生活中就更加普遍了。假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0, c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K元，至少要用多少张纸币？用贪心算法的思想，很显然，每一步尽可能用面值大的纸币即可。在日常生活中我们自然而然也是这么做的。在程序中已经事先将Value按照从小到大的顺序排好。

[cpp] view plain copy

1. #include<iostream>  
2. #include<algorithm>  
3. using namespace std;  
4. const int N=7;   
5. int Count[N]={3,0,2,1,0,3,5};  
6. int Value[N]={1,2,5,10,20,50,100};  
7.     
8. int solve(int money)   
9. {  
10.     int num=0;  
11.     for(int i=N-1;i>=0;i--)   
12.     {  
13.         int c=min(money/Value[i],Count[i]);  
14.         money=money-c*Value[i];  
15.         num+=c;  
16.     }  
17.     if(money>0) num=-1;  
18.     return num;  
19. }  
20.    
21. int main()   
22. {  
23.     int money;  
24.     cin>>money;  
25.     int res=solve(money);  
26.     if(res!=-1) cout<<res<<endl;  
27.     else cout<<"NO"<<endl;  
28. }  

3.再论背包问题
在从零开始学动态规划中我们已经谈过三种最基本的背包问题：零一背包，部分背包，完全背包。很容易证明，背包问题不能使用贪心算法。然而我们考虑这样一种背包问题：在选择物品i装入背包时，可以选择物品的一部分，而不一定要全部装入背包。这时便可以使用贪心算法求解了。计算每种物品的单位重量价值作为贪心选择的依据指标，选择单位重量价值最高的物品，将尽可能多的该物品装入背包，依此策略一直地进行下去，直到背包装满为止。在零一背包问题中贪心选择之所以不能得到最优解原因是贪心选择无法保证最终能将背包装满，部分闲置的背包空间使每公斤背包空间的价值降低了。在程序中已经事先将单位重量价值按照从大到小的顺序排好。

[cpp] view plain copy

1. #include<iostream>     
2. using namespace