一文搞定回溯算法

TenPeaches

已于 2024-11-22 19:47:27 修改

阅读量938

点赞数 20

分类专栏：数据结构与算法文章标签：算法

于 2024-11-10 21:22:40 首次发布

本文链接：https://blog.youkuaiyun.com/2403_85375987/article/details/143666335

版权

数据结构与算法专栏收录该内容

17 篇文章

订阅专栏

回溯算法

算法入门

给定一棵二叉树，搜索并记录所有值为 7 的节点，请返回节点列表。

/* 前序遍历：例题一 */
void preOrderTraversal(TreeNode node) {
    if (node != null) {
        if (node.val == 7) {
            // 记录解
            res.add(node);
        }
        preOrderTraversal(node.left);
        preOrderTraversal(node.right);
    }
}

“尝试”与“回退”

在二叉树中搜索所有值为 7 的节点， 请返回根节点到这些节点的路径 。

/* 前序遍历：例题二 */
void preOrderTraversal(TreeNode node) {
    if (node == null) {
        return;
    }
    // 尝试
    path.add(node);
    if (node.val == 7) {
        // 记录解
        res.add(new ArrayList<>(path));
    }
    preOrderTraversal(node.left);
    preOrderTraversal(node.right);
    // 回退
    path.remove(path.size() - 1);
}

在每次“尝试”中，通过将当前节点添加进 path 来记录路径；而在“回退”前，我们需要将该节点从

path 中弹出， 以恢复本次尝试之前的状态 。

剪枝

在二叉树中搜索所有值为 7 的节点，请返回根节点到这些节点的路径， 并要求路径中不包含值为 3 的节点。

/* 前序遍历：例题三 */
void preOrderTraversal(TreeNode node) {
    // 剪枝
    if (node == null || node.val == 3) {
        return;
    }
    // 尝试
    path.add(node);
    if (node.val == 7) {
        // 记录解
        res.add(new ArrayList<>(path));
    }
    preOrderTraversal(node.left);
    preOrderTraversal(node.right);
    // 回退
    path.remove(path.size() - 1);
}

剪枝:遇到值为3的节点则提前返回

完整代码：

/* 判断当前状态是否为解 */
boolean isSolution(List<TreeNode> currentState) {
    return !currentState.isEmpty() && currentState.get(currentState.size() - 1).val == 7;
}

/* 记录解 */
void recordSolution(List<TreeNode> currentState, List<List<TreeNode>> results) {
    results.add(new ArrayList<>(currentState));
}

/* 判断在当前状态下，该选择是否合法 */
boolean isValid(List<TreeNode> currentState, TreeNode option) {
    return option != null && option.val != 3;
}

/* 更新状态 */
void makeChoice(List<TreeNode> currentState, TreeNode option) {
    currentState.add(option);
}

/* 恢复状态 */
void undoChoice(List<TreeNode> currentState) {
    currentState.remove(currentState.size() - 1);
}

/* 回溯算法：例题三 */
void backtrack(List<TreeNode> currentState, List<TreeNode> availableChoices, List<List<TreeNode>> results) {
    // 检查是否为解
    if (isSolution(currentState)) {
        // 记录解
        recordSolution(currentState, results);
    }
    // 遍历所有选择
    for (TreeNode option : availableChoices) {
        // 剪枝：检查选择是否合法
        if (isValid(currentState, option)) {
            // 尝试：做出选择，更新状态
            makeChoice(currentState, option);
            // 进行下一轮选择
            backtrack(currentState, Arrays.asList(option.left, option.right), results);
            // 回退：撤销选择，恢复到之前的状态
            undoChoice(currentState);
        }
    }
}

保留 return记录解后返回，不再继续搜索

删除 return记录解后不返回，继续搜索

全排列问题

输入一个整数数组，其中不包含重复元素，返回所有可能的排列。

/* 回溯算法：全排列 I */
void backtrack(List<Integer> currentState, int[] options, boolean[] used, List<List<Integer>> results) {
    // 当状态长度等于元素数量时，记录解
    if (currentState.size() == options.length) {
        results.add(new ArrayList<>(currentState));
        return;
    }
    // 遍历所有选择
    for (int i = 0; i < options.length; i++) {
        int option = options[i];
        // 剪枝：不允许重复选择元素
        if (!used[i]) {
            // 尝试：做出选择，更新状态
            used[i] = true;
            currentState.add(option);
            // 进行下一轮选择
            backtrack(currentState, options, used, results);
            // 回退：撤销选择，恢复到之前的状态
            used[i] = false;
            currentState.remove(currentState.size() - 1);
        }
    }
}

/* 全排列 I */
List<List<Integer>> permutationsI(int[] nums) {
    List<List<Integer>> results = new ArrayList<>();
    backtrack(new ArrayList<>(), nums, new boolean[nums.length], results);
    return results;
}

输入一个整数数组，数组中可能包含重复元素，返回所有不重复的排列。

/* 回溯算法：全排列 II */
void backtrack(List<Integer> currentState, int[] options, boolean[] used, List<List<Integer>> results) {
    // 当状态长度等于元素数量时，记录解
    if (currentState.size() == options.length) {
        results.add(new ArrayList<>(currentState));
        return;
    }
    // 遍历所有选择
    Set<Integer> seen = new HashSet<>();
    for (int i = 0; i < options.length; i++) {
        int option = options[i];
        // 剪枝：不允许重复选择元素 且 不允许重复选择相等元素
        if (!used[i] && !seen.contains(option)) {
            // 尝试：做出选择，更新状态
            seen.add(option); // 记录选择过的元素值
            used[i] = true;
            currentState.add(option);
            // 进行下一轮选择
            backtrack(currentState, options, used, results);
            // 回退：撤销选择，恢复到之前的状态
            used[i] = false;
            currentState.remove(currentState.size() - 1);
        }
    }
}

/* 全排列 II */
List<List<Integer>> permutationsII(int[] nums) {
    List<List<Integer>> results = new ArrayList<>();
    backtrack(new ArrayList<>(), nums, new boolean[nums.length], results);
    return results;
}

子集和问题

给定一个正整数数组 nums 和一个目标正整数 target ，请找出所有可能的组合，使得组合中的元素和等于 target 。给定数组无重复元素，每个元素可以被选取多次。请以列表形式返回这些组合，列表中不应包含重复组合。

/* 回溯算法：子集和 I */
void backtrack(List<Integer> currentSubset, int target, int[] options, int start, List<List<Integer>> results) {
    // 子集和等于 target 时，记录解
    if (target == 0) {
        results.add(new ArrayList<>(currentSubset));
        return;
    }
    // 遍历所有选择
    // 剪枝二：从 start 开始遍历，避免生成重复子集
    for (int i = start; i < options.length; i++) {
        // 剪枝一：若子集和超过 target ，则直接结束循环
        // 这是因为数组已排序，后边元素更大，子集和一定超过 target
        if (target - options[i] < 0) {
            break;
        }
        // 尝试：做出选择，更新 target 和 start
        currentSubset.add(options[i]);
        // 进行下一轮选择
        backtrack(currentSubset, target - options[i], options, i, results);
        // 回退：撤销选择，恢复到之前的状态
        currentSubset.remove(currentSubset.size() - 1);
    }
}

/* 求解子集和 I */
List<List<Integer>> subsetSumI(int[] nums, int target) {
    List<Integer> currentSubset = new ArrayList<>(); // 状态（子集）
    Arrays.sort(nums); // 对 nums 进行排序
    int start = 0; // 遍历起始点
    List<List<Integer>> results = new ArrayList<>(); // 结果列表（子集列表）
    backtrack(currentSubset, target, nums, start, results);
    return results;
}

给定一个正整数数组 nums 和一个目标正整数 target ，请找出所有可能的组合，使得组合中的元素和等于 target 。 给定数组可能包含重复元素，每个元素只可被选择一次 。请以列表形式返回这些组合，列表中不应包含重复组合。

/* 回溯算法：子集和 II */
void backtrack(List<Integer> currentSubset, int target, int[] options, int start, List<List<Integer>> results) {
    // 子集和等于 target 时，记录解
    if (target == 0) {
        results.add(new ArrayList<>(currentSubset));
        return;
    }
    // 遍历所有选择
    // 剪枝二：从 start 开始遍历，避免生成重复子集
    // 剪枝三：从 start 开始遍历，避免重复选择同一元素
    for (int i = start; i < options.length; i++) {
        // 剪枝一：若子集和超过 target ，则直接结束循环
        // 这是因为数组已排序，后边元素更大，子集和一定超过 target
        if (target - options[i] < 0) {
            break;
        }
        // 剪枝四：如果该元素与左边元素相等，说明该搜索分支重复，直接跳过
        if (i > start && options[i] == options[i - 1]) {
            continue;
        }
        // 尝试：做出选择，更新 target 和 start
        currentSubset.add(options[i]);
        // 进行下一轮选择
        backtrack(currentSubset, target - options[i], options, i + 1, results);
        // 回退：撤销选择，恢复到之前的状态
        currentSubset.remove(currentSubset.size() - 1);
    }
}

/* 求解子集和 II */
List<List<Integer>> subsetSumII(int[] nums, int target) {
    List<Integer> currentSubset = new ArrayList<>(); // 状态（子集）
    Arrays.sort(nums); // 对 nums 进行排序
    int start = 0; // 遍历起始点
    List<List<Integer>> results = new ArrayList<>(); // 结果列表（子集列表）
    backtrack(currentSubset, target, nums, start, results);
    return results;
}

n 皇后问题

根据国际象棋的规则，皇后可以攻击与同处一行、一列或一条斜线上的棋子。给定 𝑛 个皇后和一个𝑛 × 𝑛 大小的棋盘，寻找使得所有皇后之间无法相互攻击的摆放方案。

/* 回溯算法：n 皇后 */
void backtrack(int currentRow, int n, List<List<String>> board, List<List<List<String>>> results,
                boolean[] cols, boolean[] diagonals1, boolean[] diagonals2) {
    // 当放置完所有行时，记录解
    if (currentRow == n) {
        List<List<String>> copyBoard = new ArrayList<>();
        for (List<String> row : board) {
            copyBoard.add(new ArrayList<>(row));
        }
        results.add(copyBoard);
        return;
    }
    // 遍历所有列
    for (int col = 0; col < n; col++) {
        // 计算该格子对应的主对角线和次对角线
        int diag1 = currentRow - col + n - 1;
        int diag2 = currentRow + col;
        // 剪枝：不允许该格子所在列、主对角线、次对角线上存在皇后
        if (!cols[col] && !diagonals1[diag1] && !diagonals2[diag2]) {
            // 尝试：将皇后放置在该格子
            board.get(currentRow).set(col, "Q");
            cols[col] = diagonals1[diag1] = diagonals2[diag2] = true;
            // 放置下一行
            backtrack(currentRow + 1, n, board, results, cols, diagonals1, diagonals2);
            // 回退：将该格子恢复为空位
            board.get(currentRow).set(col, "#");
            cols[col] = diagonals1[diag1] = diagonals2[diag2] = false;
        }
    }
}

/* 求解 n 皇后 */
List<List<List<String>>> nQueens(int n) {
    // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
    List<List<String>> board = new ArrayList<>();
    for (int i = 0; i < n; i++) {
        List<String> row = new ArrayList<>();
        for (int j = 0; j < n; j++) {
            row.add("#");
        }
        board.add(row);
    }
    boolean[] cols = new boolean[n]; // 记录列是否有皇后
    boolean[] diagonals1 = new boolean[2 * n - 1]; // 记录主对角线上是否有皇后
    boolean[] diagonals2 = new boolean[2 * n - 1]; // 记录次对角线上是否有皇后
    List<List<List<String>>> results = new ArrayList<>();
    backtrack(0, n, board, results, cols, diagonals1, diagonals2);
    return results;
}

相关例题

leetcode104.二叉树的最大深度

104. 二叉树的最大深度https://leetcode.cn/problems/maximum-depth-of-binary-tree/

法一：深度优先遍历

public class Method01 {
    // 定义一个方法，用来计算二叉树的最大深度
    public int maxDepth(TreeNode root) {
        // 如果当前节点为空，则返回深度0
        if(root == null){
            return 0;
        } else {
            // 递归计算左子树的深度
            int leftDepth = maxDepth(root.left);
            // 递归计算右子树的深度
            int rightDepth = maxDepth(root.right);
            // 返回左子树和右子树深度的最大值加1（当前节点）
            return Math.max(leftDepth, rightDepth) + 1;
        }
    }
}

法二：广度优先遍历

public class Method02 {
    // 定义一个方法，用来计算二叉树的最大深度
    public int maxDepth(TreeNode root) {
        // 如果当前节点为空，则返回深度0
        if (root == null) {
            return 0;
        }

        // 创建一个队列用于广度优先搜索（BFS）
        Queue<TreeNode> queue = new LinkedList<>();
        // 将根节点加入队列
        queue.offer(root);
        // 初始化树的高度
        int height = 0;

        // 当队列不为空时，不断进行层级遍历
        while (!queue.isEmpty()) {
            // 记录当前层的节点数量
            int size = queue.size();
            // 遍历当前层的每一个节点
            for (int i = 0; i < size; i++) {
                // 从队列中取出一个节点
                TreeNode node = queue.poll();
                // 如果左子节点不为空，则加入队列
                if (node.left != null) {
                    queue.offer(node.left);
                }
                // 如果右子节点不为空，则加入队列
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            // 层级遍历完当前层，高度加1
            height++;
        }
        // 返回二叉树的最大深度
        return height;
    }
}

leetcode113.路径总和Ⅱ113. 路径总和 IIhttps://leetcode.cn/problems/path-sum-ii/法一：深度优先遍历

public class Method01 {
    // 主方法，用于寻找路径和等于目标值的所有路径
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        // 调用递归方法开始寻找路径
        pS(root, targetSum);
        // 返回所有符合条件的路径
        return res;
    }

    // 存储所有符合条件的路径结果
    List<List<Integer>> res = new ArrayList<>();
    // 存储当前路径的节点值
    List<Integer> path = new ArrayList<>();

    // 递归方法：用于遍历树并寻找路径
    public void pS(TreeNode root, int targetSum) {
        // 如果当前节点为空，直接返回
        if (root == null) {
            return;
        }

        // 将当前节点的值加入路径
        path.add(root.val);
        // 减去当前节点的值，更新目标值
        targetSum -= root.val;

        // 如果目标值为0且当前节点是叶子节点，表示找到一条有效路径
        if (targetSum == 0 && root.left == null && root.right == null) {
            // 添加当前路径的副本到结果中，确保后续的修改不影响结果
            res.add(new ArrayList<>(path));
        }

        // 递归查找左子树
        pS(root.left, targetSum);
        // 递归查找右子树
        pS(root.right, targetSum);

        // 回溯：移除当前节点，准备探索其他路径
        path.remove(path.size() - 1);
    }
}

leetcode46.全排列

46. 全排列https://leetcode.cn/problems/permutations/

法一：回溯

public class Method01 {
    // 存储输入的数字列表
    List<Integer> nums = new ArrayList<>();
    // 存储所有排列结果的列表
    List<List<Integer>> res = new ArrayList<>();

    // 深度优先搜索函数，参数 x 表示当前固定的位置
    void dfs(int x) {
        // 如果 x 达到 nums 的最后一个索引，表示已生成一个完整的排列
        if (x == nums.size() - 1) {
            // 将当前排列方案添加到结果列表中
            res.add(new ArrayList<>(nums));
            return;
        }
        // 遍历当前位置 x 到列表末尾的每个元素
        for (int i = x; i < nums.size(); i++) {
            // 交换，将 nums[i] 固定在第 x 位
            Collections.swap(nums, x, i);
            // 递归调用，固定下一个位置
            dfs(x + 1);
            // 恢复交换，回到原始状态，便于下一次循环
            Collections.swap(nums, x, i);
        }
    }

    // 主函数，接收一个整型数组并生成所有排列
    public List<List<Integer>> permute(int[] nums) {
        // 将传入的数组元素添加到成员变量 nums 中
        for (int num : nums) {
            this.nums.add(num);
        }
        // 从第一个位置开始进行深度优先搜索
        dfs(0);
        // 返回所有生成的排列结果
        return res;
    }
}

leetcode47.全排列Ⅱ

47. 全排列 IIhttps://leetcode.cn/problems/permutations-ii/

法一：回溯

public class Method01 {
    // 存储输入的数字列表
    List<Integer> nums = new ArrayList<>();
    // 存储所有排列结果的列表
    List<List<Integer>> res = new ArrayList<>();

    // 深度优先搜索函数，参数 x 表示当前固定的位置
    void dfs(int x) {
        // 如果 x 达到 nums 的最后一个索引，表示已生成一个完整的排列
        if (x == nums.size() - 1) {
            // 将当前排列方案添加到结果列表中
            res.add(new ArrayList<>(nums));
            return;
        }
        HashSet<Integer> set = new HashSet<>();
        // 遍历当前位置 x 到列表末尾的每个元素
        for (int i = x; i < nums.size(); i++) {
            // 如果当前元素与之前的元素相同，则跳过
            if (set.contains(nums.get(i))) {
                continue;
            }
            // 记录当前元素，避免重复使用
            set.add(nums.get(i));
            // 交换，将 nums[i] 固定在第 x 位
            Collections.swap(nums, x, i);
            // 递归调用，固定下一个位置
            dfs(x + 1);
            // 恢复交换，回到原始状态，便于下一次循环
            Collections.swap(nums, x, i);
        }
    }

    // 主函数，接收一个整型数组并生成所有排列
    public List<List<Integer>> permuteUnique(int[] nums) {
        // 将传入的数组元素添加到成员变量 nums 中
        for (int num : nums) {
            this.nums.add(num);
        }
        // 从第一个位置开始进行深度优先搜索
        dfs(0);
        // 返回所有生成的排列结果
        return res;
    }
}

leetcode39组合总和

39. 组合总和https://leetcode.cn/problems/combination-sum/

法一：回溯

public class Method01 {
    // 存储所有符合条件的组合结果
    List<List<Integer>> res = new ArrayList<>();
    // 存储当前组合的临时列表
    List<Integer> tmp = new ArrayList<>();

    // 主函数，接收候选数组和目标值，返回所有组合
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        back(candidates, target, 0); // 从索引 0 开始进行回溯
        return res; // 返回所有组合结果
    }

    // 回溯方法，candidates 是候选数组，target 是当前目标值，cur 是当前索引
    public void back(int[] candidates, int target, int cur) {
        // 如果当前目标值为 0，表示找到一个有效组合
        if (target == 0) {
            res.add(new ArrayList<>(tmp)); // 将当前组合添加到结果列表中
            return;
        }

        // 遍历 candidates 数组，从当前索引 cur 开始
        for (int i = cur; i < candidates.length; i++) {
            // 如果当前候选值小于等于目标值，则可以加入当前组合
            if (candidates[i] <= target) {
                tmp.add(candidates[i]); // 将候选值加入当前组合
                // 递归调用 back 方法，更新目标值和保持当前索引 i（允许重复）
                back(candidates, target - candidates[i], i);
                // 移除最后一个加入的元素，以尝试其他组合
                tmp.remove(tmp.size() - 1);
            }
        }
    }
}

leetcode40.组合总和Ⅱ

40. 组合总和 IIhttps://leetcode.cn/problems/combination-sum-ii/

法一：回溯

public class Method01 {
    // 存储所有满足条件的组合结果
    List<List<Integer>> res = new ArrayList<>();
    // 存储当前的组合状态
    List<Integer> nums = new ArrayList<>();

    // 主方法，计算组合和为目标值的组合
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        // 首先对候选数组进行排序，以便于后续处理
        Arrays.sort(candidates);
        // 调用回溯法进行组合查找
        backtrack(candidates, target, 0, nums, res);
        // 返回所有找到的组合
        return res;
    }

    // 回溯法实现
    void backtrack(int[] choices, int target, int start, List<Integer> state, List<List<Integer>> res) {
        // 如果当前目标值为0，说明找到了一组有效组合
        if (target == 0) {
            res.add(new ArrayList<>(state)); // 将当前组合加入结果列表
            return;
        }

        // 遍历候选数组
        for (int i = start; i < choices.length; i++) {
            // 如果当前选项超过目标值，后续的选项也不可能满足条件，直接退出循环
            if (target - choices[i] < 0) {
                break;
            }
            // 跳过重复的元素以避免产生重复的组合
            if (i > start && choices[i] == choices[i - 1]) {
                continue;
            }
            // 选择当前元素并加入组合
            state.add(choices[i]);
            // 继续递归查找剩余的目标值
            backtrack(choices, target - choices[i], i + 1, state, res);
            // 撤销选择，回溯到上一步
            state.remove(state.size() - 1);
        }
    }
}

leetcode79.单词搜索

79. 单词搜索https://leetcode.cn/problems/word-search/

法一：回溯

public class Method01 {
    // 主方法，检查字符矩阵中是否包含给定单词
    public boolean exist(char[][] board, String word) {
        // 将单词转换为字符数组
        char[] words = word.toCharArray();
        // 遍历每个位置作为起始点
        for(int i = 0; i < board.length; i++) {
            for(int j = 0; j < board[0].length; j++) {
                // 从当前位置开始进行深度优先搜索
                if (dfs(board, words, i, j, 0)) return true;
            }
        }
        // 如果遍历完所有位置都没有找到单词，则返回 false
        return false;
    }

    // 深度优先搜索方法
    boolean dfs(char[][] board, char[] word, int i, int j, int k) {
        // 检查当前索引是否越界或字符是否不匹配
        if (i >= board.length || i < 0 || j >= board[0].length || j < 0 || board[i][j] != word[k]) return false;

        // 如果当前字符是单词的最后一个字符，返回 true
        if (k == word.length - 1) return true;

        // 标记当前字符为已访问（使用一个特殊字符，如'\0'）
        board[i][j] = '\0';

        // 进行四个方向的深度优先搜索，检查下一个字符
        boolean res = dfs(board, word, i + 1, j, k + 1) ||  // 下方
                dfs(board, word, i - 1, j, k + 1) ||  // 上方
                dfs(board, word, i, j + 1, k + 1) ||  // 右侧
                dfs(board, word, i, j - 1, k + 1);    // 左侧

        // 将当前字符恢复为原来的值，以便下次搜索使用
        board[i][j] = word[k];
        return res; // 返回是否找到完整的单词
    }
}

文章记录了学习Krahets的《Hello 算法》的轨迹，代码均使用Java语言，原书支持 Python、C++、Java、C#、Go、Swift、JavaScript、TypeScript、Dart、 Rust、C 和 Zig 等语言。

教程链接：krahets/hello-algo: 《Hello 算法》：动画图解、一键运行的数据结构与算法教程。支持 Python, Java, C++, C, C#, JS, Go, Swift, Rust, Ruby, Kotlin, TS, Dart 代码。简体版和繁体版同步更新，English version ongoing (github.com)https://github.com/krahets/hello-algo