贪心算法(又称贪婪算法)是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解，关键是贪心策略的选择，选择的贪心策略必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

在开始之前我们引入一个很简单的问题，这个问题要求用尽可能少的硬币和纸币加出一个指定的金额总数。

首先我们会尽量从币值最大的地方开始，依次往下处理，下面附上代码：

# 100美元购买物品，找钱的程序

denom = [10000, 5000, 2000, 1000, 500, 200, 100, 50, 25, 10, 5, 1]

owed = 9876

payed = []

for d in denom:

while owed >= d:

owed -= d

payed.append(d)

print(sum(payed))

print(payed)

编译之后，会输出如下结果：

9876

[5000, 2000, 2000, 500, 200, 100, 50, 25, 1]

但是这个解决方案很脆弱，稍微改变一下货币表的内容，可能就会遭到破坏。

下面说一下整数背包问题。

你可以把整数背包视为找零钱问题的泛化版。

背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。

背包问题一般分为两类：

分数背包问题和整数背包问题。

分数背包问题：

分数背包问题其实可以看做背包问题的最简单的一种，因为这里的对象可以进行分割，只选取一部分。

比如，去野餐，在背包里面放什么，可以放金沙，威士忌和水。

我们先放金沙，放完了金沙，再放威士忌，因为威士忌价值介于两者之间，最后在放水。

其实分数背包问题的重点就是要找到权重比。

按照权重比排序，然后按照从高到低的顺序一个一个装包就好了。

整数背包问题：

整数背包问题可以分为无边界和有边界的情况。

有边界的情况会假设每个类别中的对象是固定的，无边界情况下对象时我们想要多少就用多少。

贪心策略在这两种情况下都不可行，都属于尚未解决的问题。现在还没有任何复杂度在多项式级以内的算法来解决他们。

其实有更好的解决方案，比如动态规划可以设计出伪多项式级别的时间复杂度的方案。

现在我们开始引入哈弗曼算法：

当我们在构建平衡二叉树的时候，我们会意识到平衡二叉树结构是在发生概率均匀分布的前提下构建的。

其实这个平衡二叉树的问题构建在压缩领域也有应用。比如压缩领域致力于用某种可变长度的编码来表示文本，使其形式上显得更为紧凑。在表示形式中，文本的每个字符都会有自己出现的概率，而我们将根据这些概率信息为其分配不同长度的字符编码。从而实现了文本长度的最小化。

下面给出具体的算法实现：

# 哈弗曼算法

from heapq import heapify, heappush, heappop

from itertools import count

def huffman(seq, frq):

num = count()

trees = list(zip(frq, num, seq))

heapify(trees)

while len(trees) > 1:

fa, _, a = heappop(trees)

fb, _, b = heappop(trees)

n = next(num)

heappush(trees, (fa+fb, n, [a, b]))

return trees[0][-1]

seq = "abcdefghi"

frq = [4, 5, 6, 9, 11, 12, 15, 16, 20]

print(huffman(seq, frq))

以上的输出结果：

[['i', [['a', 'b'], 'e']], [['f', 'g'], [['c', 'd'], 'h']]]

这个算法使用了堆结构(导入了heapq模块)。

上述算法中反复选取，合并两个最小无序列表项表示是一个平方级别的操作(线性级别的选取，乘以线性级别的迭代),我们通过使用堆结构简化为线性对数级的操作(对数级别的选取和重新添加操作)。

添加了元祖“概率，树”，在概率各不相同的情况下就能进行操作。但是有两颗树发生的概率相同时。堆结构就必须找出比较小的那个，这时候我们就遇到了不确定的比较操作。

但是Python中不兼容对象之间不能比较。所以我们就在增加一个字段用来区别其他对象。

这时候如果应用到文本的压缩和解压缩中，我们要进行一些处理和加工。比如要对个字符出现的概率进行计数。

下面附上实现，其中计数可以调用collections磨矿中的Counter类:

# 从哈弗曼树中提取出哈弗曼编码

def codes(tree, prefix=""):

if len(tree) == 1:

yield (tree, prefix)

return

for bit, child in zip("01", tree):

for pair in codes(child, prefix + bit):

yield pair

这时候还要验证贪心算法的正确性，这个时候可以用归纳法来证明。证明一般分为两个部分：贪心选择性和最优子结构。

贪心选择性是指，每次我们都通过贪心选择得到了一个最有解决方案的一部分。

最优子结构是指，我们做出选择之后剩下的问题和原有的问题有着同样的解决方案。

至于哈弗曼算法的证明，这里就不再写出详细的过程了。

然后看下一个问题，这里我们引入最小生成树问题。

最小生成树是指，一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。

这里会引入两个新的算法Kruskal和Prim算法。

我们先看一个最短边的问题。

这是一个欧几里得图形的最小生成树(加粗部分)。

因为(e, i)为最短边，而且生成树中必须包含(e, i)节点，所以肯定包含两点之间的路径。如果我们将(e, i)加入到回路中，就会出现环路。所以我们为了使该生成树回归正常，我们要一出一天边。因为(e, i)是最短的边，所以移除其他任何一条边所产生的生成树都会小于我们原先的数据结构。

最小生成树一定包含最短边，这其实也是Kruskal算法背后的基本思想。

我们继续看，b必须要进行连接，但是b只能和d和a点相连，看起来短边会更好一些。然后我们假设(b, a)是更好地选择，然后把他加入到结构中，从而形成环路，但是我们移除掉这个边，我们会发现所得的另一颗生成树会因为选择了更短的边而变得更小了。这个时候我们就假设错误了。所以不包含(b, d)的生成树不可能是最小生成树。这其实是Prim算法背后的思想。

然后我们先看Kruskal算法：

这个算法是先对图中的边进行排序，然后着手进行选取。由于这回要寻找的是短边，所以按照长度递增顺序进行排序。

这里最重要的问题就是要检查出会导致解决方案无效的边。

这时候我们通过标记解决方案中的每个节点来了解各自所属的部分，然后从每个部分的节点中选择一个当做代表。然后让该部分中的所有节点都指向它。

下面是代码实现：

# Kruskal算法实现的朴素版

def native_find(C, u):

while C[u] !=u:

u = C[u]

return u

def native_union(C, u, v):

u = native_find(C, u)

v = native_find(C, v)

C[u] = v

def native_kruskal(G):

E = [(G[u][v], u, v) for u in G for v in G[u]]

T = set()

C = {u:u for u in G}

for _, u, v in sorted(E):

if native_find(C, u) != native_find(C, v):

T.add((u, v))

na

其实这个算法还有改进的地方，最坏的情况下，我们用来跟踪引用链的naive_find()可能是线性级别的函数，在两个部分之间，我们让native_union()总是把较小的那个指向较大的那个，来寻找平衡。

我们也可以把他们直接看做一组平衡树，然后赋予各个节点某个高度。

这样子，调用native_find()和native_union()的整体操作时间应该为O(mlgn)。

进行优化之后的代码：

# Kruskal算法

def find(C, u):

if C[u] != u:

C[u] = find(C, C[u])

return C[u]

def union(C, R, u, v):

u, v = find(C, u), find(C, v)

if R[u] > R[v]:

C[v] = u

else:

C[u] = v

if R[u] == R[v]:

R[v] += 1

然后继续看Prim算法：

Prim算法的主要思路是从某个起始节点开始对目标图结构进行遍历，并始终将最短的链接加入到相对应的树结构中。

然后看具体的实现代码：

# Prim算法

from heapq import heappop, heappush

def prim(G, s):

P, Q = {}, [(0, None, s)]

while Q:

_, p, u = heappop(Q)

if u in P:

continue

P[u] = p

for v, w in G[u].items():

heappush(Q, (w, u, v))

return P

到这里，贪心算法的一些问题和一些算法的实现就说的差不多了。

这里说一点额外的。尽管在一般情况下，贪心算法的正确性是通过归纳法证明的，但是这个也可以使用一些额外的方法去做。

第一种方案是保持领先策略。

主要思想是，证明我们在一步一步构建出属于自己的解决方案时，贪心算法始终会越来越逼近某个家乡的最优解决方案。在到达终点时，自然而然就被证明是最优的算法了。

第二个方案是尽量做到完美。

这个方案，前面展示哈弗曼算法的贪心选择属性的时候就用过了。主要是要考虑如何将一个假想的最佳解决方案无伤效率地转化为一种贪心算法。、

第三个方案就是做好安全措施。

主要思想就是，确保贪心算法的正确性是我们一切工作的起点，而且一定要确保自己的这一路每一步所采用的贪心策略都是安全的。

这里就说这么多吧。

谢谢大家关注。

天气寒冷，大家注意身体。