贪心算法

贪心算法

 

一、基本概念：

 

    所谓贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。

    贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。必须注意的是，贪心算法不是对所有问题都能得到整体最优解，选择的贪心策略必须具备无后效性，即某个状态以后的过程不会影响以前的状态，只与当前状态有关。

    所以对所采用的贪心策略一定要仔细分析其是否满足无后效性。

 

二、基本要素：

    1、贪心选择性质。所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。

动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。

对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。

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

 

三、贪心算法的基本思路：
    1、建立数学模型来描述问题。
    2、把求解的问题分成若干个子问题。
    3、对每一子问题求解，得到子问题的局部最优解。

 

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

四、实现框架

    从问题的某一初始解出发；
    while （能朝给定总目标前进一步）
    { 
          利用可行的决策，求出可行解的一个解元素；
    }
    由所有解元素组合成问题的一个可行解

五、算法存在的问题

 

    1、不能保证求得的最后解是最佳的；

    2、不能用来求最大或最小解问题；

    3、只能求满足某些约束条件的可行解的范围。

 

六、例题分析   

 

    下面是一个可以试用贪心算法解的题目，贪心解的确不错，可惜不是最优解。

 

    [背包问题]有一个背包，背包容量是M=150。有7个物品，物品可以分割成任意大小。

    要求尽可能让装入背包中的物品总价值最大，但不能超过总容量。

    物品 A B C D E F G

    重量 35 30 60 50 40 10 25

    价值 10 40 30 50 35 40 30

 

    分析：

    目标函数： ∑Pi最大

    约束条件是装入的物品总重量不超过背包容量：∑Wi<=M( M=150)

    （1）根据贪心的策略，每次挑选价值最大的物品装入背包，得到的结果是否最优？

    （2）每次挑选所占重量最小的物品装入是否能得到最优解？

    （3）每次选取单位重量价值最大的物品，成为解本题的策略。

    值得注意的是，贪心算法并不是完全不可以使用，贪心策略一旦经过证明成立后，它就是一种高效的算法。

    贪心算法还是很常见的算法之一，这是由于它简单易行，构造贪心策略不是很困难。

    可惜的是，它需要证明后才能真正运用到题目的算法中。

 

    一般来说，贪心算法的证明围绕着：整个问题的最优解一定由在贪心策略中存在的子问题的最优解得来的。

    对于例题中的3种贪心策略，都是无法成立（无法被证明）的，解释如下：

 

    （1）贪心策略：选取价值最大者。反例：

    W=30

    物品：A B C

    重量：28 12 12

    价值：30 20 20

    根据策略，首先选取物品A，接下来就无法再选取了，可是，选取B、C则更好。

    （2）贪心策略：选取重量最小。它的反例与第一种策略的反例差不多。

    （3）贪心策略：选取单位重量价值最大的物品。反例：

    W=30

    物品：A B C

    重量：28 20 10

    价值：28 20 10

    根据策略，三种物品单位重量价值一样，程序无法依据现有策略作出判断，如果选择A，则答案错误。

 

网上找的代码求解过程：

1. #include <iostream>  
2. using namespace std;  
3.   
4. struct Node  
5. {  
6.     float weight;  
7.     float value;  
8.     bool mark;  
9.     char char_mark;  
10.     float pre_weight_value;  
11. };  
12.   
13. int main(int argc, char* argv[])  
14. {  
15.     float Weight[7] = {35,30,60,50,40,15,20};  
16.     float Value [7] = {10,40,30,50,35,40,30};  
17.     Node array[7];  
18.     for(int i=0; i<7; i++)  
19.     {  
20.         array[i].value = Value[i];  
21.         array[i].weight = Weight[i];  
22.         array[i].char_mark = 65 + i;  
23.         array[i].mark = false;  
24.         array[i].pre_weight_value = Value[i] / Weight[i];  
25.     }  
26.       
27.     for(i=0;i<7;i++)  
28.         cout<<array[i].pre_weight_value<<" ";  
29.     cout<<endl;  
30.       
31.     float weight_all=0.0;  
32.     float value_all = 0.0;  
33.     float max = 0.0;  
34.     char charArray[7];  
35.     int flag,n = 0;  
36.       
37.     while(weight_all <= 150)  
38.     {  
39.         for(int index=0;index < 7; ++index)  
40.         {  
41.             if(array[index].pre_weight_value > max && array[index].mark == false)  
42.             {  
43.                 max = array[index].pre_weight_value ;  
44.                 flag = index;  
45.             }  
46.         }  
47.           
48.         charArray[n++] = array[flag].char_mark;  
49.         array[flag].mark = true;  
50.         weight_all += array[flag].weight;  
51.         value_all += array[flag].value;  
52.         max = 0.0;  
53.     }  
54.       
55.     for(i=0;i<n-1;i++)  
56.         cout<<charArray[i]<<" ";  
57.     cout<<endl;  
58.     cout<<"weight_all:"<<weight_all- array[n-1].weight<<endl;  
59.     cout<<"value_all:"<<value_all<<endl;  
60.       
61.     system("pause");  
62.     return 0;  
63. }  

 

    该算法里面就是采用的贪心第三方案，一般这个方案是成功率最大的，其他两个方案在这里没有考虑，在这里得到的结果是利用了115容量装了价值195的东西，但是这明显不是最优结果，分明还可以装一个A进去！刚好满足150重量，由于在算法中我单纯的利用第三种贪心方法求解，当剩余的包裹中最优的再加进来的时候已经超过了，所以这个时候可以选择剩余包裹中次优的（如这里选择A），再不行就次次优的，尽量把包裹装满，这样得到的结果就很接近了（不保证一定为最优），但是我们一般不这样来求解，动态规划算法可以解决这个问题，动态规划很好的弥补了贪心算法的不足！