算法设计分析第五章贪心算法

贪心算法

在求最优解问题的过程中，依据某种贪心标准，从问题的初始状态出发，直接去求每一步的最优解，通过若干次的贪心选择，最终得出整个问题的最优解，这种求解方法就是贪心算法。
从贪心算法的定义可以看出，贪心算法不是从整体上考虑问题，它所做出的选择只是在某种意义上的局部最优解，而由问题自身的特性决定了该题运用贪心算法可以得到最优解。
如果一个问题可以同时用几种方法解决，贪心算法应该是最好的选择之一。

• 活动安排问题：

活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合，是可以用贪心算法有效求解的很好例子。
该问题要求高效地安排一系列争用某一公共资源的活动。
贪心算法提供了一个简单、漂亮的方法使得尽可能多的活动能兼容地使用公共资源。

struct action{
	int s;			//起始时间
	int f;			//结束时间
	int index;		//活动的编号
};
action a[1000];

排序比较因子：

bool cmp(const action &a, const action &b)
{
	if (a.f<=b.f) return true;
	return false;
}

void GreedySelector(int n, action a[], bool b[])
{
　　b[1] = true;　　　　　//第1个活动是必选的
　　//记录最近一次加入到集合b中的活动
　　int preEnd = 1;
　　for(int i=2; i<=n; i++)
　　　　if (a[i].s>=a[preEnd].f)
　　　　{
　　　　　　b[i] = true;
　　　　　　preEnd = i;
　　　　}
}

贪心算法理论基础：

• 贪心算法是一种在每一步选择中都采取在当前状态下最好或最优的选择，希望得到结果是最好或最优的算法。
  贪心算法是一种能够得到某种度量意义下的最优解的分级处理方法，通过一系列的选择得到一个问题的解，而它所做的每一次选择都是当前状态下某种意义的最好选择。即希望通过问题的局部最优解求出整个问题的最优解。
  这种策略是一种很简洁的方法，对许多问题它能产生整体最优解，但不能保证总是有效，因为它不是对所有问题都能得到整体最优解。
  利用贪心策略解题，需要解决两个问题：
  （1）该题是否适合于用贪心策略求解；
  （2）如何选择贪心标准，以得到问题的最优/较优解。

贪心选择性质：
贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。
这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。
（1）在动态规划算法中，每步所做的选择往往依赖于相关子问题的解，因而只有在解出相关子问题后，才能做出选择。
（2）在贪心算法中，仅在当前状态下做出最好选择，即局部最优选择，然后再去解出这个选择后产生的相应的子问题。
贪心算法求解过程：
使用贪心算法求解问题应该考虑如下几个方面：
（1）候选集合A：为了构造问题的解决方案，有一个候选集合A作为问题的可能解，即问题的最终解均取自于候选集合A。
（2）解集合S：随着贪心选择的进行，解集合S不断扩展，直到构成满足问题的完整解。
（3）解决函数solution：检查解集合S是否构成问题的完整解。
（4）选择函数select：即贪心策略，这是贪心法的关键，它指出哪个候选对象最有希望构成问题的解，选择函数通常和目标函数有关。
（5）可行函数feasible：检查解集合中加入一个候选对象是否可行，即解集合扩展后是否满足约束条件。
一般流程

//A是问题的输入集合即候选集合
Greedy(A)
{
　　S={ };　　　　　　　　　　　//初始解集合为空集
　　while (not solution(S))　　//集合S没有构成问题的一个解
　　{
　　　　x = select(A);　　　　　//在候选集合A中做贪心选择
　　　　if feasible(S, x)　　　　//判断集合S中加入x后的解是否可行
　　　　　　S = S+{x};
　　　　　　A = A-{x};
　　}
　　return S;
｝

经典例题：

• 背包问题

给定一个载重量为M的背包，考虑n个物品，其中第i个物品的重量 ，价值wi （1≤i≤n），要求把物品装满背包，且使背包内的物品价值最大。
有两类背包问题（根据物品是否可以分割），如果物品不可以分割，称为0—1背包问题（动态规划）；如果物品可以分割，则称为背包问题（贪心算法）。

struct bag{
	int w;			//物品的重量
	int v;			//物品的价值
	double c;		//性价比
}a[1001];			//存放物品的数组
bool cmp(bag a, bag b){
	return a.c >= b.c;
}
//形参n是物品的数量，c是背包的容量M，数组a是按物品的性价比降序排序
double knapsack(int n, bag a[], double c)
{
　　double cleft = c;　　　　　　　　//背包的剩余容量
　　int i = 0;
　　double b = 0;　　　　　　　　　　//获得的价值
　　//当背包还能完全装入物品i
　　while(i<n && a[i].w<cleft)
　　{
　　　　cleft -= a[i].w;
　　　　b += a[i].v;
　　　　i++;
　　}
　　//装满背包的剩余空间
　　if (i<n) b += 1.0*a[i].v*cleft/a[i].w;
　　return b;
}
struct load {
	int index;		//集装箱编号
	int w;			//集装箱重量
}box[1001];
bool cmp (load a, load b) {
	if (a.w<b.w) return true;
	else return false;
}
while (scanf("%d%d", &c, &n)!=EOF)
{
　　memset(box, 0, sizeof(box));
　　memset(x, 0, sizeof(x));
　　for (int i=1; i<=n; i++) 
　　{
　　　　scanf("%d", &box[i].w);
　　　　box[i].index = i;
　　}
　　//按集装箱的重量升序排序
　　stable_sort(box, box+n+1, cmp);
　　if (box[1].w>c) {
　　　　printf("No answer!\n");
　　　　continue;
　　}
　//贪心算法的实现，重量最轻者先装载
　　int i;
　　for (i=1; i<=n && box[i].w<=c; i++)
　　{
　　　　x[box[i].index] = 1;
　　　　c -= box[i].w;
　　}
　　//输出装载的集装箱数量
　　printf("%d\n", i-1);
　　//输出装载的集装箱编号
　　for (i=1; i<=n; i++)
　　　　if (x[i]) printf("%d ", i);
　　printf("\n");
｝