贪心算法（活动安排问题）——算法小白学习篇

最新推荐文章于 2025-04-05 15:57:42 发布

Java展博

最新推荐文章于 2025-04-05 15:57:42 发布

阅读量1.2k

点赞数 9

分类专栏：算法小白学习篇文章标签： c++ 算法贪心算法

本文链接：https://blog.csdn.net/m0_74849460/article/details/144705412

版权

算法小白学习篇专栏收录该内容

1 篇文章

订阅专栏

贪心算法

1、算法思想

顾名思义，贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。

当然，希望贪心算法得到的最终结果也是整体最优的。虽然贪心算法不能对所有问题都得到整体最优解，但对许多问题它能产生整体最优解。如单源最短路经问题，最小生成树问题等。

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

2、算法基本要素

对于一个具体的问题，怎么知道是否可用贪心算法解此问题，以及能否得到问题的最优解呢?这个问题很难给予肯定的回答。但是，从许多可以用贪心算法求解的问题中看到这类问题一般具有2个重要的性质：贪心选择性质和最优子结构性质。

贪心选择性质：

所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。动态规划算法通常以自底向上的方式解各子问题，而贪心算法则通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。

最优子结构性质：

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

理解该算法思想和性质后，我们开始做题学习，我们选择活动安排问题讲解。

3、问题讲解

活动安排问题

设有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相容。

4、实现过程：

该问题要求高效地安排一系列争用某一公共资源的活动，即在所给的活动集合中选出最大的相容活动子集合。

采用贪心算法，贪心算法提供了一个简单、漂亮的方法使得尽可能多的活动能兼容地使用公共资源。

即使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

eg：

由于贪心算法解决安排问题要考虑么个活动的结束时间，所以先将活动按照结束时间长短进行递增排序。本贪心算法在处理非减序排列活动队列时可以达到极高的效率。

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

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

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

贪心算法的计算过程如下图所示，图中每行相应于算法的一次迭代

图中每行相应于算法的一次迭代。阴影长条表示的活动是已选入集合A的活动，而空白长条表示的活动是当前正在检查相容性的活动。

代码：

 #include<iostream>
 #include<iomanip>
 #define N 100
 
 using namespace std;
 int s[N];
 int f[N];
 int A[N];
 int Partition(int* b, int* a, int p, int r);
 void QuickSort(int* b, int* a, int p, int r);
 void GreedySelector(int n, int* s, int* f, int* A);
 
 int  main()
 {
     int n, i;
     cout << "请输入活动的个数,n=";
     cin >> n;
     cout << "请分别输入开始时间s[i]和结束时间f[i]:" << endl;
     for (i = 1; i <= n; i++)
     {
         cout << "s[" << i << "]=";
         cin >> s[i];
         cout << "f[" << i << "]=";
         cin >> f[i];
         cout << endl;
     }
     QuickSort(s, f, 1, n); 
     cout << "按结束时间非减序排列如下:" << endl; 
     cout << "      " << "序号  开始时间  结束时间" << endl;
     cout << "-------------------------" << endl;
     for (i = 1; i <= n; i++)
         cout << setw(8) << i << setw(8) << s[i] << setw(8) << f[i] << endl;
     cout << "-------------------------" << endl;
     GreedySelector(n, s, f, A);
     cout << "安排的活动序号依次为：" << endl;
     for (i = 1; i <= n; i++)
     {
         if (A[i])
             cout << i << setw(4) << s[i] << "-->" << f[i] << endl;
     }
     cout << endl;
     system("pause");
     return 0;
 }
 
 void QuickSort(int* b, int* a, int p, int r)
 {
     if (p < r)
     {
         int q = Partition(b, a, p, r);
         QuickSort(b, a, p, q - 1);/*对左半段排序*/
         QuickSort(b, a, q + 1, r);/*对右半段排序*/
     }
 }
 
 //产生中间数
 int Partition(int* b, int* a, int p, int r)
 {
     int k, m, i = p, j = r + 1;
     int x = a[p], y = b[p];
     while (1)
     {
         while (a[++i] < x);
         while (a[--j] > x);
         if (i >= j)
             break;
         else
         {
             k = a[i]; a[i] = a[j]; a[j] = k;
             m = b[i]; b[i] = b[j]; b[j] = m;
         }
     }
     a[p] = a[j];
     b[p] = b[j];
     a[j] = x;
     b[j] = y;
     return j;
 }
 
 
 
 void GreedySelector(int n, int* s, int* f, int* A)
 {
     
     A[1] = true;  
     int j = 1;  
     for (int i = 2; i <= n; i++)
     {
         if (s[i] >= f[j])
         {
             A[i] = true; 
             j = i;
         }
         else A[i] = false;
     }
 }

运行结果：