回溯算法

已于 2022-09-27 01:51:39 修改
阅读量946 收藏 3
点赞数
分类专栏： 算法 文章标签： 算法
于 2022-04-11 21:29:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38568382/article/details/124108119
版权

1 什么是回溯法？

回溯法，也叫做回溯搜索法，它是一种搜索的方式。

回溯法是递归的副产品，理解了递归才能理解回溯法。

2 怎么理解回溯法？

本质是穷举法，列举出所有的可能性，选出我们想要的答案，并不是什么高效的算法。

如果想让回溯法高效一点，可以增加一些剪枝的操作，但也改变不了穷尽的本质。

3 回溯法的模板

void backTrace(参数){
    if(终止条件){
        存放结果;
        return;
    }
    for(遍历数组){
        选择节点；
        backTrace(参数);
        撤销选择的节点；
    }
}

4 案例分析

LeetCode77：组合

描述：给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

示例 ：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

普通for循环怎么实现？

当n=4，k=2的时候，可以用for循环暴力破解

public class Main {

    public static void main(String[] args) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 4; i++) {
            list.add(i);
            for (int j = i + 1; j <= 4; j++) {
                list.add(j);
                // 凑满两个，塞进去返回结果
                res.add(new ArrayList<>(list));
                list.remove(list.size() - 1);
            }
            list.remove(list.size() - 1);
        }
        System.out.println(res);
    }

}

返回结果：

for暴力破解存在的问题：如果n=100，k=50的情况下，就需要50个for循环。

for(...){

        for(...){

                // 50个循环

                ......

        }

}

无法用常规手段暴力破解，因此需要回溯法递归完成穷举。

回溯法代码实现：

public class LeetCode77 {

    public static void main(String[] args) {
        LeetCode77 leetCode77 = new LeetCode77();
        System.out.println(leetCode77.combine(4, 2));
    }

    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> list = new ArrayList<>();

    public List<List<Integer>> combine(int n, int k) {
        backTrack(n, k, 1);
        return res;
    }

    private void backTrack(int n, int k, int start) {
        if (list.size() == k) {
            res.add(new ArrayList<>(list));
            return;
        }
        for (int i = start; i <= n; i++) {
            list.add(i);
            backTrack(n, k, i + 1);
            list.remove(list.size() - 1);
        }
    }

}

执行结果：

5 LeetCode回溯专题相关

（1）LeetCode39：组合总和

描述：给定一个无重复数字的数组 candidates 和目标整数target ，找出candidates 中数字和为target 的所有组合。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

代码实现：

public class LeetCode39 {

    public static void main(String[] args) {
        int[] arr = new int[]{2, 3, 6, 7};
        int target = 7;
        LeetCode39 leetCode39 = new LeetCode39();
        System.out.println(leetCode39.combinationSum(arr, target));
    }

    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> list = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] nums, int target) {
        backTrace(nums, target, 0);
        return res;
    }

    private void backTrace(int[] nums, int target, int start){
        if(target < 0){
            return;
        }
        if(target == 0){
            res.add(new ArrayList<>(list));
            return;
        }
        for(int i = start; i < nums.length; i++){
            list.add(nums[i]);
            backTrace(nums, target - nums[i], i);
            list.remove(list.size() - 1);
        }
    }

}

执行结果：

（2）LeetCode40：组合总和II

描述：给定一个无重复数字的数组 candidates 和目标整数target ，找出candidates 中数字和为target 的所有组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

示例 1：

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2：

输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]

代码实现：

public class LeetCode40 {

    public static void main(String[] args) {
        LeetCode40 leetCode40 = new LeetCode40();
        System.out.println(leetCode40.combinationSum2(new int[]{10, 1, 2, 7, 6, 1, 5}, 8));
    }

    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> list = new ArrayList<>();

    public List<List<Integer>> combinationSum2(int[] nums, int target) {
        Arrays.sort(nums);
        boolean[] flag = new boolean[nums.length];
        backTrace(nums, target, 0, flag);
        return res;
    }

    private void backTrace(int[] nums, int target, int start, boolean[] flag) {
        if (target < 0) {
            return;
        }
        if (target == 0) {
            res.add(new ArrayList<>(list));
            return;
        }
        for (int i = start; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && !flag[i - 1]) {
                continue;
            }
            list.add(nums[i]);
            flag[i] = true;
            backTrace(nums, target - nums[i], i + 1, flag);
            flag[i] = false;
            list.remove(list.size() - 1);
        }
    }

}

执行结果：

（3）LeetCode46：全排列

描述：给定一个不含重复数字的数组 nums ，返回其所有可能的全排列 。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

代码实现：

public class LeetCode46 {

    public static void main(String[] args) {
        LeetCode46 leetCode46 = new LeetCode46();
        System.out.println(leetCode46.permute(new int[]{1, 2, 3}));
    }

    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> list = new ArrayList<>();

    public List<List<Integer>> permute(int[] nums) {
        boolean[] flag = new boolean[nums.length];
        backTrack(nums, flag);
        return res;
    }

    private void backTrack(int[] nums, boolean[] flag) {
        if (list.size() == nums.length) {
            res.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (flag[i]) {
                continue;
            }
            list.add(nums[i]);
            flag[i] = true;
            backTrack(nums, flag);
            flag[i] = false;
            list.remove(list.size() - 1);
        }
    }

}

执行结果：

（4）LeetCode47：全排列II

描述：给定一个包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

代码实现：

public class LeetCode47 {

    public static void main(String[] args) {
        LeetCode47 leetCode47 = new LeetCode47();
        System.out.println(leetCode47.permuteUnique(new int[]{1, 1, 2}));
    }

    private List<List<Integer>> res = new ArrayList<>();
    private List<Integer> list = new ArrayList<>();

    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        boolean[] flag = new boolean[nums.length];
        backTrace(nums, flag);
        return res;
    }

    private void backTrace(int[] nums, boolean[] flag) {
        if (list.size() == nums.length) {
            res.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (flag[i]) {
                continue;
            }
            if (i > 0 && nums[i] == nums[i - 1] && !flag[i - 1]) {
                continue;
            }
            list.add(nums[i]);
            flag[i] = true;
            backTrace(nums, flag);
            flag[i] = false;
            list.remove(list.size() - 1);
        }
    }

}

执行结果：

（5）LeetCode78：子集

（6）LeetCode90：子集II

Copy Ninja
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法与数据结构面试宝典——回溯算法详解（C#，C++）
qq_35320456的博客
06-23 716
回溯算法是一种递归算法，通过尝试各种可能的组合来找到所有解。它在解决组合问题时非常有用，例如排列、组合、棋盘游戏（如八皇后问题）、0-1背包问题等。回溯算法的主要特点是其递归性质和通过尝试所有可能的组合来找到所有解的能力。它适用于解决组合问题，尤其是那些具有明确状态转移和边界条件的问题。回溯算法的应用价值在于它能够提供一个全面的解决方案集合，这对于某些问题来说是非常重要的，例如在棋盘游戏中的最佳移动或者在优化问题中的所有可行解。
高效 遍历 算法_关于回溯算法，你该了解这些
weixin_39808803的博客
12-02 314
别看回溯法很难，但回溯法就是暴力解法什么是回溯法回溯法也可以叫做回溯搜索法，它是一种搜索的方式。在二叉树系列中，我们已经不止一次，提到了回溯，例如二叉树：以为使用了递归，其实还隐藏着回溯。回溯是递归的副产品，只要有递归就会有回溯。「所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数」。回溯法的效率回溯法的性能如何呢，这里要和大家说清楚了，「虽然回溯法很难，很不好理解，但是回溯法并不是什么高效...
450，什么叫回溯算法，一看就会，一写就废
数据结构和算法
09-14 1673
想了解更多数据结构以及算法题，可以关注微信公众号“数据结构和算法”，每天一题为你精彩解答。也可以扫描下面的二维码关注 什么叫回溯算法 对于回溯算法的定义，百度百科上是这样描述的：回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“
PHP实现的回溯算法示例
10-19
回溯算法是一种在解决问题时，通过尝试所有可能的解决方案，并在发现某一步不满足条件时回退到上一步，甚至更早的一步，撤销刚才所做的选择，继续探索其他可能的分支，直到找到满足条件的解决方案或者所有可能性都...
C++回溯算法实验报告
12-10
回溯算法是一种在问题的解空间树中，按照深度优先搜索策略，通过剪枝操作避免无效搜索，从而求解问题的算法。在这个C++实验中，我们分别通过两个实例来探讨回溯法的应用。 首先，实验的第一个问题是删数问题。这个...
算法分析论文——回溯算法的应用.zip
10-19
回溯算法是一种强大的问题求解方法，尤其在解决复杂组合优化问题时表现出高效性。它是一种试探性的解决问题的方法，通过逐步构建可能的解决方案，并在过程中不断检查这些解决方案的有效性。如果发现当前路径无法导出...
回溯算法旅行售货员问题
05-29
回溯算法旅行商问题代码实现。算法backtrack在最坏情况下可能需要更新当前最优解O(n-1)!)次，每次更新bestx需计算时间O(n)，从而整个算法的计算时间复杂性为O(n!)。
回溯算法求数独的解
01-01
回溯算法则是解决数独问题的一种高效策略，它通过尝试填入数字并检查是否符合规则来逐步求解。 首先，我们需要理解回溯算法的基本思想。回溯法是一种试探性的解决问题的方法，它尝试分步地找出所有可能的解决方案，...
五大常用算法——回溯算法详解及经典例题
qq_37763204的博客
03-11 4万+
回溯算法　　1.回溯算法就是一种有组织的系统最优化搜索技术，可以看作蛮力法穷举搜索的改进。回溯法常常可以避免搜索所有可能的解，所以它适用于求解组织数量较大的问题。　　2.首先我们先了解一下一个基本概念“解空间树”：问题的解空间一般使用解空间树的方式来组织，树的根节点位于第1层，表示搜索的初始状态，依次向下排列。　　3.解空间树的动态搜索：在搜索至树中任一节点时，先判断该节点对应的部分是否是满足约束...
算法入门6：回溯法
热门推荐
JarvisChu的专栏
11-13 9万+
一. 回溯法 – 深度优先搜素                        1. 简单概述 回溯法思路的简单描述是：把问题的解空间转化成了图或者树的结构表示，然后使用深度优先搜索策略进行遍历，遍历的过程中记录和寻找所有可行解或者最优解。 基本思想类同于： 图的深度优先搜索二叉树的后序遍历 【 分支限界法：广度优先搜索 思想类同于：图的广度优先遍历 二叉树的层序
回溯算法详解与应用
"这篇文档是关于使用MATLAB实现回溯算法的讨论，主要涵盖了回溯算法的基本概念、算法思想以及其在解决特定问题中的应用，如货箱装船、背包问题、最大完备子图、旅行商问题和电路板排列问题。文档通过迷宫老鼠问题和0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值