什么是回溯算法

回溯算法的特点
递归：通过递归调用函数逐步构建解。
回溯：当发现当前路径不满足条件时，回退到上一步继续尝试其他可能性。
剪枝：通过提前终止不必要的搜索，提高算法效率。
经典例子及其Python实现
1. N皇后问题
问题描述：在N×N的棋盘上放置N个皇后，使得任意两个皇后不在同一行、同一列或同一对角线上。

实现过程：

逐行放置皇后，尝试每一列。
判断是否满足条件，若满足则继续下一行，若不满足则回退。
直到所有行都放置完毕，输出解。
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. 全排列问题
问题描述：给定一个数组，求出所有可能的排列。

实现过程：

逐个交换数组元素，生成不同排列。
递归地继续生成排列。
回退并交换回原来的顺序。
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. 子集和问题
问题描述：给定一个集合，求出所有可能的子集。

实现过程：

递归生成子集。
每次选择是否包含当前元素。
递归继续生成下一个元素的子集。
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的棋盘上，骑士从某一位置出发，经过每个方格一次且仅一次。

实现过程：

递归尝试每一步。
判断是否满足骑士走法且未访问过该方格。
若满足则继续下一步，否则回退。
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)