目录

贪心算法的思想

贪心算法的基本要素

        最优子结构

        贪心选择性质

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

贪心算法的一般理论/求解思路

相关例题

        会场安排问题

        哈夫曼编码

思维导图

        

---

---

贪心算法的思想

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

贪心算法的基本要素

        最优子结构

                最优子结构我们在动态规划的时候就已经接触过，所谓最优子结构就是问题的最优解包含了子问题的最优解。具有最优子结构是我们进行动态规划和贪心算法求解的要素之一。

                动态规划是自底向上求解问题，而贪心则是自顶向下迭代求解问题。每一次通过贪心选择都会使问题变成更小的子问题。

                对于一个问题能不能用贪心算法来实现，就要判断是否具有贪心选择性质，而且必须证明每一步的贪心选择可以的到最后整体的最优解。（通常我们使用交换最优解来证明）。

        贪心选择性质

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

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

        共同点：两者都具有最优子结构性质
        不同点：
        1) 动态规划算法中，每步所做的选择往往依赖于相关子问题的解，因而只有在解出相关子问题时才能做出选择。而贪心算法，仅在当前状态下做出最好选择，即局部最优选择，然后再去解做出这个选择后产生的相应的子问题。

        2) 动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常自顶向下的方式进行。

        举个栗子：

        如果现在要找开 15元钱，有11元的，5元的和1元的，则：

            1. 根据动态规划法的解题思想，得到最优解为3张5元面额的，           总共3张

            2. 根据贪心算法的解题思想，得到的近似最优解为1张11元面额的  加上4张1元面额的，总共5张

        可见，我们的贪心算法如果不满足贪心选择，得到的并不是最优的，而是较优的，但是我们的贪心算法更加的简单，实现也更加方便，动态规划就显得更加复杂，但准确性高。而且我们贪心的题目通常都可以用动态规划来解决。

贪心算法的一般理论/求解思路

（1）候选集合A：为了构造问题的解决方案，有一个候选集合A作为问题的可行解，即问题的最终解均取自候选集合A。

（2）解集合S：随着贪心选择的进行，解集合S不断扩展，直到构成满足问题的完整解。

（3）解决函数solution：检查解集合S是否构成问题的完整解。

（4）选择函数select：即贪心策略，这是关键，指出哪个候选对象最有希望构成问题的解，通常和目标函数有关。

（5）可行函数feasible：检查解集合中加入一个候选对象是否可行，即解集合扩展后是否满足约束条件。

相关例题

        会场安排问题

                假设要在足够多的会场里安排一批活动，并希望使用尽可能少的会场。设计一个有效的贪心算法进行安排。对于给定的k个待安排的活动，计算使用最少会场的时间表。

            输入：5                                                 输出        3
                        1 23
                        12 28
                        25 35
                        27 80
                        36 50

                这个题目大家会跟活动安排问题联系上，如果按照活动的结束时间进行排序，最后我们得到的答案可能不是我们想要的结果。因为有可能我们把大的填入，结果小的留下，最后使用的会场变多。举个例子：

            输入：10                                                 输出        2
                        1 3
                        3 5
                        1 7
                        7 9
                        9 11
                        11 13
                        5 15
                        15 17
                        17 19
                        13 19

                        如果按照结束时间排序，我们需要的会场应该是三个，结果我们两个就能安排上所有的会场，显然这种方法是不对的。我们应该怎么贪心呢，我们可以让尽可能多的活动在一个会场里，根据会场的开始时间进行排序，我们只需要记录每个会场的最终截止时间就可以了，这就是我们的贪心策略。

                   我们来证明一下贪心的两大要素：

                        1.最优子结构：假设x为原问题s的最优解，设1为第一个安排的活动，则x-{1}是s-{1}的最优解，假设有一个更优解y-{1},则s=x+1>y+1;与原问题矛盾。故满足最优子结构。

                        2.贪心选择证明：

                              假设该会场第一个活动为1，而开始时间最早的活动为k

                              如果k==1 则就是满足贪心选择的最优解；

                        如果k！=1，说明t(1)>t(k),设K前面有个活动x,则t(k)>end(x),将1与k交换，可知t(1)>t(k),说明交换后，仍满足最优解。故具有贪心选择性质。

              以下是代码实现：

#include<stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
struct bang{
    int s;
    int e;
}a[999];
int b[999];
int   cmp(const   void   *a,   const   void   *b)   {
  struct   bang   *px,   *py;
  px   =   (struct   bang   *)a;
  py   =   (struct   bang   *)b;
  if(px->s !=py->s){
    return px->s-py->s;
  }
  return   py->s-px->s;
}
int main()
{

        int n;
        scanf("%d",&n);
        for(int i=0;i<n;i++){
            scanf("%d%d",&a[i].s,&a[i].e);
        }
        qsort(a,n,sizeof(a[0]),cmp);
        int ans=0;
        for(int i=0;i<n;i++){
            int j;
            for(j=0;j<ans;j++){
                if(a[i].s>=b[j]){
                    b[j]=a[i].e;
                    break;
                }
            }
            if(ans==j) b[ans++]=a[i].e;
        }
        printf("%d\n",ans);

        return 0;
}

        哈夫曼编码

                哈夫曼编码是广泛用于数据文件压缩的十分有效的编码方法，我们称树的带权路径长度（WPL）最小的二叉树为“哈夫曼树”或“最优二叉树”。

                哈夫曼树对字符进行编码，称为哈夫曼树编码(Huffman Coding)。哈夫曼编码是一种编码方式，哈夫曼编码是可变字长编码的一种。Huffman于1952年提出一种编码方法，该方法完全依据字符出现概率来构造异字头的平均长 度最短的码字，有时称之为最佳编码，一般就叫作Huffman编码。

                现在给定 n 个字符在文章中出现的频率：W[1], W[2],…, W[n]，给每个字符赋予一个01串，使得任意一个字符的编码不是另一个字符编码的前缀（哈夫曼编码），而且编码的总长度（每个字符的频率于编码长度的乘积总和）尽量小。

样例：

        输入：6                                                         输出：a 0
                    a 45                                                                c 100
                    b 13                                                                b 101
                    c 12                                                                 f 1101
                    d 16                                                                e 1101
                    e 9                                                                  d 111
                    f 5

                我们生成哈夫曼编码，首先得生成哈夫曼树，如何生成哈夫曼树呢，我们可以发现，频率越高的字符，他的编码就越短，就代表他的深度就越小，所以我们就可以考虑能否每次取最小频率的两个字符进行合并，然后生成父亲，将父亲加入到堆中继续迭代选择。最后堆仅剩一个数时，便完成建树的过程。我们来证明一下看是否可行。

    最优子结构：设T是表示字符集C的一个最优前缀码的完全二叉树，C中字符c的出现频率是f（c）。设x和y是树T中的两个叶子且为兄弟，z是他们的父亲。若将z看做具有频率f(z)=f(x)+f(y)的字符，则树T设T是表示字符集C的一个最优前缀码的完全二叉树，C中字符c的出现频率是f（c）。设x和y是树T中的两个叶子且为兄弟，z是他们的父亲。若将z看做具有频率f(z)=f(x)+f(y)的字符，则树T1=T-{x,y}表示字符集C1=C-{x,y}∪{z}的一个最优前缀码。

        首先证明T的平均码长B(T)可用T1平均码长B(T1)来表示。

        我们可以知道c∈C-{x,y},dT1(c)= dT(c), f(c)dT(c)= f(c)dT1(c)

        f (x)dT(r)+f(y)dT(y)= f(x)+f(y)+f(z)dT1(z).

               B(T)= B(T1)+f(x)+f(y)

        假设T1不是最优的，我们有T2是比T1更优的，即有B(T2)<B(T1)。

        由于z被看做C1中的一个字符，故z在T2中是一树叶。若将x和y加入树T2中作为z的儿子，则得到表示字符集C的前缀码的二叉树T3，且有B(T3)=B(T2)+f(x)+f(y)<B(T1)+f(x)+f(y)=B(T)与初始矛盾，所以满足最优子结构。

贪心选择性质：

        通过第一个图进行介绍，b与c是最一般的两个叶子结点且为兄弟，x和y是候选集中最小的两个点，我们通过交换b和x可以得出B(T)>=B(T1），而且我们知道T是最优的，又有B(T)<=B(T1),可知 

 B(T2)=B(T)的，由此得证。

以下是使用优先队列实现的代码：

#include <bits/stdc++.h>
#include <queue>
using namespace std;
typedef struct node{
   char c;
    int weight;
    string huffcode;
    node *lchild,*rchild;
    node(){
        c='\0';
        weight=0;
        huffcode=("");
        lchild=NULL;
        rchild=NULL;
    }
}node;
struct cmp{
    bool operator() (struct node*a,struct node*b){
        return a->weight>b->weight;
    }
};
priority_queue<node*,vector<node*>,cmp > q;
void creatnode(node *root){
    if(root->lchild){
        root->lchild->huffcode=root->huffcode+"0";
        creatnode(root->lchild);
    }
    if(!(root->lchild)&&!(root->rchild)){
        cout << root->c <<" " << root->huffcode << endl;
    }
    if(root->rchild){
        root->rchild->huffcode=root->huffcode+"1";
        creatnode(root->rchild);
    }

}
int main()
{
	int x;
	cin >> x;
	int w;
	char ch;
	for(int i=0;i<x;i++){
        cin >> ch >> w;
        node*t=new node;
        t->c=ch;
        t->weight=w;
        q.push(t);
	}
	while(q.size()!=1){
        node *a,*b;
        a=q.top();
        q.pop();
        b=q.top();
        q.pop();
        node* temp=new node;
        temp->weight=a->weight+b->weight;
        temp->lchild=a;
        temp->rchild=b;
        q.push(temp);
	}
    creatnode(q.top());

	return 0;
}

思维导图