回溯算法题

已于 2022-04-09 17:57:48 修改
阅读量690 收藏
点赞数
分类专栏： Java 刷题 蓝桥杯 文章标签： 数据结构 算法
于 2022-03-22 22:57:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62226325/article/details/123672589
版权

一，回溯题的常用模板：

注意模板：在选择之前需要排除不合法的选择！！！！ 

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16 注意体会做选择和撤销选择 

如下面的dfs所示：

★向一路子节点一直进行遍历，直到子节点为null，此时就要进行return了，一直return到某个拥有右子节点的子节点，这个return的过程便是回溯。

★回溯使我们可以遍历所有的子节点（即可以遍历所有的情况），所以，我们是不是可以使用回溯来进行一些类似的操作（全排列，子集，组合问题）

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

下面情况均分需不需要index和i++来进行讨论。

二，普通的回溯算法

1.电话号码的字母组合

★需要index，需要i++情况

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 只是比普通的回溯算法加多了对数据的处理而已

注意使用字符串时（StringBuilder添加字符和删除字符的操作）

该题需要记录index来进行判断，而且字符不可能重复，故不需要进行去重的操作，i从0开始即可

class Solution {
    public List<String> letterCombinations(String digits) {
        List<String> res = new ArrayList();
        if (digits.length() == 0) {
            return res;
        }
        //将所有可能的组合放入哈希表中
        Map<Character,String> map = new HashMap() {
            {
                put('2', "abc");
                put('3', "def");
                put('4', "ghi");
                put('5', "jkl");
                put('6', "mno");
                put('7', "pqrs");
                put('8', "tuv");
                put('9', "wxyz");
            } };
        backTrace(res, map, digits,0, new StringBuilder());
        return res;
    }

    public static void backTrace(List<String> res,Map<Character,String> map,String digits,int index,StringBuilder re){
        //简单的basecase
        if(index == digits.length()){
            res.add(re.toString());
            return;
        }
        //获取当前数组对应的字母
        char c = digits.charAt(index);
        String s = map.get(c);
        int l = s.length();
        //对所有可能做选择
        for(int i = 0; i < l;i++){
            re.append(s.charAt(i));
            backTrace(res,map,digits,index + 1,re);
            re.deleteCharAt(index);
        }
    }
}

2.组合总和 

★需要index，不需要i++情况

该题中：2+3+2和3+2+2是一样的，故需要从index开始，而且一个数字可以使用多次（即做选择的时候，该选择可选择多次，不需要下次判断时排除掉），故不需要i++； 

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        backTrace(res,candidates,target,0,re);
        return res;
    }
    public static void backTrace(List<List<Integer>> res,int[] candidates,int target,int index,List<Integer> re){
        if(target < 0){
            return;
        }
        if(target == 0){
            res.add(new ArrayList<>(re));
            return;
        }
        for(int i = index; i < candidates.length;i++){
            re.add(candidates[i]);
            backTrace(res,candidates,target - candidates[i],i,re);
            re.remove(re.size() - 1);
        }
    }
}

三，回溯的去重问题 

1.组合总和②

★需要index，不需要i++；

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

上一题的进阶版，难点为去重，下面是我一开始的错误思路，使用set来去重，但只是去掉了数字的重复，组合的重复并没有解决 

原因：我们都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一个树枝上使用过，一个维度是同一树层上使用过。

回看一下题目，元素在同一个组合内是可以重复的，怎么重复都没事，但两个组合不能相同。

所以我们要去重的是同一树层上的“使用过”，同一树枝上的都是一组合里的元素，不用去重。（树层去重是需要对数组进行排序的）

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        HashSet<Integer> set = new HashSet();
        backTrack(res,target,candidates,0,re,set);
        return res;
    }
    public void backTrack(List<List<Integer>> res,int target,int[] candidates,int index,List<Integer> re,HashSet<Integer> set){
        if(target < 0){
            return;
        }
        if(target == 0){
             set.clear();
            res.add(new ArrayList<>(re));
        }
        for(int i = index; i < candidates.length;i++){
            if(!set.contains(candidates[i])){
            re.add(candidates[i]);
            set.add(candidates[i]);
            }else{
                continue;
            }
            backTrack(res,target - candidates[i],candidates,i,re,set);
            re.remove(re.size() - 1);
        }
    }
}

 正解：注意一定要先对数组进行排序

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
         Arrays.sort(candidates);
        backTrack(res,target,candidates,0,re);
        return res;
    }
    public void backTrack(List<List<Integer>> res,int target,int[] candidates,int index,List<Integer> re){
        if(target < 0){
            return;
        }
        if(target == 0){
            res.add(new ArrayList<>(re));
        }
        for(int i = index; i < candidates.length;i++){
            if(candidates[i]<=target){
                if(i>index&&candidates[i]==candidates[i-1]){
                    continue;
                }
            re.add(candidates[i]);
            backTrack(res,target - candidates[i],candidates,i + 1,re);
            re.remove(re.size() - 1);
        }
    }
    }
}

重点体会：

这里使用了index，就不需要使用used数组了

 if(i>index&&candidates[i]==candidates[i-1]){
                    continue;
                } 

前面我们提到：要去重的是“同一树层上的使用过”，如何判断同一树层上元素（相同的元素）是否使用过了呢。

如果candidates[i] == candidates[i - 1] 并且 used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。

此时for循环里就应该做continue的操作。

如图所示：

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 将used的变化用橘黄色标注上，可以看出在candidates[i] == candidates[i - 1]相同的情况下：

  • used[i - 1] == true，说明同一树支candidates[i - 1]使用过
  • used[i - 1] == false，说明同一树层candidates[i - 1]使用过

这块去重很抽象，很少题解能够讲清楚，更多的是自己的思考

四，全排列问题

1. 全排列

★不需要index，不需要i++；

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 我的错误解法：

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        int[] use = new int[nums.length];
        if(nums.length == 1){
            re.add(nums[0]);
            res.add(re);
            return res;
        }
        backTrace(res,re,nums);
        return res;
    }
    public void backTrace(List<List<Integer>> res, List<Integer> re,int[] nums){
        if(re.size() == nums.length){
            res.add(new ArrayList(re));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            re.add(nums[i]);
            backTrace(res,re,nums);
            re.remove(re.size() - 1);
        }
    }
    }

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 选择从i = 0 开始，每次选择都选择全部，故有误

正确答案就是在上面的思路上，添加一个used表，把当前选择中已经选择过的排除，就只能选择剩下的数字，而不会出现重复的情况（前提：题目为给出不重复的数字，有重复就不行）

 

 错误使用index也会出现错误哦

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        int[] used = new int[nums.length];
        if(nums.length == 1){
            re.add(nums[0]);
            res.add(re);
            return res;
        }
        backTrace(res,re,nums,0);
        return res;
    }
    public void backTrace(List<List<Integer>> res, List<Integer> re,int[] nums,int index){
        if(re.size() == nums.length){
            res.add(new ArrayList(re));
            return;
        }
        for(int i = index;i < nums.length;i++){
            re.add(nums[i]);
            backTrace(res,re,nums,i);
            re.remove(re.size() - 1);
        }
    }
    }

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

那么如果出现重复数字又该如何全排列呢？

2.全排列②

思路其实和上面的去重一样（记得先排序）

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 class Solution {
    // 创建一个全局变量集合，保存结果
    List<List<Integer>> alist=new  ArrayList<List<Integer>>();
     // 讲数组的长度变为全局变量
    int len;
    public List<List<Integer>> permuteUnique(int[] nums) {
       this.len=nums.length;
         // 创建一个贯穿整个递归过程的集合
        ArrayList<Integer> all=new ArrayList<Integer>();
        /*
         下面这个想法打错特错这样会导致最后一层的元素肯定都是被标记过的导致无元素可加
         好像也不是完全错只是我忽略了数组也是引用类型，返回上一层时，应撤销在本层的操作
        // 想到一个解决方法：参数中加上一个visited数组，将该层已经访问过的数子标记
         */
         int[] visited=new int[len]; 
         dfs(nums,visited,all,0);
        return alist;
     }
     public void dfs(int[] nums,int[] visited,ArrayList list,int index){
         // 出口
         if(list.size()==len){
             // 因为list是引用变量所以需要创建一个新的集合来保存list中的数据
             ArrayList<Integer> temp=new ArrayList<Integer>(list);
             alist.add(temp);
             return ;
         }
         // 将符合条件的集合加入到alist中
         for(int i=0;i<len;i++){
             if(visited[i]==1){
                 continue;
             }
             // 如果是没有访问过的就将它加入集合
              list.add(nums[i]); 
              visited[i]=1;
             dfs(nums,visited,list,index+1);
            // 回退到上一层之前将本层加入的数据给去掉
              list.remove(list.size()-1);  
              visited[i]=0;    
         }
     }
 }

//上面的代码解决了自己引用自己的问题，可是在同一层有重复元素怎么办
// 例如 [1,1,2]  上面的代码可以得出  
//[[1,1,2],[1,2,1],[1,1,2],[1,2,1],[2,1,1],[2,1,1]]
// 可它有两个重复的1，就那第1层说是，他们两肯定可以获得重复的结果，怎么解决
// 大佬给出了解决方法：先对数组进行排序，就是如果该元素的前面有和它一样的元素，那这个元素就别用了
class Solution {
    // 创建一个全局变量集合，保存结果
    List<List<Integer>> alist=new  ArrayList<List<Integer>>();
    // 讲数组的长度变为全局变量
    int len;
    public List<List<Integer>> permuteUnique(int[] nums) {
        this.len=nums.length;
        // 创建一个贯穿整个递归过程的集合
        ArrayList<Integer> all=new ArrayList<Integer>();
        /*
        下面这个想法打错特错这样会导致最后一层的元素肯定都是被标记过的导致无元素可加
        好像也不是完全错只是我忽略了数组也是引用类型，返回上一层时，应撤销在本层的操作
        // 想到一个解决方法：参数中加上一个visited数组，将该层已经访问过的数子标记
        */
        int[] visited=new int[len]; 
        // 对数组进行排序
        Arrays.sort(nums);
        dfs(nums,visited,all,0);
        return alist;
    }
    public void dfs(int[] nums,int[] visited,ArrayList list,int index){
        // 出口
        if(list.size()==len){
        // 因为list是引用变量所以需要创建一个新的集合来保存list中的数据
        ArrayList<Integer> temp=new ArrayList<Integer>(list);
        alist.add(temp);
        return ;
        }
        // 将符合条件的集合加入到alist中
        for(int i=0;i<len;i++){
            // visit解决了自己访问自己的问题,并且
            if(visited[i]==1){
                continue;
            }
            // 现在解决同一层出现重复元素的问题
            // 为什么要加上这个？visited[i-1]==0
            // 解释在下面
            if(i>0&&nums[i]==nums[i-1] && visited[i-1]==0){
                continue;
            }
            // 如果是没有访问过的就将它加入集合
             list.add(nums[i]); 
             visited[i]=1;
            dfs(nums,visited,list,index+1);
            // 回退到上一层之前将本层加入的数据给去掉
             list.remove(list.size()-1);  
             visited[i]=0;    
        }
    }
}

/*
大神的理解：for循环保证了从数组中从前往后一个一个取值，再用if判断条件。所以nums[i - 1]一定比nums[i]先被取值和判断。如果nums[i - 1]被取值了，那vis[i - 1]会被置1，只有当递归再回退到这一层时再将它置0。每递归一层都是在寻找数组对应于递归深度位置的值，每一层里用for循环来寻找。所以当vis[i - 1] == 1时，说明nums[i - 1]和nums[i]分别属于两层递归中，也就是我们要用这两个数分别放在数组的两个位置，这时不需要去重。但是当vis[i - 1] == 0时，说明nums[i - 1]和nums[i]属于同一层递归中（只是for循环进入下一层循环），也就是我们要用这两个数放在数组中的同一个位置上，这就是我们要去重的情况。
可以好好的遍历一次就会理解该思路了，遍历时主要是要理解，第2层的元素，在第三层所有的元素被访问后，就会回溯
到第一层，回到第一层后所有的元素是没有标记的，所以去重一定要加上visited[i-1]==0这样才说明他们才是在同一层
[1,1,2]
[1,1,2]
[1,1,2]
*/

 ★重点

上面记录了这么多需不需要index，那到底上面时候需要呢？

其实子集也是一种组合问题，因为它的集合是无序的，子集{1,2} 和 子集{2,1}是一样的。

那么既然是无序，取过的元素不能重复取，写回溯算法的时候，for就要从startIndex开始，而不是从0开始！

那什么时候for可以从0开始呢？

求排列组合问题的时候，就要从0开始，因为排列组合是有序的，{1, 2} 和{2, 1}是两种排序

那什么时候需要i++呢，无序时需要，具体看能不能重复！

1.组合

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 这题出现的是组合，[1,4],[4,1]的组合是一样的，该题目是无序的，故需要从index开始使i++

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 正解为：

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        backTrace(res,re,n,k,1);
        return res;
    }
    public void backTrace(List<List<Integer>> res,List<Integer> re,int n,int k,int index){
        if(re.size() == k){
            res.add(new ArrayList(re));
            return;
        }
        for(int i = index; i <= n; i++){
            re.add(i);
            backTrace(res,re,n,k,i + 1);
            re.remove(re.size() - 1);
        }
    }   
}

 2.子集

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16

 ★易错点

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        ArrayList<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        //先排序
        Arrays.sort(nums);
        //定义一个数组判断是否已经访问过了
        int n = nums.length;
        int[] used = new int[n];
        if(nums == null){
            return res;
        }
        backTrace(res,re,n,used,nums,0);
        return res;
    }
    //子集问题是无序的，故需要一个index，已确保取过的元素不会重复再取
    public void backTrace(ArrayList<List<Integer>> res,List<Integer> re,int n,int[] used,int[] nums, int index){
            //子集问题，不需要basecase
            res.add(new ArrayList(re));
        for(int i = index; i < n; i++){
            if(i > 0&&nums[i] == nums[i - 1] && used[i - 1] == 0){
                continue;
            }
            re.add(nums[i]);
            used[i] = 1;
            backTrace(res,re,n,used,nums,index + 1);
            re.remove(re.size() - 1);
            used[i] = 0;
        }
    }
}

这是在回溯时，回溯条件上写index + 1

提交后的答案 

watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5p-g56C4,size_20,color_FFFFFF,t_70,g_se,x_16 

正解为使用i +1  

class Solution {
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        ArrayList<List<Integer>> res = new ArrayList();
        List<Integer> re = new ArrayList();
        //先排序
        Arrays.sort(nums);
        //定义一个数组判断是否已经访问过了
        int n = nums.length;
        int[] used = new int[n];
        if(nums == null){
            return res;
        }
        backTrace(res,re,n,used,nums,0);
        return res;
    }
    //子集问题是无序的，故需要一个index，已确保取过的元素不会重复再取
    public void backTrace(ArrayList<List<Integer>> res,List<Integer> re,int n,int[] used,int[] nums, int index){
            //子集问题，不需要basecase
            res.add(new ArrayList(re));
        for(int i = index; i < n; i++){
            if(i > 0&&nums[i] == nums[i - 1] && used[i - 1] == 0){
                continue;
            }
            re.add(nums[i]);
            used[i] = 1;
            backTrace(res,re,n,used,nums,i + 1);
            re.remove(re.size() - 1);
            used[i] = 0;
        }
    }
}

 

柠砸
关注
专栏目录
算法基础（Java）--回溯算法
m0_73757009的博客
03-15 1023
s的每一个元素s【i】(i >= 0&&i < n),都为数组a中的任意元素a【j】(j >= 0&&j < n)，不过要保证任意的s【i】不相等。乘以2，格子上填的就是左括号或者右括号，这里的剪枝条件是，当前右括号数量超过了左括号，或左括号数量超过了一半。上面的i代表解空间的第i个位置，往往从0开始，而n则代表解空间的大小。因此我们看到，回溯本身是很简单的，单纯的模板套用，难的在于需要根据回溯条件来定义各种别的变量，以及最后结果的记录。这个向量的每个元素都是问题的部分解，只有当这个数组的每一个元素都。
回溯算法例题，C++实现
12-24
是一道不错的回溯算法学习例题。
回溯算法练习题
S5242的博客
09-14 272
回溯是一个常见的算法，类似于深搜/广搜，会穷举每一个可能。但是会有一个恢复选择的操作。类似于上一题，这里我用了一个deepth变量来控制决策树的层数。
回溯算法及典型例题
qq_43406565的博客
08-25 4542
大多是使用回溯算法的题目都符合以下条件： 输出可以看作一个n元组(x1,x2,…,xn)，例如八皇后问题。 元组需要满足一些约束条件。 个人认为回溯算法和暴力法有很大的相似度，但是回溯算法会在每次构造解的过程中进行剪枝。整个选择过程可以构成一棵状态空间树，树的根可以代表查找解之前的初始状态。大多数情况下可以用DFS的方法来生成状态空间树。如果当前结点是有希望的，可以继续深度遍历，否则回溯到父母节点。 首先来看一道经典例题 一.八皇后问题 1.问题描述 在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击
回溯算法（例题详细解析）
c_study__c的博客
02-08 4698
回溯算法（例题详细解析）涉及到深度优先、广度优先遍历进行回溯，深度解析，详细了解回溯算法
回溯算法讲解--适用于leetcode绝大多数回溯题目
weixin_34198583的博客
02-27 350
什么是回溯算法？回溯法是一种系统搜索问题解空间的方法。为了实现回溯，需要给问题定义一个解空间。说到底它是一种搜索算法。只是这里的搜索是在一个叫做解空间的地方搜索。而往往所谓的dfs，bfs都是在图或者树这种数据结构上的搜索。根据定义来看，要实现回溯，需要两点1搜索，2解空间先看什么是解空间。就是形如数组的一个向量[a1,a2,....,a...
每天一道算法题：分治算法，回归算法，贪心算法，回溯算法.zip
最新发布
08-08
贪心算法 每天一道算法题：分治算法，回归算法，贪心算法，回溯算法.zip
常用算法介绍，及其几道算法题，常见算法包括排序算法、搜索算法、动态规划、贪心算法、回溯算法、分治算法等
07-31
常用算法介绍，及其几道算法题，常见算法包括排序算法、搜索算法、动态规划、贪心算法、回溯算法、分治算法等
回溯相关题目
吹灭读书灯 一身都是月
08-23 340
一：排列问题 题目描述：         二：组合问题 题目描述：给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。 说明： 所有数字（包括 target）都是正整数。 解集不能包含重复的组合。  示例 1: 输入: can...
回溯题目/排列、组合、子集问题
yanglq的博客
07-29 562
排列、组合的题目大部分用到回溯法。这部分也包含不是回溯法的题目。 总结： （1）回溯法一般只包含引用变量，不含临时变量 （2）重复的数设置哈希表判断 （3） 一、组合 39. Combination Sum  组合之和（没有重复的数,但是同一个数可以重复出现） Given a set of candidate numbers (C) (without duplicates)
回溯法典型题
05-12
用回溯法解决的几道题……
回溯算法常见例题总结
没得选择丶
04-22 827
46.全排列 给定一个没有重复数字的序列，返回其所有可能的全排列。 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] class Solution { public: vector<vector<int>> permute(vector<int>&...
【算法题】回溯
呦呦呦_96的博客
03-10 232
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个...
回溯算法题目练习
qq_43223115的博客
08-11 225
回溯算法题目练习 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 class Solution { List<List<Integer>> list = new ArrayList<>(); List<Integer> track = new ArrayList<>(); public List<List<Integer>> combine(int n, int
回溯算法及题目
weixin_57023347的博客
09-25 1895
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
经典回溯题讲解
倾心之作
12-09 465
目录题目解题思路代码（c++)总结 本篇博客主要讲解一下回溯算法的典型例题。为什么我没有选力扣里的组合总和Ⅰ、Ⅲ或Ⅳ呢？因为除了Ⅳ其他三题都是回溯算法，三题相差不大，Ⅳ是一道动态规划的题我们后面再说。 题目 题目链接： 力扣40：组合总和Ⅱ 给定一个数组 candidates和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。 candidates 中的每个数字在每个组合中只能使用一次。 注意：解集不能包含重复的组合。 示例 1: 输入: candid
回溯算法
Marmara
12-05 1693
一、基本介绍 （一）概念        回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。        回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。...
关于回溯的题目
github_38818603的博客
09-20 352
不关心起始点的位置： https://leetcode.com/problems/max-area-of-island/description/  找到矩阵中最大连通子区域的块数 剑桥offer   找到矩阵中相同的路径 起始点是固定的： 剑桥offer  机器人的运动范围 二叉树找到最长路径/最大距离   https://www.cnblogs.com/wangzaizhen/p/517...
回溯算法例题2
czh_vegetable的博客
03-15 416
回溯算法例题2——leetcode37
比n皇后更复杂的回溯算法题
12-03
以下是一些比n皇后更复杂的回溯算法题： 1. 数独问题：在一个9*9的数独中填入数字，使得每行、每列和每个3*3的小方格中的数字都不重复。 2. 八皇后问题的变种：在一个n*n的棋盘上，放置k个皇后，使得它们互相攻击...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值