搜索的策略（2）——贪心策略

贪心策略

　　很多时候，我们只需要找到问题的最优解，如果使用盲目搜索策略，就必须先找出所有解，再进一步比较哪个是最优的，当在解空间十分庞大时，难免有些浪费体力的感觉。这时候，不妨试试更高效的贪心策略。

　　贪心策略也叫贪心算法（greedy algorithm）或贪婪算法，是一种强有力的穷举搜索策略，它通过一系列选择来找到问题的最优解。在每个决策点，它都会做出当时看来是最优的选择，一旦选择后就无需回溯。简单来说，贪心策略是一种“步步为营”的策略——只要做好眼前的每一步，就自然会在未来得到最好的结果，并且做过的决策就是是最好的决策，无需再次检查。

　　很多时候，贪心法并不能保证得到最优解，它能得到的是较为接近最优解的较好解，因此贪心法经常被用来解决一些对结果精度要求不高的问题。

小偷的背包

　　一个小偷撬开了一个保险箱，发现里面有N个大小和价值不同的东西，但自己只有一个容量是M的背包，小偷怎样选择才能使偷走的物品总价值最大？

　　假设有5个物品A,B,C,D,E，它们的体积分别是3,4,7,8,9，价值分别是4,5,10,11,13，可以用矩形表示体积，将矩形旋转90°后表示价值：

　　下图展示了一个容量为17的背包的4中填充方式，其中有两种方式的总价都是24：

　　背包问题有很多重要的实应用，比如长途运输时，需要知道卡车装载物品的最佳方式。

搜索策略

　　我们基于贪心策略去解决背包问题：在取完一个物品后，找到填充背包剩余部分的最佳方法。对于一个容量为M的背包，需要对每一种类型的物品都推测一下，如果把它装入背包的话总价值是多少，依次递归下去就能找到最佳方案。这个方案的原理是，一旦做出了最佳选择就无需更改，也就是说一旦知道了如何填充较小容量的背包，则无论下一个物品是什么，都无需再次检验已经放入背包中的物品（已经放入背包中的物品一定是最佳方案）。

寻找解决方案

　　首先定义物品的数据模型：

1 class Goods:
2     ''' 物品的数据结构  '''
3     def __init__(self, size, value):
4         '''
5         :param size: 物品的体积
6         :param value: 物品的价值
7         '''
8         self.size = size
9         self.value = value

　　然后使用fill_into_bag方法寻找最佳填充方案。该方法接收背包容量和物品清单两个参数，返回背包最大价值和最佳填充方案：

 1 def fill_into_bag(M, goods_list):
 2     '''
 3     填充一个容量是 M 的背包
 4     :param M: 背包的容量
 5     :param goods_list: 物品清单，包括每种物品的体积和价值，物品互不相同
 6     :return: (最大价值，最佳填充方案)
 7     '''
 8     space = 0       # 背包的剩余容量
 9     max = 0         # 背包中物品的最大价值
10     plan = []       # 最佳填充方案
11
12     for goods in goods_list:
13         space = M - goods.size
14         if space >= 0:
15             # 在取完一个物品（goods）后，填充背包剩余部分的最佳方法
16             space_plan = fill_into_bag(space, goods_list)
17             if space_plan[0] + goods.value > max:
18                 max = space_plan[0] + goods.value
19                 plan = [goods] + space_plan[1]
20
21     return max, plan

　　最后可以看看小偷应该怎样填充背包：

 1 def paint(plan):
 2     print('最大价值：' + str(plan[0]))
 3     print('最佳方案：')
 4     for goods in plan[1]:
 5         print('\t大小：{0}\t价值：{1}'.format(goods.size, goods.value))
 6
 7 if __name__ == '__main__':
 8     goods_list = [Goods(3, 4), Goods(4, 5), Goods(7, 10), Goods(8, 11), Goods(9, 13)]
 9     plan = fill_into_bag(17, goods_list)
10     paint(plan)

　　运行结果：

　　遗憾的是，fill_into_bag方法只能作为一个简单的试验样品，它犯了一个严重的错误——第二次递归会忽略上一次所做的所有计算！这将导致要花指数级的时间才能计算出结果。为了把时间降为线性，需要使用动态编程技术对其进行改进，把计算过的值都缓存起来，由此得到了背包问题的2.0版：

 1 # 字典缓存，space:(max,plan)
 2 sd = {}
 3 def fill_into_bag_2(M, goods_list):
 4     '''
 5     填充一个容量是 M 的背包
 6     :param M: 背包的容量
 7     :param goods_list: 物品清单，包括每种物品的体积和价值，物品互不相同
 8     :return: (最大价值，最佳填充方案)
 9     '''
10     space = 0       # 背包的剩余容量
11     max = 0         # 背包中物品的最大价值
12     plan = []       # 最佳填充方案
13
14     if M in sd:
15         return sd[M]
16
17     for goods in goods_list:
18         space = M - goods.size
19         if space >= 0:
20             # 在取完一个物品（goods）后，填充背包剩余部分的最佳方法
21             print(goods.size, space)
22             space_plan = fill_into_bag_2(space, goods_list)
23             if space_plan[0] + goods.value > max:
24                 max = space_plan[0] + goods.value
25                 plan = [goods] + space_plan[1]
26     # 设置缓存，M空间的最佳方案
27     sd[M] = max, plan
28
29     return max, plan

　　这次可以快速运行了，当然，我们并不想把这个算法告诉小偷。

骑士旅行

　　骑士旅行（Knight tour）问题是另一个关于国际象棋的话题：骑士可以由棋盘上的任一个方格出发，如果每个方格只能到达一次，它要如何走完所有的位置？骑士旅行曾在十八世纪初倍受数学家与拼图迷的注意，具体什么时候被提出已不可考。

　　“骑士”的走法和吃子都和中国象棋的“马”类似，遵循“马走日”的原则，只不过没有“蹩腿”的约束：

　　在国际象棋中，骑士的价值为3，虽然不算高，却灵活、易调动、易双抽，从这一点看，它的价值不亚于皇后。

5.5.1 构建数据模型

　　我们依然使用8×8的二维列表存储棋盘信息，用0表示方格的初始状态。使用一个从1开始的计数器记录骑士旅行的轨迹，每走一步，计数器加1，同把骑士到达的方格状态设置为计数器的值，这些数值就是骑士的旅程轨迹：

　　骑士从一个方格出发， 最多可以向八个方向行进，怎样方便地表示这八个方向呢？我们都见识或棋谱，在棋谱上，把骑士可以到达的八个方格依次编号：

　　这像极了平面直角坐标系，可以把棋盘外围的列序号看作y轴的坐标，行序号看作x轴的坐标，这样棋盘上的每一个方格就可以用一个二维向量表示，向量的第一个分量是行号，第二个分量是列号。这实际上是把我们熟知的直角坐标系顺时针旋转了90°，目的是为了能够更方便地用二维列表表示。

　　骑士的初始位置是(3,3)，从这里出发可以到达的另外八个位置依次是：(2,1)，(1,2)，(1,4)，(2,5)，(4,5)，(5,4)，(5,2)，(4,1)。它们与初始位置的差值是：(-1,-2)，(-2,-1)，(-2,1)，(-1,2)，(1,2)，(2,1)，(2,-1)，(1,-2)。由于向量是表示大小和方向的量，与具体位置无关，所以骑士从任意位置出发，加上差值向量后都可以到达另外八个位置（不考虑棋盘边界）。以上图为例：

　　用一个列表存储这些差值向量。骑士旅行的数据模型：

 1 class KnightTour:
 2     def __init__(self):
 3         # 棋盘的行数和列数
 4         self.row_num, self.col_num = 8, 8
 5         # 方格的初始状态
 6         self.s_init = 0
 7         # 棋盘
 8         self.chess_board = [[self.s_init] * self.row_num for i in range(self.row_num)]
 9         # 差值向量，表示骑士移动的八个方向
10         self.v_move = [(-1, -2), (-2, -1), (-2, 1), (-1, 2), (1, 2), (2, 1), (2, -1), (1, -2)]
11         # 计数器终点
12         self.max = self.row_num * self.col_num
13         # 解决方案
14         self.answer = None

盲目的深度优先策略

　　大概最容易想到的旅行方法就是深度优先搜索，基本思虑和八皇后类似：骑士从一个位置开始，向一个方向探索，无法继续前进时就“悔棋”，尝试下一个方向，如果计数器能累加到64，说明骑士可以完成旅行：

 1 import copy
 2
 3 class KnightTour:
 4     ……
 5     def enable(self, curr_board, x, y):
 6         ''' 判断x,y位置是否可走 '''
 7         # 边界条件判断 and x,y位置是否曾经到达过
 8         return (0 <= x < self.col_num and 0 <= y < self.row_num) and curr_board[x][y] == self.s_init
 9
10     def move(self, curr_board, x, y, count):
11         '''
12         骑士从(x,y)位置开始旅行
13         :param curr_board: 当前棋盘
14         :param x: 起始位置行号
15         :param y: 起始位置列号
16         :param count: 当前计数
17         :return
18         '''
19         # 找到一种方法就退出
20         if self.answer is not None:
21             return
22         # 如果已经走遍了所有方格，该问题解决
23         if count > self.max:
24             self.answer = curr_board
25             return
26
27         if self.enable(curr_board, x, y):
28             curr_board[x][y] = count
29             # 继续旅行,分别探测八个方向
30             for v_x, v_y in self.v_move:
31                 # 复制棋盘上的状态, 以便回溯
32                 bord = copy.deepcopy(curr_board)
33                 self.move(bord, x + v_x, y + v_y, count + 1)

　　这里x是方格的行序号，y是方格列序号。Enable方法用于判断(x,y)是否超出的棋盘边界，同时也检查了骑士是否已经到访过(x,y)。move方法以递归的方式向下一步探索。悔棋的回溯操作使用了复制棋盘状态的方式，这需要大量的内存，它有一个通过更改方格状态的代替版本：

 1  def move2(self, x, y, count):
 2         '''
 3        骑士从(x,y)位置开始旅行
 4        :param x: 起始位置行号
 5        :param y: 起始位置列号
 6        :param count: 当前计数
 7        :return
 8         '''
 9         # 找到一种方法就退出
10         if self.answer is not None:
11             return
12         # 如果已经走遍了所有方格，该问题解决
13         if count > self.max:
14             self.answer = copy.deepcopy(self.chess_board)
15             return
16
17         if self.enable(self.chess_board, x, y):
18             self.chess_board[x][y] = count
19             # 继续旅行,分别探测八个方向
20             for v_x, v_y in self.v_move:
21                 self.move2(x + v_x, y + v_y, count + 1)
22             # 将该位置设为初始值，以便悔棋
23             self.chess_board[x][y] = self.s_init

　　move2只使用了一个棋盘，为了回到上一个方格，当骑士探索完八个方向后，需要将当前所在方格重置为初始状态。move2的改进仅仅是节省了一点内存，和move1并没有本质的区别，它们在运行时都相当缓慢。骑士每到达一个位置后，都将向八个方向探索，棋盘上共有64个方格，探索的数量也会产生爆炸，因此我们在找到一种方案后就马上退出。

　　完整代码：

 1 import copy
 2
 3 class KnightTour:
 4     def __init__(self):
 5         # 棋盘的行数和列数
 6         self.row_num, self.col_num = 8, 8
 7         # 方格的初始状态
 8         self.s_init = 0
 9         # 棋盘
10         self.chess_board = [[self.s_init] * self.row_num for i in range(self.row_num)]
11         # 差值向量，表示骑士移动的八个方向
12         self.v_move = [(-1, -2), (-2, -1), (-2, 1), (-1, 2), (1, 2), (2, 1), (2, -1), (1, -2)]
13         # 计数器终点
14         self.max = self.row_num * self.col_num
15         # 解决方案
16         self.answer = None
17
18     def start(self, x, y):
19         '''
20          旅行开始
21         :param x: 起始位置行号
22         :param y: 起始位置列号
23         :return:
24         '''
25         # self.move(self.chess_board, x, y, 1)
26         self.move2(x, y, 1)
27
28     def enable(self, curr_board, x, y):
29         ''' 判断x,y位置是否可走 '''
30         # 边界条件判断 and x,y位置是否曾经到达过
31         return (0 <= x < self.col_num and 0 <= y < self.row_num) and curr_board[x][y] == self.s_init
32
33     def move(self, curr_board, x, y, count):
34         '''
35         骑士从(x,y)位置开始旅行
36         :param curr_board: 当前棋盘
37         :param x: 起始位置行号
38         :param y: 起始位置列号
39         :param count: 当前计数
40         :return
41         '''
42         # 找到一种方法就退出
43         if self.answer is not None:
44             return
45         # 如果已经走遍了所有方格，该问题解决
46         if count > self.max:
47             self.answer = curr_board
48             return
49
50         if self.enable(curr_board, x, y):
51             curr_board[x][y] = count
52             # 继续旅行,分别探测八个方向
53             for v_x, v_y in self.v_move:
54                 # 复制棋盘上的状态, 以便回溯
55                 bord = copy.deepcopy(curr_board)
56                 self.move(bord, x + v_x, y + v_y, count + 1)
57
58     def move2(self, x, y, count):
59         '''
60        骑士从(x,y)位置开始旅行
61        :param x: 起始位置行号
62        :param y: 起始位置列号
63        :param count: 当前计数
64        :return
65         '''
66         # 找到一种方法就退出
67         if self.answer is not None:
68             return
69         # 如果已经走遍了所有方格，该问题解决
70         if count > self.max:
71             self.answer = copy.deepcopy(self.chess_board)
72             return
73
74         if self.enable(self.chess_board, x, y):
75             self.chess_board[x][y] = count
76             # 继续旅行,分别探测八个方向
77             for v_x, v_y in self.v_move:
78                 self.move2(x + v_x, y + v_y, count + 1)
79             # 将该位置设为初始值，以便悔棋
80             self.chess_board[x][y] = self.s_init
81
82     def display(self):
83         if self.answer is None:
84             print('No answers!')
85             return
86
87         for row in  self.answer:
88             for c in row:
89                 print('%4d' % c, end='')
90             print()
91
92 if __name__ == '__main__':
93     kt = KnightTour()
94     kt.start(7, 7)
95     kt.display()

　　如果骑士从(7, 7)出发，是能够完成旅行的：

　　骑士的初始位置和探测方向的顺序都会对运算时间产生极大的影响，如果把起始位置改成(0,0)，那么上面的程序将运行相当长的时间。

　　并不是在所有棋盘都能完成旅行，在3×3的棋盘上，骑士永远都无法到达中心位置：

带有预见性的贪心策略

　　由于每步试探的随机性和盲目性，使得基于深度优先策略的盲目搜索效率低下。如果能够找到一种克服这种随机性和盲目性的办法，按照一定规律选择前进的方向，则成功的可能性将大大增加。J.C. Warnsdorff在1823年提出一个聪明的解法：有选择地走下一步，先将最难的位置走完，既然每一格迟早都要走到，与其把困难留在后面，不如先走困难的路，这样后面的路才会宽阔，成功的机会也增大。

　　为了简单起见，我们的骑士先在5×5的棋盘上旅行。他的初始位置是(0,0)，这也是旅途的第一站，用“①”表示：

　　骑士的下一站只可能有两个，(1,2)和(2,1)，用深色方格表示：

　　如果骑士的下一站是(1,2)，那么从(1,2)出发，再下一站能够到达(0,4)，(2,4)，(3,3)，(3,1)，(2,0)这5个位置，将数字5标记在(1,2)中，用于表示路的宽窄，数字越小，路越窄，表示这条路线越困难。如果从(2,1)出发，再下一站能够到达另外五个位置：

　　第二站的“宽度”都是5。我们已经在图5.13中为八个方向编好了序号，从位于十点钟方向的1号开始，按照顺时针顺序逐一探索，选择最窄目的地当中的第一个作为下一站。按照这种方式，这里选择(1,2)作为下一站，并为该方格标记序号：

　　接下来从位置②继续探测，寻找最窄的第三站：

　　每个方格只能到达一次，所以不能再回到①，这也是贪心法和深度优先搜索的重要原因之一——在贪心法中，每一步决策都是当下最好的，一旦做出选择就不再回溯。从位置②出发，到达的最窄第三站是(0,4)：

　　按照这种方式继续向前探测，骑士最终能够顺利完成旅程：

　　按照这种思路使用贪心策略编写代码：

 1 class KnightTourGreedy:
 2     def __init__(self):
 3         # 棋盘的行数和列数
 4         self.row_num, self.col_num = 8, 8
 5         # 方格的初始状态
 6         self.s_init = 0
 7         # 棋盘
 8         self.chess_board = [[self.s_init] * self.row_num for i in range(self.row_num)]
 9         # 差值向量，表示骑士移动的八个方向
10         self.v_move = [(-1, -2), (-2, -1), (-2, 1), (-1, 2), (1, 2), (2, 1), (2, -1), (1, -2)]
11         # 计数器终点
12         self.max = self.row_num * self.col_num
13         # 解决方案
14         self.answer = None
15
16     def enable(self, x, y):
17         ''' 判断x,y位置是否可走 '''
18         # 边界条件判断 and x,y位置是否曾经到达过
19         return 0 <= x < self.col_num and 0 <= y < self.row_num and self.chess_board[x][y] == self.s_init
20
21     def get_width(self, x, y):
22         '''  x,y位置的“宽度”,数值越小，后面的路越窄  '''
23         # 如果（x, y）位置曾经达到过，返回9（比八个方向多1）
24         if self.enable(x, y) == False:
25             return 9
26         n = 0
27         for v_x, v_y in self.v_move:
28             if self.enable(x + v_x, y + v_y):
29                 n += 1
30         return n
31
32     def find_min(self, x, y):
33         ''' 找到从(x,y)出发，路“最窄”的下一个位置（下一个位置可到达的“未曾到访”方格数最少）  '''
34         min_x, min_y, min_n = -1, -1, 100
35         for v_x, v_y in self.v_move:
36             n = self.get_width(x + v_x, y + v_y)
37             if n < min_n:
38                 min_x, min_y, min_n = x + v_x, y + v_y, n
39         return min_x, min_y
40
41     def move(self, x, y, count):
42         ''' 骑士从(x,y)位置开始旅行  '''
43         # 找到一种方法就退出
44         if self.answer is not None:
45             return
46         # 如果已经走遍了所有方格，该问题解决
47         if count > self.max:
48             self.answer = self.chess_board
49             return
50
51         if self.enable(x, y):
52             self.chess_board[x][y] = count
53             # 找出八个方向中，路“最窄”的一个
54             next_x, next_y = self.find_min(x, y)
55             # 向路“最窄”的方向继续前进
56             self.move(next_x, next_y, count + 1)
57
58     def start(self, x, y):
59         ''' 旅行开始 '''
60         self.move(x, y, 1)
61
62     def display(self):
63         if self.answer is None:
64             print('No answers!')
65             return
66
67         for row in self.answer:
68             for c in row:
69                 print('%4d' % c, end='')
70             print()
71
72 if __name__ == '__main__':
73     kt = KnightTourGreedy()
74     kt.start(0, 0)
75     kt.display()

　　KnightTourGreedy的基本数据模型、棋盘边界判断和打印方法都和KnightTour一致。get_width用于计算从(x,y)位置的宽度，数值越小，该位置后面的路越“窄”，越难以到达。

　　对于路的宽窄来说，最窄是0，表示无路可走；最大是8，可以向8个方向前进（不能回到出发的位置）。为了让更便于find_min方法选择“最窄”的路，如果(x,y)曾经到访过，则(x,y)的宽度是9（可以选择大于8并且小于min_n初始值的任何数），从而保证曾经到访过的方格一定宽于未曾到访的方格，以使得find_min不会选中曾经到访过的方格。move方法没有任何回溯，只是简单地向最窄的方向一步步走下去：

　　改成8×8或16×16的大棋盘后，KnightTourGreedy也可以快速得出结果：

　　对于一些更大的棋盘，KnightTourGreedy运行时可能会出现“RecursionError: maximum recursion depth exceeded in comparison”，这是由于递归深度超过了Python的默认限制。解决这一问题有两种方法，一种是通过sys.setrecursionlimit()修改递归的默认深度，另一种是将递归改成循环。

　　

---

　　 作者：我是8位的

　　出处：http://www.cnblogs.com/bigmonkey

　　本文以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，非商业用途！ 

　　扫描二维码关注公众号“我是8位的”