一.问题的描述

学校的小礼堂每天都会有许多活动，有时间这些活动的计划时间会发生冲突，需要选择出一些活动进行举办。小刘的工作就是安排学校小礼堂的活动，每个时间最多安排一个活动。
现在小刘有一些活动计划的时间表，他想尽可能的安排更多的活动，请问他该如何安排才可以安排更多的活动。
具体的示例如下所示：

二.问题的分析

1.贪心算法的基本思想：
贪心算法在对问题进行求解的时候，总是做出当前看来是最好的选择，它会不从整体的最优进行考虑，而是得到在某种意义上的局部最优解，而且贪心算法不是对所有的问题都能得到整体的最优解，关键是贪心策略的的选择。不从整体上的最优加以考虑，做出的只是在某种意义上的局部最优解，贪心法中推进的每一步不是依据某一固定的递推式，而是当前看似最佳的贪心决策，不断的将问题归纳为更加小的相似的子问题，最后当初的大问题只剩下了一个最简单的小问题。
2.本题解决思路：
由于输入的活动以其完成的时间是非减序的排列，所以贪心算法每次都是选择具有最早完成时间的相容活动加入我们最终的输出序列中，按照这种方法选择相容的活动可以为没有安排的活动留下更多的时间。
3、具体的算法流程描述：

（1）输入我们需要进行安排的活动的数目n，以及依次输入每个待排序活动的开始时间和结束时间，将它们分别存放在数组s[ ]和f[ ]中。
（2）分别定义存放开始时间和结束时间的数组，使用排序将结束时间按照从小到大的顺序进行排列，得到最初排列好的数组。
（3）以排列后的第一个数组的结束时间为基准，依次在已排序的数列中找开始时间和结束时间不发生冲突的活动进行安排，最后输出安排好的活动。

三、源程序清单

编译环境：Dev C++

/*///测试数据/
请输入待排序的活动数目：
11
请依次输入每个活动的开始时间和结束时间：
3 8 0 6 3 5 8 11 6 10 8 12 5 7 2 13 1 4 12 14 5 9
/运行结果// 
排序后的活动为：
(1, 4)  (3, 5)  (0, 6)  (5, 7)  (3, 8)  (5, 9)  (6, 10) (8, 11) (8, 12) (2, 13) (12, 14)
活动的具体安排如下所示：
(1, 4)  (5, 7)  (8, 11) (12, 14)
*/
#include "stdio.h"
#include "stdlib.h"
//函数的声明 
void merge(int *s, int *f, int p, int q, int r);//使用归并进行排序 
void sort(int *s, int *f, int p, int r);//对每个活动的终止时间进行排序 
void active(int *s, int *f, int *b, int n, int &count);//设置活动安排函数 
//其中数组b中存放的是标志0和1，显示活动是否被安排，如果活动被安排，就显示1，否则，显示0. 
int main()//主函数
{
    
   int i, n, count = 0;//count 记录入围的活动数目，n是我们需要输入的总的活动个数 
   printf("请输入待排序的活动数目：\n"); 
   scanf("%d", &n);//输入待排序的活动的数目 
   int *s = (int *)malloc(sizeof(int) * n);
   int *f = (int *)malloc(sizeof(int) * n);
   int *b = (int *)malloc(sizeof(int) * n);//为数组分配相应大小的空间，记录入围的活动下标；
   printf("请依次输入每个活动的开始时间和结束时间：\n");
   for(i = 0; i < n; i++)
   {
    
      scanf("%d%d", &s[i], &f[i]);//将活动的时间分别存到两个数组中 
	  b[i] = 0;
   }
   printf("排序后的活动为：\n"); 
   active(s, f, b, n, count);//显示最终排序后活动的结果 
   printf("活动的具体安排如下所示：\n");
   for(i = 0; i < count; i++)
   {
    
     printf("(%d, %d)\t", s[b[i]], f[b[i]]);//输出最终安排的活动 
   }
   printf("\n");
   return 0;
}

void merge(int *s, int *f, int p, int q, int r)//归并排序 
{
    
   int i, j, k;
   int n1 = q - p + 1;
   int n2 = r - q;
   int *ls = (int *)malloc(sizeof(int) * (n1 + 1));
   int *lf = (int *)malloc(sizeof(int) * (n1 + 1));
   int *rs = (int *)malloc(sizeof(int) * (n2 + 1));
   int *rf = (int *)malloc(sizeof(int) * (n2 + 1));//分别为数组分配相应的空间 
   for(i = 0; i < n1; i++)
   {
    
      ls[i] = s[p + i];
	  lf[i] = f[p + i];
   }
   ls[i] = 0;
   lf[i] = 24;//规定范围（时间在0-24范围之内）
   for(i = 0; i < n2; i++)
   {
    
     rs[i] = s[q + 1 + i];
	 rf[i] = f[q + 1 + i];
   }
   rs[i] = 0;
   rf[i] = 24;//规定范围（时间在0-24范围之内） 
   i = 0;
   j = 0;
   for(k = p; k <= r; k++)
   {
    
      if(lf[i] >= rf[j])
	  {
    
	     s[k] = rs[j];
		 f[k] = rf[j];//如果左边的时间数字大于右边，则交换位置 
		 j++;
	  }
	  else
	  {
    
	    s[k] = ls[i];
		f[k] = lf[i];	
		i++;
	  }
   }
}

void sort(int *s, int *f, int p, int r)
{
    
   if(p < r)
   {
    
      int q = ( p + r) / 2;
	  sort(s, f, p, q);//利用递归将活动的结束时间分别进行排序 
	  sort(s, f, q + 1, r);
	  merge(s, f, p, q, r);//使用一次归并排序 
   }
}

void active(int *s, int *f, int *b, int n, int &count)
{
    
   int i, j = 0;
   sort(s, f, 0, n-1);//首先对结束时间进行排序 
   for(i = 0; i < n; i++)
   {
    
      printf("(%d, %d)\t", s[i], f[i]);//输入将结束时间由小到大排列好的所有活动 
   }
   printf("\n");
   b[0] = 0;//数组b显示的是标志0和1 
   count = 1;//计数 
   for(i = 1; i < n; i++)
   {
    
     if(s[i] >= f[b[count - 1]])
	 {
    
	   b[count++] = i;
	 }
   }
}

四.运行结果

五.总结

贪心算法，在求解过程中，并不追求全局最优解，而是追求每一步的最优，所以贪心算法也不保证一定能够获得全局最优解，但是贪心算法在很多问题上可以求得最优解。
贪心算法选择的是在每一步的当前选择看来最好的那一个，它是逐步将问题简化，从而最终也只会剩余一个子问题，针对活动选择问题，我们一开始有n个活动，所以我们事先要选择结束最早的那个活动，这样才可以为接下来的活动腾出更多的时间来安排。