回溯算法：解决复杂问题的利器

最新推荐文章于 2026-01-04 19:40:08 发布

原创最新推荐文章于 2026-01-04 19:40:08 发布 · 823 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #python #leetcode

回溯算法（Backtracking）是一种用于解决复杂问题的强大工具，特别适用于那些需要枚举所有可能解或路径的问题。在本文中，我们将深入探讨回溯算法的基本原理、应用场景以及实际示例。

什么是回溯算法？

回溯算法是一种基于深度优先搜索（DFS）的算法，通过尝试所有可能的解，并在发现当前路径不可行时回溯到上一个节点，继续尝试其他路径。它的核心思想是“试错”，即尝试一个解，如果不行就回退，再尝试另一个解。

回溯算法的基本框架

回溯算法的基本框架如下：

result = []

def backtrack(选择列表, 路径):
    if 满足结束条件:
        result.append(路径.copy())
        return
    for 选择 in 选择列表:
        做选择
        backtrack(剩余选择列表, 更新后的路径)
        撤销选择

backtrack(初始选择列表, 初始路径)
return result

回溯算法的关键步骤

做选择：根据当前状态选择下一个可能的解。
递归调用：进入下一层递归，继续做选择。
撤销选择：如果当前选择导致无法找到解，撤销选择并回溯到上一层。

回溯算法的应用场景

回溯算法广泛应用于以下问题：

子集问题：给定一个不包含重复元素的整数数组，返回该数组所有可能的子集。
组合问题：给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
排列问题：给定一个不包含重复元素的整数数组，返回该数组所有可能的排列。
八皇后问题：将 n 个皇后放置在 n x n 的棋盘上，使得任何两个皇后都不在同一行、同一列或同一对角线上。
数独问题：填充一个部分填充的数独棋盘，使得所有行、列和 3x3 子宫格中都没有重复的数字。

回溯算法的实际示例

例子：子集问题（LeetCode 78）

给定一个不包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        def backtrack(start, path):
            res.append(path.copy())
            for i in range(start, len(nums)):
                path.append(nums[i])
                backtrack(i + 1, path)
                path.pop()

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

# 示例 usage
solution = Solution()
nums = [1, 2, 3]
print(solution.subsets(nums))
# 输出：[[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

例子：组合问题（LeetCode 77）

给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        def backtrack(start, path):
            if len(path) == k:
                res.append(path.copy())
                return
            for i in range(start, n + 1):
                path.append(i)
                backtrack(i + 1, path)
                path.pop()

        res = []
        backtrack(1, [])
        return res

# 示例 usage
solution = Solution()
n = 4
k = 2
print(solution.combine(n, k))
# 输出：[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

例子：八皇后问题

将 n 个皇后放置在 n x n 的棋盘上，使得任何两个皇后都不在同一行、同一列或同一对角线上。

def solveNQueens(n):
    def is_valid(row, col, placed):
        for i in range(row):
            if placed[i] == col or placed[i] - i == col - row or placed[i] + i == col + row:
                return False
        return True

    def backtrack(row, placed):
        if row == n:
            result.append(placed[:])
            return
        for col in range(n):
            if is_valid(row, col, placed):
                placed[row] = col
                backtrack(row + 1, placed)

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

# 输出结果为每个解的列索引列表
# 例如：solveNQueens(4) 输出：[[1, 3, 0, 2], [2, 0, 3, 1]]

def print_board(solution):
    n = len(solution)
    for col in solution:
        print('.' * col + 'Q' + '.' * (n - col - 1))

# 示例 usage
solution = solveNQueens(4)
for s in solution:
    print_board(s)