贪心法

Posted 2022-11-24 松子茶

贪心法(Greedy Approach)又称贪婪法, 在对问题求解时，总是做出在当前看来是最好的选择，或者说是：总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。当然，希望贪心算法得到的最终结果也是整体最优的。虽然贪心算法不能对所有问题都得到整体最优解，但对许多问题它能产生整体最优解。如单源最短路经问题，最小生成树问题等。在一些情况下，即使贪心算法不能得到整体最优解，其最终结果却是最优解的很好近似。

---

贪心法的设计思想

当一个问题具有以下的性质时可以用贪心算法求解:每一步的局部最优解，同事也说整个问题的最优解。

如果一个问题可以用贪心算法解决，那么贪心通常是解决这个问题的最好的方法。 贪婪算法一般比其他方法例如动态规划更有效。但是贪婪算法不能总是被应用。例如，部分背包问题可以使用贪心解决，但是不能解决0-1背包问题。

贪婪算法有时也用用来得到一个近似优化问题。例如，旅行商问题是一个NP难问题。贪婪选择这个问题是选择最近的并且从当前城市每一步。这个解决方案并不总是产生最好的最优解，但可以用来得到一个近似最优解。

让我们考虑一下任务选择的贪婪算法的问题, 作为我们的第一个例子。问题：

给出n个任务和每个任务的开始和结束时间。找出可以完成的任务的最大数量，在同一时刻只能做一个任务。

例子:

下面的6个任务：
     start[]  =  1, 3, 0, 5, 8, 5;
     finish[] =  2, 4, 6, 7, 9, 9;
最多可完成的任务是：
 0, 1, 3, 4

贪婪的选择是总是选择下一个任务的完成时间至少在剩下的任务和开始时间大于或等于以前选择任务的完成时间。我们可以根据他们的任务完成时间，以便我们总是认为下一个任务是最小完成时间的任务。

• 1)按照完成时间对任务排序
• 2)选择第一个任务排序数组元素和打印。
• 3) 继续以下剩余的任务排序数组。

……a)如果这一任务的开始时间大于先前选择任务的完成时间然后选择这个任务和打印。

在接下来的C程序，假设已经根据任务的结束时间排序。

#include<stdio.h>
// 打印可以完成的最大数量的任务
//  n   -->  所有任务的数量
//  s[] -->  开始时间
//  f[] -->  结束时间
void printMaxActivities(int s[], int f[], int n)

    int i, j;
    printf ("Following activities are selected \\n");
    // 选择第一个任务
    i = 0;
    printf("%d ", i);
    //考虑剩下的任务
    for (j = 1; j < n; j++)
    
      // 如果当前的任务开始比 前一个选择的任务结束时间大或相等，就选择它
      if (s[j] >= f[i])
      
          printf ("%d ", j);
          i = j;
      
    


// driver program to test above function
int main()

    int s[] =  1, 3, 0, 5, 8, 5;
    int f[] =  2, 4, 6, 7, 9, 9;
    int n = sizeof(s)/sizeof(s[0]);
    printMaxActivities(s, f, n);
    getchar();
    return 0;

输出：

Following activities are selected
0 1 3 4

---

贪心算法的基本要素

对于一个具体的问题，怎么知道是否可用贪心算法解此问题，以及能否得到问题的最优解呢?这个问题很难给予肯定的回答。

但是，从许多可以用贪心算法求解的问题中看到这类问题一般具有2个重要的性质：贪心选择性质和最优子结构性质。

• 1、贪心选择性质

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

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

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

• 2、最优子结构性质

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

• 3、贪心算法与动态规划算法的差异

贪心算法和动态规划算法都要求问题具有最优子结构性质，这是2类算法的一个共同点。但是，对于具有最优子结构的问题应该选用贪心算法还是动态规划算法求解?是否能用动态规划算法求解的问题也能用贪心算法求解?下面研究2个经典的组合优化问题，并以此说明贪心算法与动态规划算法的主要差别。

0-1背包问题：
给定n种物品和一个背包。物品i的重量是Wi，其价值为Vi，背包的容量为C。应如何选择装入背包的物品，使得装入背包中物品的总价值最大?

在选择装入背包的物品时，对每种物品i只有2种选择，即装入背包或不装入背包。不能将物品i装入背包多次，也不能只装入部分的物品i。

背包问题：
与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，1 <= i <= n。

这2类问题都具有最优子结构性质，极为相似，但背包问题可以用贪心算法求解，而0-1背包问题却不能用贪心算法求解。

用贪心算法解背包问题的基本步骤：

• 首先计算每种物品单位重量的价值$V_i/W_i$，
• 然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。
• 若将这种物品全部装入背包后，背包内的物品总重量未超过C，则选择单位重量价值次高的物品并尽可能多地装入背包。
• 依此策略一直地进行下去，直到背包装满为止。

伪代码：

void Knapsack(int n,float M,float v[],float w[],float x[])

　　Sort(n,v,w);
　　int i;
　　for (i = 1 ; i <= n ; i++) 
　　　　x[i] = 0;
　　　　float c=M;
　　　　for (i=1;i<=n;i++) 
　　　　　　if (w[i] > c) break;
　　　　
　　　　x[i]=1;
　　　　c-=w[i];
　　
　　if (i <= n) 
　　　　x[i]=c / w[i];

算法knapsack的主要计算时间在于将各种物品依其单位重量的价值从大到小排序。因此，算法的计算时间上界为 O（nlogn）。

为了证明算法的正确性，还必须证明背包问题具有贪心选择性质。

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

---

贪心法的典型应用

活动安排问题

问题描述：设有$n$个活动的集合$E = \\1,2,…,n\\$，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。每个活$i$都有一个要求使用该资源的起始时间$s_i$和一个结束时间$f_i$,且$s_i < f_i$ 。如果选择了活动i，则它在半开时间区间$[s_i, f_i)$内占用资源。若区间$[s_i, f_i)$与区间$[s_j, f_j)$不相交，则称活动$i$与活动$j$是相容的。也就是说，当$s_i >= f_j$或$s_j >= f_i$时，活动$i$与活动$j$相容。

由于输入的活动以其完成时间的非减序排列，所以算法 greedySelector每次总是选择具有最早完成时间的相容活动加入集合A中。直观上，按这种方法选择相容活动为未安排活动留下尽可能多的时间。也就是说，该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

算法$greedySelector$的效率极高。当输入的活动已按结束时间的非减序排列，算法只需$O(n)$的时间安排n个活动，使最多的活动能相容地使用公共资源。如果所给出的活动未按非减序排列，可以用$O(nlogn)$的时间重排。

例：设待安排的11个活动的开始时间和结束时间按结束时间的非减序排列如下：

i	1	2	3	4	5	6	7	8	9	10	11
S[i]	1	3	0	5	3	5	6	8	8	2	12
f[i]	4	5	6	7	8	9	10	11	12	13	14

算法$greedySelector$ 的计算过程如下图所示[图来源网络]。图中每行相应于算法的一次迭代。阴影长条表示的活动是已选入集合A的活动，而空白长条表示的活动是当前正在检查相容性的活动。

若被检查的活动i的开始时间$S_i$小于最近选择的活动$j$的结束时间$f_i$，则不选择活动$i$，否则选择活动$i$加入集合$A$中。

贪心算法并不总能求得问题的整体最优解。但对于活动安排问题，贪心算法$greedySelector$却总能求得的整体最优解，即它最终所确定的相容活动集合A的规模最大。这个结论可以用数学归纳法证明。

活动安排问题实现：

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std ;

struct ActivityTime

public:
    ActivityTime (int nStart, int nEnd) 
        : m_nStart (nStart), m_nEnd (nEnd) 
     
    ActivityTime ()
        : m_nStart (0), m_nEnd (0)
     
    friend 
    bool operator < (const ActivityTime& lth, const ActivityTime& rth) 
    
        return lth.m_nEnd < lth.m_nEnd ;
    
public:
    int m_nStart ;
    int m_nEnd ;
 ;

class ActivityArrange 

public:
    ActivityArrange (const vector<ActivityTime>& vTimeList) 
    
        m_vTimeList = vTimeList ;
        m_nCount = vTimeList.size () ;
        m_bvSelectFlag.resize (m_nCount, false) ;
    
    // 活动安排
    void greedySelector () 
    
        __sortTime () ;
        // 第一个活动一定入内
        m_bvSelectFlag[0] = true ;    
        int j = 0 ;
        for (int i = 1; i < m_nCount ; ++ i) 
            if (m_vTimeList[i].m_nStart > m_vTimeList[j].m_nEnd) 
                m_bvSelectFlag[i] = true ;
                j = i ;
            
        

        copy (m_bvSelectFlag.begin(), m_bvSelectFlag.end() ,ostream_iterator<bool> (cout, ” “));
        cout << endl ;
    

private:
    // 按照活动结束时间非递减排序
    void __sortTime () 
    
        sort (m_vTimeList.begin(), m_vTimeList.end()) ;
        for (vector<ActivityTime>::iterator ite = m_vTimeList.begin() ;
                ite != m_vTimeList.end() ; 
                ++ ite) 
            cout << ite->m_nStart << “, “<< ite ->m_nEnd << endl ;
        
    

private:
    vector<ActivityTime>    m_vTimeList ;    // 活动时间安排列表
    vector<bool>            m_bvSelectFlag ;// 是否安排活动标志
    int    m_nCount ;    // 总活动个数
 ;

int main()

    vector<ActivityTime> vATimeList ;
    vATimeList.push_back (ActivityTime(1, 4)) ;
    vATimeList.push_back (ActivityTime(3, 5)) ;
    vATimeList.push_back (ActivityTime(0, 6)) ;
    vATimeList.push_back (ActivityTime(5, 7)) ;
    vATimeList.push_back (ActivityTime(3, 8)) ;
    vATimeList.push_back (ActivityTime(5, 9)) ;
    vATimeList.push_back (ActivityTime(6, 10)) ;
    vATimeList.push_back (ActivityTime(8, 11)) ;
    vActiTimeList.push_back (ActivityTime(8, 12)) ;
    vATimeList.push_back (ActivityTime(2, 13)) ;
    vATimeList.push_back (ActivityTime(12, 14)) ;

    ActivityArrange aa (vATimeList) ;
    aa.greedySelector () ;
    return 0 ;

最优前缀码

Huffman 编码是一种无损压缩技术。它分配可变长度编码不同的字符。贪婪的选择是分配一点代码最常见的字符长度。哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。其压缩率通常在20%～90%之间。哈夫曼编码算法用字符在文件中出现的频率表来建立一个用0，1串表示各字符的最优表示方式。

给出现频率高的字符较短的编码，出现频率较低的字符以较长的编码，可以大大缩短总码长。

_	a	b	c	d	e	f
频率（千次）	45	13	12	16	9	5
定长码	000	001	010	011	100	101
变长码	0	以上是关于贪心法的主要内容，如果未能解决你的问题，请参考以下文章 《挑战程序设计竞赛》学习笔记 最大化平均值 c语言背包问题，求高手解答 退而求其次——遗传算法 决策树贪心算法正确吗？ 决策树贪心算法正确吗？