算法导论第16章 贪心算法之活动选择

问题描述：

假定有一个n个活动的集合S = {a1, a2, ...., an}, 这些活动使用同一个资源，而这个资源在某一刻只能供一个活动使用。每个活动ai有一个开始时间si和结束时间fi， 0 ≤ si < fi < +∞.

如果被选中，任务ai发生在半开时间区间[si, fi)。 如果两个活动ai， aj满足[si, fi), [sj, fj）不重叠，则他们是兼容的。即若si ≥ fj 或 sj ≤ fi，则ai， aj是兼容的

在活动选择中，我们希望选出一个最大兼容活动集，假定活动已按结束时间的单调递增顺序排序：f1 ≤ f2 ≤ f3 ≤....≤ fn-1 ≤ fn 

该问题有最优子结构，可以用动态规划算法求解，但是动态规划会求解所有子问题，但对于选择问题，可以只考虑一个选择，贪心选择。即每次都选择剩下的集合当中结束时间最早的活动。

定理16.1： 考虑任意非空子问题Sk， 令am是Sk中结束时间最早的活动，则am在Sk的某个最大兼容活动子集中。

贪心算法通常是自顶向下的设计：做出一个选择，然后求解剩下的那个子问题，而不是自底向上的求出很多子问题，然后再做出选择（这是动态规划常用的方法）

#include <iostream>
using namespace std;

/************************************************************************/
/* 递归法, 共有n个活动,为了方便算法初始化，
   添加了一个虚拟活动a0，结束时间为f0=0
   输入：
   start[]：每个活动的开始时间， final[]: 每个活动的结束时间
   k: 要求解的子问题，nn：问题的规模
   过程中打印符合条件的活动
   与ak活动兼容的活动的条件是：start[m] > final[k]
   活动的开始时间比ak的结束时间靠后 */
/************************************************************************/
void recursiveActivitySelector(int *start, int *final, int k, int n)
{
	int m = k+1;
	//找出符合条件的活动
	while (m <= n && start[m] < final[k])
        m++;
	if (m <= n)
	{
		cout << "a" << m << " ";
		recursiveActivitySelector(start, final, m, n);
	}
	else
		cout << " " << endl;
}

/************************************************************************/
/* 递归版的迭代版本
   输入：start[]：每个活动的开始时间， final[]: 每个活动的结束时间
   过程中打印符合条件的活动
   与ak活动兼容的活动的条件是：start[m] > final[k]
   活动的开始时间比ak的结束时间靠后
   */
/************************************************************************/
void greedyActivitySelector(int *start, int *final, int n)
{
	cout << "a1 ";
	int k = 1;
	for (int m = 2; m <= n; m++)
	{
		//找出符合条件的活动
		if (start[m] > final[k])
		{
			cout << "a" << m << " ";
			k = m;
		}
	}
	cout << endl;
}

int main()
{
	int start[] = {-1, 1, 3, 0, 5, 3, 5, 6, 8, 8, 2, 12};
	int final[] = {0, 4, 5, 6, 7, 9, 9, 10, 11, 12, 14, 16};

	cout << "递归法求活动：";
	recursiveActivitySelector(start, final, 0, 11);
	cout << "迭代的贪心算法：";
	greedyActivitySelector(start, final, 11);

	system("pause");
	return 0;
}

贴上一张图：递归算法的求解过程，很详细

在输入活动已按结束时间排序的情况下，这两个算法的运行时间都为Θ（n）

运行结果为：