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<n;i++) { x = select(A);
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<n;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<n;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 ，
5
01===+n j x x L ，由算法的实现，有：
M M x
w i
n
i i ==∑=11
（5.2.3）
假定，算法的最优解是),,,(21n y y y Y L =，并且满足：
M M y
w i
n
i i ==∑=21
（5.2.4）
若Y X ≠，必存在n k k <≤1,，对k i <≤1，有i i y x =，对k ，有k k y x ≠，这时，有两种情况：
① 若k k y x <，因为1≤k y ，必有1<k x 。

根据算法的执行，有01===+n k x x L 。

所以，21M M <，与（5.2.3）、（5.2.4）式矛盾。

因此，只有Y X =。

② 若k k y x >，有：
i
k
i i i
k i i i
n i i y w x w x w M ∑∑∑===>≥=
1
1
1
所以，n k y y ,,1L +不会全为0。

令k k k x y y =Δ+，并使n k y y ,,1L +都相应减少，得到新的解),,,(21n z z z Z L =，
当k i <≤1时有：i i i x y z ==；当k i =时有：k k k x z y =<；当n i k ≤<时有：i i y z <，并且满足：
0)()(1
=−−
−∑+=i i n
k i i
k k k w z y
w y z
令：
n n n n n k k k k k k k k k k w z y w p
w z y w p w y z w p )()()(11111−−−−−−=+++++L δ ))()()((111n n n k k k k k k k
k
w z y w z y w y z w p −−−−−−≥
+++L 0=
若0>δ，则Z 是一个新的最优解；若0=δ，则Z 与Y 同为最优解。

在此两种情况下，都用Z 取代Y ，并且对所有的k i ≤≤1，都有：i i x z =，而对n i k ≤≤+1，有：i i x z ≠。

对向量Z 重复上述①②步骤，最终必有：对所有的n i ≤≤1，都有：i i x z =。

因此，X 是最优解。