回溯问题题型分类

在计算机编程和算法设计中，回溯问题通常可以分为以下几种主要题型。这些题型涵盖了使用回溯算法解决问题的多种情况：

排列问题（Permutations）：

这类问题涉及确定一组元素的所有可能排列方式。
示例：给定一个不同的数字集合，列出所有可能的排列。
题目： 给定一组不同的数字 [1,2,3]，返回其所有可能的排列。

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

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

# 调用函数
print(permute([1, 2, 3]))

输出：[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 2, 1], [3, 1, 2]]

组合问题（Combinations）：

这些问题要求找出一组元素中所有可能的组合方式，通常是在不考虑元素顺序的情况下。
示例：给定一组数字和一个目标值，找出所有加起来等于目标值的组合。
题目： 给定两个整数 n = 4 和 k = 2，返回从 1 到 n 中所有可能的 k 个数的组合。
解答：

def combine(n, k):
    def backtrack(start, path):
        if len(path) == k:
            result.append(path[:])
            return
        for i in range(start, n + 1):
            path.append(i)
            backtrack(i + 1, path)
            path.pop()

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

# 调用函数
print(combine(4, 2))

输出：[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

子集问题（Subsets）：

子集问题涉及找出一组元素的所有可能子集。
示例：给定一组不同的整数，返回所有可能的子集。
题目： 给定一组不同的整数 [1,2,3]，返回所有可能的子集。

解答：

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

# 调用函数
print(subsets([1, 2, 3]))

输出：[[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]

棋盘问题（Chessboard problems）：

这类问题通常涉及在棋盘上放置或移动棋子，如皇后、马等，需要满足特定的条件。
示例：八皇后问题，即在8×8的棋盘上放置八个皇后，使它们互不攻击。
题目： 在 8x8 的棋盘上放置八个皇后，使它们互不攻击（即没有两个皇后在同一行、同一列或同一对角线上）。
解答：

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

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

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

# 调用函数
print(solveNQueens(8))

输出：过长省略

图论问题（Graph Theory Problems）：

这些问题涉及图的遍历和搜索，如寻找路径或循环。
示例：找出图中所有可能的路径，从一个节点到另一个节点。
题目： 给定一个有向图，找出从节点 0 到节点 n-1 的所有路径。
解答：

def allPaths(graph):
    def backtrack(node, path):
        if node == len(graph) - 1:
            result.append(path[:])
            return
        for next_node in graph[node]:
            path.append(next_node)
            backtrack(next_node, path)
            path.pop()

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

# 调用函数
print(allPaths([[1,2], [3], [3], []]))  # 示例图

输出：[[0, 1, 3], [0, 2, 3]]

分割问题（Partitioning Problems）：

这类问题涉及将一组元素划分成满足特定条件的子集。
示例：将一组数字分成两部分，使得这两部分的和相等。

题目： 给定一个非空字符串 s 和一个包含非空单词的字典 wordDict，判断 s 是否可以被空格分割成一个或多个在字典中出现的单词。

解答：

def wordBreak(s, wordDict):
    def backtrack(start, path):
        if start == len(s):
            result.append(' '.join(path))
            return
        for end in range(start + 1, len(s) + 1):
            if s[start:end] in wordDict:
                path.append(s[start:end])
                backtrack(end, path)
                path.pop()

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

# 调用函数
print(wordBreak("catsanddog", ["cat", "cats", "and", "sand", "dog"]))

输出：[‘cat sand dog’, ‘cats and dog’]

决策树问题（Decision Trees）：

决策树问题通常涉及一系列决策，这些决策需要达到某个特定目标。
示例：解决诸如迷宫寻路等问题，其中每个步骤都是一个决策。
回溯算法的核心思想是从可能的解决方案中逐一尝试，通过递归方式探索所有可能的分支。当一个分支确定不是正确的解决方案时，算法会回溯到上一个决策点，尝试其他可能的路径。这种方法通常用于解决复杂的组合问题，尤其是当问题的解空间非常大时。
题目： 给定一个 m x n 网格，每个单元格可以是 ‘1’（陆地）或 ‘0’（水）。找出网格中岛屿的数量。一个岛被水包围，并且它是通过水平或垂直连接相邻陆地而形成的。你可以假设网格的四个边界都被水包围。

解答：

def numIslands(grid):
    def dfs(x, y):
        if not (0 <= x < len(grid) and 0 <= y < len(grid[0])) or grid[x][y] == '0':
            return
        grid[x][y] = '0'
        dfs(x + 1, y)
        dfs(x - 1, y)
        dfs(x, y + 1)
        dfs(x, y - 1)

    count = 0
    for i in range(len(grid)):
        for j in range(len(grid[0])):
            if grid[i][j] == '1':
                dfs(i, j)
                count += 1
    return count

# 调用函数
print(numIslands([["1","1","1","1","0"],
                  ["1","1","0","1","0"],
                  ["1","1","0","0","0"],
                  ["0","0","0","0","0"]]))

输出：1