python算法之试探算法

前言

试探算法也叫回溯法，试探算法的处事方式比较委婉，他先暂时放弃关于问题规模大小的限制，并将问题的候选解按照某种顺序逐一枚举和检验。当发现当前候选解一定不是正确的解时，就选择下一个候选解。如果当前候选解除不满足问题规模要求外，其余都满足，则扩大当前候选解的范围，并继续试探。如果当前候选解满足包括问题规模在内的所有要求时，该候选解就是问题的一个解。

试探算法基础

1. 针对所有问题，定义问题的解空间。
2. 确定易于搜索的解空间结构。
3. 以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

试探算法案例

解决“八皇后”问题

问题描述：在8*8的国际象棋上，摆放八个皇后，使其不能相互攻击，即任意两个皇后不能在同一行，同一列，同意斜线上，问有多少种摆法？

n = 8
x = []  # 一个解（n元数组）
X = []  # 一组解

# 冲突检测：判断 x[k] 是否与前 x[0~k-1] 冲突
def conflict(k):
    global x

    for i in range(k):  # 遍历前 x[0~k-1]
        if x[i] == x[k] or abs(x[i] - x[k]) == abs(i - k):  # 判断是否与 x[k] 冲突,前者判断是否同行，后者判断是否同列或同斜线
            return True
    return False


# 套用子集树模板
def queens(k):  # 到达第k行
    global n, x, X

    if k >= n:  # 超出最底行
        # print(x)
        X.append(x[:])  # 保存（一个解），注意x[:]
    else:
        for i in range(n):  # 遍历第 0~n-1 列（即n个状态）
            x.append(i)  # 皇后置于第i列，入栈
            if not conflict(k):  # 剪枝
                queens(k + 1)
            x.pop()  # 回溯，出栈
# 解的可视化（根据一个解x，复原棋盘。'X'表示皇后）
def show(x):
    global n
    for i in range(n):
        print('. ' * (x[i]) + 'X ' + '. ' * (n - x[i] - 1))
# 测试
queens(0)  # 从第0行开始

print(X[-1], '\n')
show(X[-1])

运行结果

解决“迷宫”问题

给定一个迷宫，入口已知。问是否有路径从入口到出口，若有·，则输出一条这样的路径。
**注意：**移动可以从上、下、左、右、上左、上右、下左、下右八个方向。输入0表示可以走，输入1表示墙。

# 迷宫（1是墙，0是通路）
maze = [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [0, 0, 1, 0, 1, 1, 1, 1, 0, 1],
        [1, 1, 0, 1, 0, 1, 1, 0, 1, 1],
        [1, 0, 1, 1, 1, 0, 0, 1, 1, 1],
        [1, 1, 1, 0, 0, 1, 1, 0, 1, 1],
        [1, 1, 0, 1, 1, 1, 1, 1, 0, 1],
        [1, 0, 1, 0, 0, 1, 1, 1, 1, 0],
        [1, 1, 1, 1, 1, 0, 1, 1, 1, 1]]

m, n = 8, 10  # 8行，10列
entry = (1, 0)  # 迷宫入口
path = [entry]  # 一个解（路径）
paths = []  # 一组解

# 移动的方向（顺时针8个：N, EN, E, ES, S, WS, W, WN）
directions = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]


# 冲突检测
def conflict(nx, ny):
    global m, n, maze

    # 是否在迷宫中，以及是否可通行
    if 0 <= nx < m and 0 <= ny < n and maze[nx][ny] == 0:   #不越界，可以通行
        return False

    return True


# 套用子集树模板
def walk(x, y):  # 到达(x,y)格子
    global entry, m, n, maze, path, paths, directions

    if (x, y) != entry and (x % (m - 1) == 0 or y % (n - 1) == 0):  # 出口
        # print(path)
        paths.append(path[:])  # 直接保存，未做最优化
    else:
        for d in directions:  # 遍历8个方向(亦即8个状态)
            nx, ny = x + d[0], y + d[1]
            path.append((nx, ny))  # 保存，新坐标入栈
            if not conflict(nx, ny):  # 剪枝
                maze[nx][ny] = 2  # 标记，已访问（奇怪，此两句只能放在if区块内！）
                walk(nx, ny)
                maze[nx][ny] = 0  # 回溯，恢复
            path.pop()  # 回溯，出栈


# 解的可视化（根据一个解x，复原迷宫路径，'2'表示通路）
def show(path):
    global maze

    import pprint, copy

    maze2 = copy.deepcopy(maze)

    for p in path:
        maze2[p[0]][p[1]] = 2  # 通路

    pprint.pprint(maze)  # 原迷宫
    print()
    pprint.pprint(maze2)  # 带通路的迷宫


# 测试
walk(1, 0)
print(paths[-1], '\n')  # 看看最后一条路径
show(paths[-1])

运行结果