贪心算法

学习要点：

1、概念

2、基本要素（+与动态规划算法的差异）

3、应用范例：

（1）活动安排问题

（2）最优装载问题

（3）哈夫曼编码

（4）最优服务次序问题

（5）最小生成树

（6）最大边权值最小的生成树

（7）.......

 

1、概念

贪心算法总是作出当前看来是最好的选择。

也就是说贪心算法并不从整体最优上加以考虑，它所作出的选择只是在某种意义上的局部最优选择。

在一些情况下，即使贪心算法不能得到整体最优解，但其最终结果却是最优解的很好的近似解。

2、基本要素

贪心选择：通过一系列的选择得到问题的解，且所作的每一个选择都是当前状态下局部最好选择。

两个重要性质：贪心选择性质 + 最优子结构性质

（1）贪心选择性质———————————————与动态规划算法的主要区别

贪心选择性质：所求问题的整体最优解可以通过一系列局部最优的选择（即贪心选择）来达到。

注：与动态规划的区别

共同点：都要求问题具有最优子结构性质

在动态规划中，每步所做的选择往往依赖于相关子问题的解，所以只有在解出相关子问题后才能作出选择。通常以自底向上的方式解各子问题。

而在贪心算法中，仅在当前状态下做出最好的选择，即局部最优选择，然后再去解作出这个选择后产生的相应的子问题。所做的贪心选择可以依赖于以往所做过的选择，但不依赖于将来所做的选择，也不依赖于子问题的解。通常以自顶向下的方式进行，以迭代的方式做出相继的贪心选择，每做一次贪心选择就将所求问题简化为规模更小的子问题。

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

首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始，做了贪心选择后，原问题简化为规模更小的类似子问题。然后用数学归纳法证明，通过每一步做贪心选择，最终可得到问题的整体最优解。

（2）最优子结构性质

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。

问题的最优子结构性质是该问题可用动态规划算法或贪心算法求解的关键特征。

3、应用范例

（1）活动安排问题

/*

*问题：要求高效地安排一系列争用某一公共资源的活动

*描述：设有n 个活动的集合E={1,2，...，n}，其中每个活动都要求使用同一个资源，如演讲会场等，而在同一时间内只有一个活动可以使用这一资源。

   每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si<fi。如果选择了活动i，则它在半开时间区间[si,fi)内占用资源。

   若区间[si,fi)与区间[sj,fj)不相交，则称活动i和活动j是相容的。也就是说，当si>=fj或sj>=fi时，活动i与活动j相容。

*分析：活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

   考虑到每个活动的开始、结束时间已定，要选择最佳活动安排，可以把各活动的起始时间和结束时间分别存储于数组s和f中，

   且按照结束时间非递减排序，最早结束活动先被安排，依次贪心选择活动进行安排。

   该贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

*B Y ：xymaqingxiang

   2014-04-19

*/

#include <stdio.h>
#include <stdlib.h>

#define MAX 20
#define INFINITY 32768

struct In 
{ 
    int s; 
    int f; 
}t[MAX] ;

//按照f的值从小到大将结构体排序,关于结构体内的排序关键数据f的类型可以很多种，参考上面的例子写 
int cmp( const void *a ,const void *b) 
{ 
    return (*(In *)a).f - (*(In *)b).f ;  
} 

void GreedySelector(int n, struct In t[], int a[])
{
    int i, j, count;
    a[1] = 1;
    j = 1;
    count = 1;
    for(i = 2; i < n+1; i++)
    {
        if(t[i].s >= t[j].f)
        {
            a[i] = 1;
            j=i;
            count++;
        }
        else
            a[i] = 0;
    }
}

//排序
void sort(int n, struct In t[])
{
    int i,j;
    int t1,t2;
    for(i=1;i<n+1;i++)
    {
        for(j=1;j<n+1;j++)
            if(t[j].f>t[j+1].f)
            {
                t1=t[j].f;
                t2=t[j].s;

                t[j].f=t[j+1].f;
                t[j].s=t[j+1].s;

                t[j+1].f=t1;
                t[j+1].s=t2;
            }
    }
}

int main()
{
    int i = 0, j = 0;        //控制程序流程
    int n;                    //n：活动数目
    int a[MAX] = {0};        //标记活动是否被安排：1--安排，0--未安排
    
    for(i = 0; i < MAX; i++)
    {
        t[i].f = INFINITY;
        t[i].s = 0;
    }
    
    printf("请输入活动数目（n）：");
    scanf("%d", &n);        //输入活动
    printf("
请输入各个活动的开始时间s和结束时间f：
");
    for(i = 1; i < n+1; i++)    //依次输入各个顾客服务时间
    {
        printf("第%d个活动的起始时间和结束时间：
",i);
        scanf("%d", &t[i].s);
        scanf("%d", &t[i].f);
    }

    printf("
");
    for(i = 1; i < n+1; i++)    //依次打印各个活动的结束时间
        printf("%d  ",t[i].f);
    printf("
");
    for(i = 1; i < n+1; i++)    //依次打印各个活动的起始时间
        printf("%d  ",t[i].s);

    sort(n,t);

/*    qsort(t,n,sizeof(t[0]),cmp); //排序函数--快排思想
*/
    printf("
");
    for(i = 1; i < n+1; i++)    //依次打印各个活动的结束时间
        printf("%d  ",t[i].f);
    printf("
");
    for(i = 1; i < n+1; i++)    //依次打印各个活动的起始时间
        printf("%d  ",t[i].s);
    
    GreedySelector(n,t,a);

    printf("
");

    for(i = 1; i < n+1; i++)    //打印活动标记数组
        printf("%d",a[i]);

    printf("
被安排的活动有：");
    for(i = 1; i < n+1; i++)
        if(a[i]==1)
            printf("%d  ",i);

    printf("
");

    flushall();
    printf("按任意键继续...");
    getchar();
    return 0;
}

（2）最优装载问题

/*

*问题：要求在体积不受限制的情况下，将尽可能多的集装箱装上轮船

*描述：有一批集装箱要装上一搜载重量为c的轮船，其中集装箱i的重量为wi，选择尽可能多的集装箱

*分析：最优装载问题就是要在所给的这批集装箱中选择尽可能多的集装箱装上轮船，使其个数达到最大。

   考虑到每个集装箱的重量已定，要把尽可能多的集装箱装上轮船，可以把各个集装箱的重量存储在数组w中，

   且按照重量wi从小到大排序，最轻的先被选中，依次贪心选择集装箱进行装载。

   该贪心选择的意义是使剩余的可利用空间极大化，以便装载尽可能多的集装箱。

*B Y ：xymaqingxiang

   2014-04-19

*/

#include <stdio.h>
#include <stdlib.h>

#define MAX 20
#define INFINITY 32768

//按照w的值从小到大排序
int cmp(const void *a, const void *b) 
{
    return (*(int *)a - *(int *)b);
}


void load(int c, int n, int w[], int a[])
{
    int i;
    for(i = 1; i < n+1 && w[i] <= c; i++)
    {
        a[i] = 1;
        c -= w[i];
    }
}

//排序 --从小到大
/*void sort(int n, struct In t[])
{
    int i,j;
    int t1,t2;
    for(i=1;i<n+1;i++)
    {
        for(j=1;j<n+1;j++)
            if(t[j].f>t[j+1].f)
            {
                t1=t[j].f;
                t2=t[j].s;

                t[j].f=t[j+1].f;
                t[j].s=t[j+1].s;

                t[j+1].f=t1;
                t[j+1].s=t2;
            }
    }
}
*/

int main()
{
    int i = 0, j = 0;        //控制程序流程
    int n,c;                    //n：集装箱数目
    int w[MAX] = {0};
    int a[MAX] = {0};        //标记集装箱是否被装载：1--被装载，0--未被装载
    
    printf("请输入轮船载重（c）：");
    scanf("%d", &c);        //输入集装箱数目n
    printf("请输入集装箱数目（n）：");
    scanf("%d", &n);        //输入集装箱数目n
    printf("
请输入各个集装箱的重量w[i]：
");
    for(i = 1; i < n+1; i++)    //依次输入各个集装箱重量w
    {
        printf("第%d个集装箱的重量w：
",i);
        scanf("%d", &w[i]);
    }

    printf("
");
    for(i = 1; i < n+1; i++)    //依次打印各个集装箱重量w
        printf("%d  ",w[i]);

//    sort(n,t);

    qsort(w,n,sizeof(w[0]),cmp); //排序函数--快排思想

    printf("
");
    for(i = 1; i < n+1; i++)    //依次打印排序后各个集装箱重量w
        printf("%d  ",w[i]);
    
    load(c,n,w,a);

    printf("
");

    for(i = 1; i < n+1; i++)    //打印活动标记数组
        printf("%d",a[i]);

    printf("
被装载的集装箱有：");
    for(i = 1; i < n+1; i++)
        if(a[i]==1)
            printf("%d  ",i);

    printf("
");

    flushall();
    printf("按任意键继续...");
    getchar();
    return 0;
}

（3）哈夫曼编码

/*

*问题：基础的哈夫曼树的实现

*描述：已知每个字符出现的频率，构造哈夫曼树，并设计哈弗曼编码。

*要求：从终端读入字符集大小n、n个字符和n个权值，建立哈夫曼树，打印每个字符对应的哈夫曼编码，对终端输入的字符集解码，并显示编码结果。

   哈夫曼树是由n个带权叶子结点构成的所有二叉树中带权路径长度最短的二叉树，又叫最优二叉树。

   树的带权路径长度（WPL）为树中从根到所有叶子结点的各个带权路径长度之和。

   带权路径长度为从树根到某一结点的路径长度（从一个结点到另一个结点所经过的分支数目）与该结点的权的乘积。

*分析：算法步骤

   1、初始化：用给定的n个权值{w1,w2,....wn}对应由n棵二叉树构成的森林F={T1,T2,...,Tn}，其中每一棵二叉树Ti都只有一个权值为wi的根结点，其左右子树为空。

   2、找最小树：在森林F中选择两棵根结点权值最小的二叉树，作为一棵新二叉树的左、右子树，标记新二叉树的根结点权值为其左、右子树的根结点权值之和。

   3、删除和加入：从F中删除被选中的那两棵二叉树，同时把新构成的二叉树加入到森林F中。

   4、判断：重复2、3操作，知道森林中只含有一棵二叉树为止，此时得到的这棵二叉树就是哈夫曼树。

*B Y ：xymaqingxiang

   2014-04-16

*/

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>

#define MAX 20
#define N 20                //叶子结点的最大值
#define M 2*N-1            //所有结点的最大值

typedef struct 
{
    char data;
    int weight;            //结点的权值
    int parent;            //双亲的下标
    int lchild;            //左孩子结点的下标
    int rchild;            //右孩子结点的下标
}HTNode,HuffmanTree[M+1];    //HuffmanTree是结构数组类型，0号单元不用

//typedef char * HuffmanCode[N+1];    //存储哈夫曼编码串的头指针的数组
typedef struct
{
    char data;
    char cd[M];
}CNode;
typedef CNode * HuffmanCode[N+1];


//在ht[1]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，并将其序号分别赋值给是s1，s2返回
void Select(HuffmanTree ht,int pos,int *s1,int *s2)        
{
    int m1,m2,i;
    m1=m2=32767;            //给m1、m2赋最大值
    for(i=1;i<=pos;i++)        //在ht[1]~ht[i-1]的范围内选择
    {
        if(ht[i].parent==0&&ht[i].weight<m1)        
        {
            m2=m1;
            m1=ht[i].weight;
            *s2=*s1;
            *s1=i;
        }
        else if(ht[i].parent==0&&ht[i].weight<m2)
        {
            m2=ht[i].weight;
            *s2=i;
        }
    }
    if(ht[*s1].weight>=ht[*s2].weight)
    {
        i=*s1;
        *s1=*s2;
        *s2=i;
    }

   /*if(*s1>*s2)
    {
        i=*s1;
        *s1=*s2;
        *s2=i;
    }*/
}

//创建哈夫曼树ht[M+1],w[]存放n个权值
void CrtHuffmanTree(HuffmanTree ht,int w[],char d[], int n)        
{
    int s1,s2;
    int i,m;
    for(i=1;i<=n;i++)                //初始化ht[]----1~n号单元存放叶子结点
    {
        ht[i].data=d[i];
        ht[i].weight=w[i];
        ht[i].parent=0;
        ht[i].lchild=0;
        ht[i].rchild=0;
    }
    m=2*n-1;                        //所有结点数目
    for(i=n+1;i<=m;i++)                //初始化ht[]----n+1~m号单元存放非叶子结点
    {
        ht[i].weight=0;
        ht[i].parent=0;
        ht[i].lchild=0;
        ht[i].rchild=0;
    }
    s1=s2=1;
    for(i=n+1;i<=m;i++)                //创建非叶结点，建哈夫曼树
    {
        Select(ht,i-1,&s1,&s2);        //在ht[1]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，并将其序号分别赋值给是s1，s2返回
        ht[i].weight=ht[s1].weight+ht[s2].weight;    //标记权值、父子关系
        ht[s1].parent=i;
        ht[s2].parent=i;
        ht[i].lchild=s1;
        ht[i].rchild=s2;
    }
}

//从叶子结点到根，逆向求每个叶子结点对应的哈夫曼编码
void CrtHuffmanCode(HuffmanTree ht,HuffmanCode hc,int n)    
{
    char *cd;
    int c,i,p,start;
    cd=(char *)malloc((n+1)*sizeof(char));                //分配当前编码的工作空间
    cd[n-1]='';                                        //从右向左逐位存放编码，首先存放编码结束符

    for(i=1;i<=n;i++)
        hc[i]->data=ht[i].data;

    for(i=1;i<=n;i++)            //求n个叶子结点对应的哈夫曼编码
    {
        start=n-1;                //初始化编码起始指针
        c=i;                    //从叶子结点开始向上倒推
        p=ht[i].parent;
        while(p!=0)
        {
            --start;
            if(ht[p].lchild==c)        
                cd[start]='0';        //左分支标0
            else
                cd[start]='1';        //右分支标1
            c=p;                    
            p=ht[p].parent;            //向上倒推
        }
//        hc[i]=(char *)malloc((n-start)*sizeof(char));        //为第i个编码分配空间
//        strcpy(hc[i],&cd[start]);
        strcpy(hc[i]->cd,&cd[start]);        //把编码复制到hc[i]的cd成员变量中
    }
    free(cd);
}

//打印相应字符对应的哈夫曼编码
void OutPut(HuffmanCode hc,int n)        
{
    int i;
    for(i=1;i<=n;i++)
        printf("%c:%s
",hc[i]->data,hc[i]->cd);
}

//解码
void Decode(HuffmanCode hc,char sc[],int n)
{
    int len,i,j;
    len=strlen(sc);
    for(i=0;i<len;i++)
    {
        for(j=1;j<=n;j++)
        {
            if(hc[j]->data==sc[i])
            {
                printf("%s",hc[j]->cd);
                break;
            }
        }

    }
}

void main()
{
    int w[M+1];            //叶子结点的权值数组w
    int n,i;
    char d[M+1];
    char *sc;
    HuffmanTree ht;        //哈夫曼数组ht
    HuffmanCode hc;        //哈夫曼编码hc
    printf("please input the numbers of leaves: ");
    scanf("%d",&n);            //输入叶子结点数目n
    
    for(i=1;i<=n;i++)
    {
        hc[i]=(CNode *)malloc(sizeof(CNode));
        printf("please input the char and weight of %d:
",i);
        flushall();
        scanf("%c",&d[i]);
        scanf("%d",&w[i]);        //依次输入各叶子结点对应权值
    }

    CrtHuffmanTree(ht,w,d,n);        //创建哈夫曼树
    CrtHuffmanCode(ht,hc,n);    //求哈夫曼编码
    OutPut(hc,n);                //打印哈夫曼编码结果

    flushall();
    printf("按任意键继续...");
    getchar();

    sc=(char *)malloc(M*sizeof(char));
    printf("please input the Source code:");
    flushall();
    scanf("%s",sc);
    Decode(hc,sc,n);

    flushall();
    printf("按任意键继续...");
    getchar();
}

/*

*问题：进阶哈夫曼树的文件实现

*描述：从文件中读取字符集及其权值，构造哈夫曼树，并设计哈弗曼编码，完成给定字符串的解码。

*要求：从文件读入字符集大小n、n个字符和n个权值，建立哈夫曼树，打印每个字符对应的哈夫曼编码，

   将字符集的编码保存到相应的文件中，对终端输入的字符串解码，并显示解码结果。

   哈夫曼树是由n个带权叶子结点构成的所有二叉树中带权路径长度最短的二叉树，又叫最优二叉树。

   树的带权路径长度（WPL）为树中从根到所有叶子结点的各个带权路径长度之和。

   带权路径长度为从树根到某一结点的路径长度（从一个结点到另一个结点所经过的分支数目）与该结点的权的乘积。

*分析：算法步骤

   1、初始化：用给定的n个权值{w1,w2,....wn}对应由n棵二叉树构成的森林F={T1,T2,...,Tn}，其中每一棵二叉树Ti都只有一个权值为wi的根结点，其左右子树为空。

   2、找最小树：在森林F中选择两棵根结点权值最小的二叉树，作为一棵新二叉树的左、右子树，标记新二叉树的根结点权值为其左、右子树的根结点权值之和。

   3、删除和加入：从F中删除被选中的那两棵二叉树，同时把新构成的二叉树加入到森林F中。

   4、判断：重复2、3操作，知道森林中只含有一棵二叉树为止，此时得到的这棵二叉树就是哈夫曼树。

*B Y ：xymaqingxiang

   2014-04-16

*/

  1 #include<stdio.h>
  2 #include<malloc.h>
  3 #include<stdlib.h>
  4 #include<string.h>
  5 #include <conio.h>
  6 
  7 #define MAX 200
  8 #define N 20            //叶子结点的最大值
  9 #define M 2*N-1            //所有结点的最大值
 10 
 11 typedef struct 
 12 {
 13     char data;            //字符
 14     int weight;            //结点的权值
 15     int parent;            //双亲的下标
 16     int lchild;            //左孩子结点的下标
 17     int rchild;            //右孩子结点的下标
 18 }HTNode,HuffmanTree[M+1];    //HuffmanTree是结构数组类型，0号单元不用
 19 
 20 //typedef char * HuffmanCode[N+1];    //存储哈夫曼编码串的头指针的数组
 21 typedef struct
 22 {
 23     char data;            //字符
 24     char cd[M];            //编码
 25 }CNode;
 26 typedef CNode * HuffmanCode[N+1];
 27 
 28 
 29 //在ht[1]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，并将其序号分别赋值给是s1，s2返回
 30 void Select(HuffmanTree ht,int pos,int *s1,int *s2)        
 31 {
 32     int m1,m2,i;
 33     m1=m2=32767;            //给m1、m2赋最大值
 34     for(i=1;i<=pos;i++)        //在ht[1]~ht[i-1]的范围内选择
 35     {
 36         if(ht[i].parent==0&&ht[i].weight<m1)        
 37         {
 38             m2=m1;
 39             m1=ht[i].weight;
 40             *s2=*s1;
 41             *s1=i;
 42         }
 43         else if(ht[i].parent==0&&ht[i].weight<m2)
 44         {
 45             m2=ht[i].weight;
 46             *s2=i;
 47         }
 48     }
 49     if(ht[*s1].weight>=ht[*s2].weight)
 50     {
 51         i=*s1;
 52         *s1=*s2;
 53         *s2=i;
 54     }
 55 
 56    /*if(*s1>*s2)
 57     {
 58         i=*s1;
 59         *s1=*s2;
 60         *s2=i;
 61     }*/
 62 }
 63 
 64 //创建哈夫曼树ht[M+1],w[]存放n个权值
 65 void CrtHuffmanTree(HuffmanTree ht,int w[],char d[], int n)        
 66 {
 67     int s1,s2;
 68     int i,m;
 69     for(i=1;i<=n;i++)                //初始化ht[]----1~n号单元存放叶子结点
 70     {
 71         ht[i].data=d[i];
 72         ht[i].weight=w[i];
 73         ht[i].parent=0;
 74         ht[i].lchild=0;
 75         ht[i].rchild=0;
 76     }
 77     m=2*n-1;                        //所有结点数目
 78     for(i=n+1;i<=m;i++)                //初始化ht[]----n+1~m号单元存放非叶子结点
 79     {
 80         ht[i].weight=0;
 81         ht[i].parent=0;
 82         ht[i].lchild=0;
 83         ht[i].rchild=0;
 84     }
 85     s1=s2=1;
 86     for(i=n+1;i<=m;i++)                //创建非叶结点，建哈夫曼树
 87     {
 88         Select(ht,i-1,&s1,&s2);        //在ht[1]~ht[i-1]的范围内选择两个parent为0且weight最小的结点，并将其序号分别赋值给是s1，s2返回
 89         ht[i].weight=ht[s1].weight+ht[s2].weight;    //标记权值、父子关系
 90         ht[s1].parent=i;
 91         ht[s2].parent=i;
 92         ht[i].lchild=s1;
 93         ht[i].rchild=s2;
 94     }
 95 }
 96 
 97 //从叶子结点到根，逆向求每个叶子结点对应的哈夫曼编码
 98 void CrtHuffmanCode(HuffmanTree ht,HuffmanCode hc,int n)    
 99 {
100     char *cd;
101     int c,i,p,start;
102     cd=(char *)malloc((n+1)*sizeof(char));                //分配当前编码的工作空间
103     cd[n-1]='';                                        //从右向左逐位存放编码，首先存放编码结束符
104 
105     for(i=1;i<=n;i++)            //求n个叶子结点对应的哈夫曼编码
106     {
107         start=n-1;                //初始化编码起始指针
108         c=i;                    //从叶子结点开始向上倒推
109         p=ht[i].parent;
110         while(p!=0)
111         {
112             --start;
113             if(ht[p].lchild==c)        
114                 cd[start]='0';        //左分支标0
115             else
116                 cd[start]='1';        //右分支标1
117             c=p;                    
118             p=ht[p].parent;            //向上倒推
119         }
120         hc[i]=(CNode *)malloc(sizeof(CNode));
121         strcpy(hc[i]->cd,&cd[start]);        //把编码复制到hc[i]的cd成员变量中
122         hc[i]->data=ht[i].data;
123     }
124     free(cd);
125 }
126 
127 //打印相应字符对应的哈夫曼编码
128 void OutPut(HuffmanCode hc,int n)        
129 {
130     int i;
131     for(i=1;i<=n;i++)
132         printf("%c:%s
",hc[i]->data,hc[i]->cd);
133 }
134 
135 //解码
136 void Decode(HuffmanCode hc,char sc[],int n)
137 {
138     int len,i,j;
139     len=strlen(sc);
140     for(i=0;i<len;i++)
141     {
142         for(j=1;j<=n;j++)
143         {
144             if(hc[j]->data==sc[i])
145             {
146                 printf("%s",hc[j]->cd);
147                 break;
148             }
149         }
150 
151     }
152 }
153 
154 //读取文件，得到字符集以及相应的权值
155 int Read(char d[],int w[])
156 {
157     FILE *fp;
158     char filename[20];
159 //    char a[20] = {'0'};
160 //    int b[20] = {0};
161     int i=1;
162     printf("
请输入文件名:");
163     flushall();
164     scanf("%s",filename);
165     fp=fopen(filename,"rt");
166     if(fp==NULL)
167     {
168         printf("写文件出错，按任意键退出！");
169         getch();
170         exit(1);
171     }
172 
173 /*    while(!feof(fp))
174     {
175         fscanf(fp,"%c %d
",&a[i],&b[i]);
176         i++;
177     }*/
178     while(!feof(fp))
179     {
180         fscanf(fp,"%c %d
",&d[i],&w[i]);
181         i++;
182     }
183     d[i]='';
184 //    w[i]='';
185     printf("
文件读取成功！请按任意键退出！
");
186     getch();
187     fclose(fp);
188     return (i-1);
189 }
190 
191 //将字符的权值还有编码保存到相应文件中
192 void Save(char d[], int w[],int n, HuffmanCode hc)
193 {
194     FILE *fp;
195     int i;
196     char filename[20];
197     printf("
请输入要保存规则的文件名：");
198     scanf("%s",filename);
199     fp=fopen(filename,"wt");
200     if(fp==NULL)
201     {
202         printf("写文件出错，按任意键推出！");
203         getch();
204         exit(1);
205     }
206     else
207     {
208         for(i = 1; i <= n; i++)
209             fprintf(fp, "字符%c的编码为：%s，权值为：%d
",d[i],hc[i]->cd, w[i]);//向文件输入内容
210     }
211 
212     printf("
文件成功保存！请按任意键退出！
");
213     getch();
214     fclose(fp);
215 }
216 
217 void main()
218 {
219     int w[MAX] = {0};            //叶子结点的权值数组w
220     int n,i;
221     char d[MAX] = {'0'};
222     char *sc;
223     HuffmanTree ht;        //哈夫曼数组ht
224     HuffmanCode hc;        //哈夫曼编码hc
225     
226 /*    printf("please input the numbers of leaves: ");
227     scanf("%d",&n);            //输入叶子结点数目n
228     for(i=1;i<=n;i++)
229     {
230     //    hc[i]=(CNode *)malloc((n+1)*sizeof(CNode));
231         hc[i]=(CNode *)malloc(sizeof(CNode));
232         printf("please input the char and weight of %d:
",i);
233         flushall();
234         scanf("%c",&d[i]);
235         scanf("%d",&w[i]);        //依次输入各叶子结点对应权值
236     }
237 */
238 
239     n=Read(d, w);
240 
241     CrtHuffmanTree(ht,w,d,n);        //创建哈夫曼树
242     CrtHuffmanCode(ht,hc,n);    //求哈夫曼编码
243     OutPut(hc,n);                //打印哈夫曼编码结果
244 
245     Save(d, w, n, hc);
246 
247     flushall();
248     printf("按任意键继续...");
249     getchar();
250 
251     sc=(char *)malloc(M*sizeof(char));
252     printf("please input the Source code:");
253     flushall();
254     scanf("%s",sc);
255     Decode(hc,sc,n);
256 
257     flushall();
258     printf("按任意键继续...");
259     getchar();
260 }

（4）最优服务次序问题

/*

基础最优服务次序问题

1、问题描述：
设有n 个顾客同时等待一项服务。顾客i需要的服务时间为ti ,1 ≤i≤n。应如何安排n 个顾客的服务次序才能使平均等待时间达到最小 平均等待时间是n 个顾客等待服务时间的总和除以n。对于给定的n个顾客需要的服务时间，编程计算最优服务次序。
2、题目分析：
考虑到每个顾客需要的服务时间已给定，要计算最优服务次序，可以先对顾客需要的服务时间由短到长排序，再采用贪心算法求解。
3、算法设计：
a. 定义数组a[n]存储n个顾客需要的服务时间；
b. 调用库函数sort(a,a+n)对顾客需要的服务时间由短到长排序；
c. 函数time()计算最小平均等待时间，采用while循环依次对顾客等待服务时间进
行累加，用a[i]标记第i+1个顾客需要的服务时间，用b[i]计算第i+1个顾客的等待服务
时间，用t计算前i+1个顾客等待服务时间的总和（初始i=1, t=a[0],b[0]=a[0]）：
① b[i]=a[i]+b[i-1]，t=b[i]+t；
② i++；
③ i=n时循环结束；
d. t/n为所求。

4、算法分析：
函数time()的时间杂度为Ο(n)，主函数调用的库函数sort(a,a+n)的时间复杂度为，且主函数调用函数time()，故该算法的时间杂度为。

*B Y ：xymaqingxiang

   2014-04-17

*/

 

/*

*问题：多处最优服务次序问题的实现

*描述：设有n 个顾客同时等待一项服务。顾客i需要的服务时间为ti ,1 ≤i≤n。共有s处可以提供此项服务。

   应如何安排n 个顾客的服务次序才能使平均等待时间达到最小，平均等待时间是n 个顾客等待服务时间的总和除以n。

   对于给定的n个顾客需要的服务时间，编程计算最优服务次序。

*分析：考虑到每个顾客需要的服务时间已给定，要计算多处最优服务次序，可以先对顾客需要的服务时间由短到长排序，最短服务时间优先，即采用贪心算法求解。

   即按照服务时间排好序，分治，每次都按从0到s依序进入需要服务的顾客，并且一定是从0到s开始服务结束时换人。

*B Y ：xymaqingxiang

   2014-04-17

*/

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) 
{
    return (*(int *)a - *(int *)b);
}

int main()
{
    int i = 0, j = 0; //控制程序流程
    int n, s; //n：顾客数目； s：服务处数目
    double t = 0; //统计最终的平均等待时间
    int a[100]; //记录各个顾客的服务时间
    int st[100] = {0}; //S个服务处服务时间记录
    printf("请输入顾客（n）和服务处数目（s）：");
    scanf("%d%d", &n, &s); //输入顾客数目和服务处数目
    printf("
请输入各个顾客的服务时间a：
");
    for(i = 0; i < n; i++) //依次输入各个顾客服务时间
        scanf("%d", &a[i]);
    qsort(a,n,sizeof(a[0]),cmp); //排序函数--快排思想
    i=0;
    while(i < n)
    {
        st[j] +=a [i];
        t += st[j];
        i++;
        j++;
        if(j == s)
            j = 0;
    }
    printf("
平均等待时间：");
    printf("%.f
",t/n);
    flushall();
    printf("按任意键继续...");
    getchar();
    return 0;
}

（5）最小生成树

问题：求得连通图的最小生成树，使其各边代价之和最小

描述：

一个连通图的生成树是指一个极小连通子图，它包含图中的全部顶点，但只有足以构成一棵树的n-1条边。

在一个连通网的所有生成树中，各边的代价之和最小的那棵生成树称之为该连通网的最小代价生成树，简称最小生成树（MST）。

分析：用贪心算法设计策略构造最小生成树

  Prim算法 + Kruskal算法

设G=（V,E）是连通带权图，V={1,2, . . . , n }。

a、Prim算法——加点法

算法基本思想：首先置S={1}，然后，只要S是V的真子集，做如下的贪心选择：选取满足条件i属于S，j属于V-S，且c[i][j]最小的边，并将顶点j添加到S中，这个过程一直进行到S=V时为止。

b、Kruskal算法——加边法

算法基本思想：首先将G的n个顶点看成是n个孤立的连通分支，将所有的边按权从小到大排序。然后从第一条边开始，依边权递增的顺序查看每一条边，并按照下述方法连接两个不同的连通分支：当查看到第k条边（v,w），如果端点v、w分别是当前两个不同的连通分支T1和T2中的顶点时，就用边（v,w）将T1和T2连接成一个连通分支，然后继续查看第k+1条边；如果端点v和w在当前的同一个连通分支中，就直接再查看第k+1条边。这个过程一直进行到只剩下一个连通分支时为止。

Kruskal算法中按权的递增顺序查看边的序列可以看做是一个优先队列，它的优先级为边权。顺序查看就是对这个优先队列执行DeleteMin运算。

在Kruskal算法中，需要对由连通分支组成的集合不断的进行修改，Union（a,b）即将两个联通分支连接起来，Find（v）返回包含顶点v的连通分支的名字。

（5）最大边权值最小的生成树

 /*

 问题：（有向+无向）图的连通性（遍历实现） 

 描述： 用邻接矩阵实现: 

实现图的深度优先遍历和广度优先遍历,并输出。

用BFS、DFS判断图的连通性

 */

//拓展

 /*

*问题：生成树问题

*描述：试设计一个构造图G生成树的算法，使得构造出的生成树的边的最大权值达到最小。

*分析：考虑到每条边的权值已给定，要使生成树的边中的最大权值达到最小，可以先对图中的边由大到小排序，再采用贪心算法求解。

*设计：a. 定义数组a[n]存储n条边的权值；

   b. 调用库函数sort(a)对边的权值按由大到小排序；

   c. 依次删除权值最大的边，并判断树是否连通，

  ① 若连通，则继续c；

  ② 若不连通，则结束；

   d. 此时的a[i]即为所求。

*B Y ：xymaqingxiang

   2014-04-16

   **存在问题：边信息数组没有实时更新

*/

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>

#define MAX 20
//#define INFINITY 32768
#define False 0
#define True 1

int count_d;        //DFS中遍历过程中点的统计计数
int visited[MAX];    //访问标记数组

typedef enum {DG,DN,UDG,UDN} Graphkind;     //图的种类 
typedef char VertexData;        //假设顶点数据类型为字符型
typedef int AdjType;            //权值为整型--int型
typedef struct ArcNode            //定义邻接矩阵ArcNode
{
    AdjType adj;                //对于无权图，1表示相邻，0则相反
//    OtherInfo info
}ArcNode;

typedef struct data                //边信息数组
{
    VertexData v1;                //边的顶点
    VertexData v2;                //边的顶点
    int weight;                    //权值
}Data;

typedef struct        //
{
    VertexData vertex[MAX];        //顶点数组
    ArcNode arcs[MAX][MAX];        //邻接矩阵
    int vexnum,arcnum;            //图的顶点数和弧数
    Graphkind kind;                //图的种类标志
    Data info[MAX];
}AdjMatrix;

typedef struct Node        //节点类型
{
    int data;            //数据域
    struct Node *next;    //指针域
}QNode;       
typedef struct            //队列类型
{
    QNode *front;        //队头
    QNode *rear;        //队尾
}LinkQueue;

int InitQueue(LinkQueue *Q)        //队列初始化
{
    Q->front=(QNode*)malloc(sizeof(QNode));
    if(Q->front==NULL)
    {
        printf("malloc error!
");
        return False;
    }
    Q->front->next=NULL;
    Q->rear=Q->front;
    return True;
}
int EnterQueue(LinkQueue *Q,int x)        //入队操作--将元素x插入到队列Q中
{
    QNode *s;
    s=(QNode*)malloc(sizeof(QNode));
    if(s==NULL)
    {
        printf("malloc error!
");
        return False;
    }
    s->data=x;
    s->next=NULL;
    Q->rear->next=s;
    Q->rear=s;
    return True;
}
int DeleteQueue(LinkQueue *Q,int *x)    //出队操作--将队列Q的队头元素出队，并存放到x所指的存储空间中
{
    QNode *p;
    if(Q->front==Q->rear)
    {
        printf("queue is empty!
");
        return False;
    }
    p=Q->front->next;
    Q->front->next=p->next;
    *x=p->data;
    free(p);
    if(Q->front->next==NULL)
        Q->rear=Q->front;
    return True;
}
int Empty(LinkQueue *Q)        //将队列置空
{
    if(Q->front==Q->rear)
        return True;
    return False;
}

int Locate(AdjMatrix *g,VertexData v)    //求顶点位置
{
    int j=False,k;
    for(k=0;k<g->vexnum;k++)
        if(g->vertex[k]==v)
        {
            j=k;
            break;
        }
    return j;    
}

void CreateDN(AdjMatrix *g)        //创建有向图
{
    int i,j,k;
    VertexData v1,v2;
    printf("please input arcnum vexnum :
");
    scanf("%d %d",&g->arcnum,&g->vexnum);
    for(i=0;i<g->vexnum;i++)
        for(j=0;j<g->vexnum;j++)
            g->arcs[i][j].adj=0;
    for(i=0;i<g->vexnum;i++)
    {
        printf("please input vertex %d/%d:",i+1,g->vexnum);
        flushall();
        scanf("%c",&g->vertex[i]);
        printf("
");
    }
    for(k=0;k<g->arcnum;k++)
    {
        printf("please input arc %d/%d:",k+1,g->arcnum);
        flushall();
        scanf("%c%c",&v1,&v2);
        i=Locate(g,v1);
        j=Locate(g,v2);
        g->arcs[i][j].adj=1;
    }

}

void CreateUDN(AdjMatrix *g)        //创建无向图
{
    int i,j,k;
    int w;
//    VertexData v1,v2;
    printf("please input arcnum vexnum :
");        //输入图的弧数、顶点数
    scanf("%d %d",&g->arcnum,&g->vexnum);    
    for(i=0;i<g->vexnum;i++)            //初始化邻接矩阵
        for(j=0;j<g->vexnum;j++)
            g->arcs[i][j].adj=0;
    for(i=0;i<g->vexnum;i++)        //输入图的顶点信息
    {
        printf("please input vertex %d/%d:",i+1,g->vexnum);
        flushall();        //清空缓存区
        scanf("%c",&g->vertex[i]);
        printf("
");
    }

    for(k=0;k<g->arcnum;k++)    //输入一条弧的两个顶点
    {
        printf("please input arc %d/%d:",k+1,g->arcnum);
        flushall();
//        scanf("%c%c",&v1,&v2);

        scanf("%c%c",&g->info[k].v1,&g->info[k].v2);
        scanf("%d",&g->info[k].weight);
        i=Locate(g,g->info[k].v1);            //得到两个顶点的位置
        j=Locate(g,g->info[k].v2);
        g->arcs[i][j].adj=g->info[k].weight;    //建立弧
        g->arcs[j][i].adj=g->info[k].weight;    //建立弧
    }

}


//添加边
void Addarc(AdjMatrix *g,int k)
{
    int i,j;
    i=Locate(g,g->info[k].v1);            //得到两个顶点的位置
    j=Locate(g,g->info[k].v2);
    g->arcs[i][j].adj=g->info[k].weight;    //恢复弧
    g->arcs[j][i].adj=g->info[k].weight;    //恢复弧
    g->arcnum+=g->arcnum;
}

//删除一条边
void Delarc(AdjMatrix *g,int k)
{
    int i,j;
    i=Locate(g,g->info[k].v1);            //得到两个顶点的位置
    j=Locate(g,g->info[k].v2);
    g->arcs[i][j].adj=0;            //删除弧
    g->arcs[j][i].adj=0;            //删除弧
    g->arcnum-=g->arcnum;
}

void DFS(AdjMatrix g,int i)        //深度优先遍历
{
    int j;
    printf("%c ",g.vertex[i]);
    count_d++;
    visited[i]=True;
    for(j=0;j<g.vexnum;j++)
        if(!visited[j]&&g.arcs[i][j].adj!=0)
            DFS(g,j);
}
int TraverseD(AdjMatrix g)
{
    int i;
    count_d=0;
    for(i=0;i<g.vexnum;i++)
        visited[i]=False;
    i=0;
//    for(i=0;i<g.vexnum;i++)
        if(!visited[i])
            DFS(g,i);
    if(count_d==g.vexnum)
        return True;
    else 
        return False;    
}

int BFS(AdjMatrix g,int i)     //广度优先遍历
{
    int j,k;
    int count;
    LinkQueue q;
    printf("%c ",g.vertex[i]);
    visited[i]=True;
    count=1;
    InitQueue(&q);
    EnterQueue(&q,i);
    while(!Empty(&q))
    {
        DeleteQueue(&q,&k);
        for(j=0;j<g.vexnum;j++)
        {
            if(!visited[j]&&g.arcs[k][j].adj!=0)
            {
                printf("%c ",g.vertex[j]);
                visited[j]=True;
                count++;
                EnterQueue(&q,j);
            }
        }
    }
    if(count==g.vexnum)
        return True;
    else 
        return False;
}
int TraverseB(AdjMatrix g)
{
    int i,f;
    for(i=0;i<g.vexnum;i++)
        visited[i]=False;
    i=0;
//    for(i=0;i<g.vexnum;i++)
        if(!visited[i])
            f=BFS(g,i);
    if(f==1)
        return True;
    else 
        return False;
}

//确定由大到小排序
int cmp(const void *a, const void *b) 
{
    return (*(int *)b - *(int *)a);
}

//冒泡排序实现
void sort(AdjMatrix *g)
{
    int i,j;
    int t;
    VertexData v1,v2;
    for(i=0;i<g->arcnum;i++)
    {
        for(j=0;j<g->arcnum;j++)
            if(g->info[j].weight<g->info[j+1].weight)
            {
                t=g->info[j].weight;
                v1=g->info[j].v1;
                v2=g->info[j].v2;

                g->info[j].weight=g->info[j+1].weight;
                g->info[j].v1=g->info[j+1].v1;
                g->info[j].v2=g->info[j+1].v2;

                g->info[j+1].weight=t;
                g->info[j+1].v1=v1;
                g->info[j+1].v2=v2;
            }
    }

}

void main()
{
    int i,j;
    int b,d;        //返回值判断标志位

    AdjMatrix g;    //无向图
    CreateUDN(&g);

//    AdjMatrix g;    //有向图
//    CreateDN(&g);

    printf("
");

    for(i=0;i<g.vexnum;i++)        //打印邻接矩阵信息
    {
        for(j=0;j<g.vexnum;j++)
        {
            printf("%d",g.arcs[i][j].adj);
        }
        printf("
");
    }

    printf("
");

    printf("BFS:");                //BFS:首先判断图是否连通，不连通则退出
    b=TraverseB(g);
    if(b==1)
        printf("
BFS---连通");
    else
    {
        printf("
BFS---不连通,不存在生成树");
        exit(0);
    }

    printf("
");

    printf("DFS:");            //DFS:首先判断图是否连通，不连通则退出
    d=TraverseD(g);
    if(d==1)
        printf("
DFS---连通");
    else
    {
        printf("
DFS---不连通,不存在生成树");
        exit(0);
    }

    printf("
");
    
    //对图的边按照权值由大到小排序 ——————有问题
//    qsort(g.info,g.arcnum,sizeof(g.info[0]),cmp); //排序函数--快排思想
    sort(&g);

    printf("
");

    //打印边的信息数组，检查排序效果
    for(i=0;i<g.arcnum;i++)
        printf("%d ",g.info[i].weight);

    printf("

");

    //求解生成树
    j=g.arcnum;
    for(i=0;i<j;i++)
    {
        Delarc(&g,i);        //依次删除最大边并判断图的连通性
        printf("
BFS:");
        b=TraverseB(g);
        if(b!=1)
            Addarc(&g,i);
    }

    printf("
");


    //打印最终的邻接矩阵
    for(i=0;i<g.vexnum;i++)
    {
        for(j=0;j<g.vexnum;j++)
        {
            printf("%d",g.arcs[i][j].adj);
        }
        printf("
");
    }

    getchar();
}