算法学习7——回溯算法

什么是回溯算法？

回溯算法是一种试探性搜索算法，通过递归的方式逐步构建解决方案，并在发现当前路径不满足条件时回退到上一步。回溯算法特别适用于组合优化问题，如全排列、组合、子集和图的着色问题等。

回溯算法的特点

1. 递归：通过递归调用函数逐步构建解。
2. 回溯：当发现当前路径不满足条件时，回退到上一步继续尝试其他可能性。
3. 剪枝：通过提前终止不必要的搜索，提高算法效率。

经典例子及其Python实现

1. N皇后问题

问题描述：在N×N的棋盘上放置N个皇后，使得任意两个皇后不在同一行、同一列或同一对角线上。

实现过程：

1. 逐行放置皇后，尝试每一列。
2. 判断是否满足条件，若满足则继续下一行，若不满足则回退。
3. 直到所有行都放置完毕，输出解。

Python代码：

def solve_n_queens(n):
    def is_safe(board, row, col):
        for i in range(row):
            if board[i] == col or abs(board[i] - col) == row - i:
                return False
        return True

    def solve(board, row):
        if row == n:
            result.append(board[:])
            return
        for col in range(n):
            if is_safe(board, row, col):
                board[row] = col
                solve(board, row + 1)
                board[row] = -1

    result = []
    board = [-1] * n
    solve(board, 0)
    return result

# 示例
n = 4
solutions = solve_n_queens(n)
for sol in solutions:
    print(sol)

2. 全排列问题

问题描述：给定一个数组，求出所有可能的排列。

实现过程：

1. 逐个交换数组元素，生成不同排列。
2. 递归地继续生成排列。
3. 回退并交换回原来的顺序。

Python代码：

def permute(nums):
    def backtrack(start):
        if start == len(nums):
            result.append(nums[:])
            return
        for i in range(start, len(nums)):
            nums[start], nums[i] = nums[i], nums[start]
            backtrack(start + 1)
            nums[start], nums[i] = nums[i], nums[start]

    result = []
    backtrack(0)
    return result

# 示例
nums = [1, 2, 3]
print(permute(nums))

3. 子集和问题

问题描述：给定一个集合，求出所有可能的子集。

实现过程：

1. 递归生成子集。
2. 每次选择是否包含当前元素。
3. 递归继续生成下一个元素的子集。

Python代码：

def subsets(nums):
    def backtrack(start, path):
        result.append(path[:])
        for i in range(start, len(nums)):
            path.append(nums[i])
            backtrack(i + 1, path)
            path.pop()

    result = []
    backtrack(0, [])
    return result

# 示例
nums = [1, 2, 3]
print(subsets(nums))

4. 骑士巡游问题

问题描述：在N×N的棋盘上，骑士从某一位置出发，经过每个方格一次且仅一次。

实现过程：

1. 递归尝试每一步。
2. 判断是否满足骑士走法且未访问过该方格。
3. 若满足则继续下一步，否则回退。

Python代码：

def solve_knights_tour(n):
    def is_safe(x, y, board):
        return 0 <= x < n and 0 <= y < n and board[x][y] == -1

    def solve(x, y, movei, board, x_move, y_move):
        if movei == n * n:
            return True
        for k in range(8):
            next_x, next_y = x + x_move[k], y + y_move[k]
            if is_safe(next_x, next_y, board):
                board[next_x][next_y] = movei
                if solve(next_x, next_y, movei + 1, board, x_move, y_move):
                    return True
                board[next_x][next_y] = -1
        return False

    board = [[-1 for _ in range(n)] for _ in range(n)]
    x_move = [2, 1, -1, -2, -2, -1, 1, 2]
    y_move = [1, 2, 2, 1, -1, -2, -2, -1]
    board[0][0] = 0

    if solve(0, 0, 1, board, x_move, y_move):
        return board
    else:
        return "No solution exists"

# 示例
n = 5
solution = solve_knights_tour(n)
for row in solution:
    print(row)