贪婪法

1

贪婪法

例 货币兑付问题：用最少的货币张数支付现金。

集合},,,{21n p p p P L =表示n 张面值为i p 的货币，n i ≤≤1， 出纳员需支付的现金为A ，从P 中选取一个最小的子集S ，使得

S p i ∈ 并且

A p

i

=∑

用向量),,,(21n x x x X L =表示S 中所选取的货币，使得：

⎩⎨

⎧∉∈=S

p S p x i i i 0

1

那么，出纳员支付的现金必须满足：

A p

x i

n

i i =∑=1

（5.0.1）

并且使得：

∑==n

i i

x

d 1

min

（5.0.2）

向量X 称为问题的解向量， 所有向量的全体称为问题的解空间。 （5.0.1）式称为问题的约束方程， （5.0.2）式称为问题的目标函数。 满足约束方程的向量称为问题的可行解。 满足目标函数的向量称为问题的最优解。

贪婪法引言

贪婪法的设计思想

贪婪法的设计方法描述如下：

greedy(A,n) {

2

solution = ϕ; for (i=1;i

if (feasible(solution,x))

solution = union(solution,x);

}

return solution; }

适于贪婪法求解的问题，具有两个重要性质：贪婪选择性质和最优子结构性质。 贪婪选择性质，是指所求问题的全局最优解，可以通过一系列局部最优的选择来达到。 例：从10张10元、10张5元、10张1元、10张5角、10张2角、10张1角的货币中兑付57元8角

集合},,,{6021p p p P L =顺序表示货币； 向量),,,(6021x x x X L =表示支付给客户的货币。 第一步挑出的货币集合}{11p S =，局部解),0,1(1L =Y ， 问题简化为在集合},,{6021p p P L =中挑选货币、付出47元8角

在以后的步骤中，可以用同样的方法进行挑选，并能得到问题的全局最优解。 最优子结构：指问题的最优解，包含它的子问题的最优解。

付给客户的货币集合的最优解是},,,,,,,,,,{51413122211154321p p p p p p p p p p p S n =。 第一步所简化了的子问题的最优解是},,,,,,,,,{51413122211154321p p p p p p p p p p S n =−。

n n S S ⊂−1，并且n n S p S =∪−}{11。所以，出纳员付钱问题具有最优子结构性质。

贪婪法的例子，货郎担问题

例 货郎担问题。5个城市，费用矩阵如图5.1所示。

1 2 3 4 5 5个城市的费用矩阵

总是选择费用最小的路线前进，选择的路线是1→4→3→5→2→1，总费用是14。 只选择一个城市作为出发城市，所需时间是)(2n O 。 n 个城市都可以作为出发城市，所需时间是)(3n O 。

从城市1出发的最优的路线是1→2→5→4→3→1，总费用只有13。

3

1 1 1

6 3 5 2 5 2 2 5 2 2 2 3 3

3 5 7

4 3 4 2 3 4 2 3

1 2 5 2 2 2 5

4 2 3

货郎担问题的求解过程

5.2 背包问题

载重量为M 的背包，重量为i w 、价值为i p 的物体，n i ≤≤1，把物体装满背包，使背包内的物体价值最大

物体可以分割的背包问题，及物体不可分割的背包问题，把后者称为0/1背包问题。

背包问题贪婪算法的实现

解向量),,,(21n x x x X L =

i x ：物体i 被装入背包的部分，10≤≤i x ， 0=i x ：物体i 没被装入背包； 1=i x ：物体i 被全部装入背包

约束方程：

M x

w i

n

i i =∑=1

（5.2.1）

目标函数： i n

i i x p d ∑==1

max

（5.2.2）

价值重量比最大：既使目标函数的值增加最快，又使背包载重量的消耗较慢。 数据结构：

typedef struct {

float p; /* n 个物体的价值 */ float w; /* n 个物体的重量 */ float v; /* n 个物体的价值重量比 */ } OBJECT;

4

OBJECT instance[n];

float x[n]; /* n 个物体装入背包的份量 */

算法 贪婪法求解背包问题

输入：背包载重量M,存放n 个物体的价值p 、及重量w 信息的数组instance[] 输出：n 个物体被装入背包的份量x[],背包中物体的总价值

1. float knapsack_greedy(float M,OBJECT instance[],float x[],int n)

2. {

3. int i;

4. float m,p = 0;

5. for (i=0;i

6. instance[i].v = instance[i].p / instance[i].w;

7. x[i] = 0;

/* 解向量赋初值 */

8. }

9. merge_sort(instance,n); /* 按关键值v 的递减顺序排序物体 */ 10. m = M;

/* 背包的剩余载重量 */

11. for (i=0;i

12. if (instance[i].w<=m) {

/* 优先装入价值重量比大的物体 */

13. x[i] = 1; m -= instance[i].w;

14. p += instance[i].p; 15. } 16. else {

/* 最后一个物体的装入份量 */

17. x[i] = m / instance[i].w; 18. p += x[i] * instance[i].p; 19. break; 20. } 21. }

22. return p; 23. }

背包问题贪婪算法的分析

一、时间复杂性为)log (n n Θ。需要)(n Θ工作空间，用来存放物体的价值重量比。 二、算法的正确性

定理5.1 当物体的价值重量比按递减顺序排序后，算法knapsack_greedy 可求得背包问题的最优解。

证明 设解向量),,,(21n x x x X L =，分两种情况：

(1) 若在解向量X 中，n i x i ~1,1==，物体已全部装入，则X 就是最优解； (2) 若在解向量X 中，存在n j j <≤1,，使得1121====−j x x x L ，10<≤j x ，