回溯算法题

已于 2022-04-09 17:57:48 修改
阅读量650 收藏
点赞数
分类专栏： 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;
        }
    }
}

 

柠砸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数独C++回溯算法实现
01-03
通过回溯算法，我们可以有效地解决数独问题，并通过用户友好的界面，使玩家能够自定义难度、生成新题、获取提示和撤回操作，提高游戏的趣味性和挑战性。这个项目不仅锻炼了编程技能，也展示了算法在实际问题中的应用...
C语言算法题C语言算法题.zip
01-28
"C语言算法题.zip"这个压缩包很可能包含了一系列的C语言编程练习，旨在帮助学习者提升算法设计和实现的能力。在C语言中，算法是解决问题的关键，通过编写高效的代码，可以有效地处理数据和执行计算任务。 1. **基础...
回溯算法题模板与实战详解
qqrrjj2011的博客
06-03 1079
回溯算法题模板与实战详解
一文弄懂回溯算法（例题详解）
2302_79862386的博客
03-02 1598
回溯是递归的副产品，只要有递归就会有回溯」，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都使用了递归。详细地说：可以将回溯算法过程理解成一颗多叉树的遍历过程， 回溯法按深度优先策略搜索问题的解空间树。首先从根节点出发搜索解空间树，当算法搜索至解空间树的某一节点时，先利用剪枝函数判断该节点是否可行（即能得到问题的解）。如果不可行，则跳过对该节点为根的子树的搜索，逐层向其祖先节点回溯；否则，进入该子树，继续按深度优先策略搜索。void backtrack(参数) {
回溯算法及典型例题
qq_43406565的博客
08-25 4466
大多是使用回溯算法的题目都符合以下条件： 输出可以看作一个n元组(x1,x2,…,xn)，例如八皇后问题。 元组需要满足一些约束条件。 个人认为回溯算法和暴力法有很大的相似度，但是回溯算法会在每次构造解的过程中进行剪枝。整个选择过程可以构成一棵状态空间树，树的根可以代表查找解之前的初始状态。大多数情况下可以用DFS的方法来生成状态空间树。如果当前结点是有希望的，可以继续深度遍历，否则回溯到父母节点。 首先来看一道经典例题 一.八皇后问题 1.问题描述 在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击
经典的回溯算法题leetcode组合问题整理及思路代码详解
xiaoliii0401的博客
11-23 1318
倘若各位不太清楚回溯算法可以去看我上一篇文章。
算法总结-回溯算法
hhhlizhao的博客
03-22 634
回溯算法也可以叫做回溯搜索法，它是一种搜索方法。回溯是递归的副产品，只要有递归就会有回溯（递归中隐藏着回溯算法）。所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数。
算法题-回溯算法
bingbingaidaima的博客
07-15 546
回溯法也叫回溯搜索法，它是一种搜索的方式回溯是递归的副产品，只要有递归就会有回溯。
【算法】回溯算法
Code 小白的博客
06-29 5682
回溯算法
回溯算法:全排列
m0_51436734的博客
04-10 2307
本文解决几个问题： 回溯算法是什么？解决回溯算法相关的问题有什么技巧？如何学习回溯算法？回溯算法代码是否有规律可循？ 其实回溯算法其实就是我们常说的 DFS 算法，本质上就是一种暴力穷举算法。 废话不多说，直接上回溯算法框架。解决一个回溯问题，实际上就是一个决策树的遍历过程。 站在回溯树的一个节点上，你只需要思考 3 个问题： 1、路径：也就是已经做出的选择。 2、选择列表：也就是你当前可以做的选择。 3、结束条件：也就是到达决策树底层，无法再做选择的条件。 如果你不理解这三个词语的解释，没关系，我们后面会
常见的回溯算法例题总结
热门推荐
bajin7353的博客
08-07 1万+
例一：火柴棍摆正方形（leetcode 473） 已知一个数组，保存了N个火柴棍，问是否可以使用这N个火柴棍摆成一个正方形？ 思考： 回溯算法如何设计？ 如何设计递归函数，递归的回溯搜素合适返回真，何时返回假？ 普通的回溯搜索是否可以解决该问题，如何让对深度搜索进行优化？ 算法设计： 想象正方形的4条边即4个桶，将每个火柴杆回溯的放置在每个桶中，在放完N个火柴杆后，检...
回溯算法
天才小熊猫的客栈
05-17 849
1.什么是回溯法 ？ 回溯法也可以叫做回溯搜索法，它是⼀种搜索的⽅式。 回溯是递归的副产品，只要有递归就会有回溯。 所以以下讲解中，回溯函数也就是递归函数，指的都是⼀个函数。 2.回溯法的效率 ： 回溯法并不是什么⾼效的算法。因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法⾼效⼀些，可以加⼀些剪枝的操作，但也改不了回溯法就是穷举的本质。 那么既然回溯法并不⾼效为什么还要⽤它呢？ 因为没得选，⼀些问题能暴⼒搜出来就不错了，撑死了再剪枝⼀下，还没有更⾼效的解法。 3.回溯...
每天一道算法题：分治算法，回归算法，贪心算法，回溯算法.zip
04-25
贪心算法 一般来说，贪婪算法有五个组成部分: 一个候选集：从中创建一个解决方案 一个选择函数：用于选择要添加到解决方案中的最佳候选项 一个可行性函数：用于确定候选项是否可以为解决方案做出贡献 一个目标函数...
DFS.rar_dfs算法习题
09-20
DFS，全称深度优先搜索（Depth-First Search），是一种经典的图论或树遍历算法，广泛应用于解决计算机科学中的各种问题，例如寻找图中的环、判断连通性、求最短路径等。在这个"DFS.rar_dfs算法习题"压缩包中，包含的...
回溯算法例题，C++实现
12-24
回溯算法是一种在解决问题时，通过尝试所有可能的解决方案，并在每一步中排除那些不可能产生正确结果的选项来寻找问题答案的方法。它主要用于解决约束满足问题，如迷宫求解、八皇后问题、数独填充等。在本例题中，...
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 393
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 243
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
java算法原理
jylee的博客
07-25 828
正确回答通过率：40.0%[ 详情 ] 推荐指数： ★★★★ 试题难度： 高难 试题类型： 编程题 ▸ 写笔记试题回答参考思路： >>
c语言（7.23）
fhgfyrsg的博客
07-23 697
【代码】c语言（7.23）
比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、付费专栏及课程。

余额充值