专题练习——回溯

最新推荐文章于 2022-08-06 20:26:22 发布
最新推荐文章于 2022-08-06 20:26:22 发布
阅读量220 收藏
点赞数
分类专栏： LeetCode刷题 文章标签： leetcode java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39924622/article/details/107895787
版权

文章目录

回溯框架

回溯法是所有搜索算法中最为基本的一种算法，又称为试探法，基本做法是深度优先搜索。
回溯算法框架如下所示，其核心就是 for 循环里面的递归，在递归调⽤之前做出选择，在递归调⽤之后撤销该选择。

result = []
function backtrack(路径, 选择列表) {
	if (满足条件) {  // 结束条件
		result.add(路径);
		return;
	}
	for (选择 in 选择列表) {
		做出选择
		backtrack(路径，选择列表)
		撤销选择
	}
}

一、LeetCode77. 组合

题目描述

链接
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。

示例:

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

方法一、回溯

这里用了一个begin防止搜索重复的值

class Solution {
    public List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        if (n <= 0 || k <= 0 || n < k)
            return list;
        backTrack(n, k, 1, new Stack<>());
        return list;
    }
    private void backTrack(int n, int k, int begin, Stack<Integer> track) {
        //结束条件
        if (track.size() == k) {
            list.add(new ArrayList<>(track));
            return;
        }
        for(int i = begin; i <= n; i++){ 
            track.push(i); //做出选择
            backTrack(n, k, i + 1, track);
            track.pop();  //撤销选择
        }
    }
}

在这里插入图片描述

方法二、回溯+剪枝

设想一下从[1,2,3,4,5]中取出3个数，for循环到3的时候，还刚好剩下3个数，但循环到4时，以及不够3个数了，这些分支是没必要执行的。

class Solution {
    public List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> combine(int n, int k) {
        if (n <= 0 || k <= 0 || n < k)
            return list;
        backTrack(n, k, 1, new Stack<>());
        return list;
    }
    private void backTrack(int n, int k, int begin, Stack<Integer> track) {
        //结束条件
        if (track.size() == k) {
            list.add(new ArrayList<>(track));
            return;
        }
        /*
        //剪枝：剩下的个数不足时，停止搜索
        // i 的极限值满足： n - i + 1 = (k - track.size())。
        // n - i + 1 是 [i,n] 的长度。
        // k - track.size() 是剩下还要寻找的数的个数。
        */
        for(int i = begin; i <= n - (k - track.size()) + 1; i++){ 
            track.push(i); //做出选择
            backTrack(n, k, i + 1, track);
            track.pop();  //撤销选择
        }
    }
}

在这里插入图片描述

二、LeetCode78. 子集

题目描述

链接
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

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

方法一、回溯

class Solution {
    public List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> subsets(int[] nums) {
        backTrack(nums, 0, new Stack<Integer>());     
        return list;
    }
    private void backTrack(int[] nums, int begin, Stack<Integer> track) {
        list.add(new ArrayList<>(track));
        for (int i = begin; i < nums.length; i++) {
            track.push(nums[i]);
            backTrack(nums, i + 1, track);
            track.pop();
        }
    }
}

方法二、枚举法

逐个枚举，空集的幂集只有空集，每增加一个元素，让之前幂集中的每个集合，追加这个元素，就是新增的子集。
比如说：1,2,3的子集

  • 首先，添加一个空List到结果List（res）中
  • for循环遍历到1，[]加上1，添加到res中，此时res：[ [] , [1] ]
  • for循环遍历到2，res中每个list都加上2，此时res：[ [] , [1] , [2] , [1,2] ]
  • for循环遍历到3，res中每个list都加上3，此时res：[ [] , [1] , [2] , [1,2] , [3] , [1,3] , [2,3] , [1,2,3]]
class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList();
        res.add(new ArrayList<Integer>());//添加空白元素    
        for (Integer num : nums) {
            int size = res.size();
            for (int i = 0; i < size; i++) {
                List<Integer> newSub = new ArrayList<>(res.get(i)); 
                newSub.add(num);
                res.add(newSub);               
            } 
        }
        return res;
    }
}

三、LeetCode46. 全排列

题目描述

链接
给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

方法一、回溯法

class Solution {
    public List<List<Integer>> list = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        backTrack(nums, new LinkedList<>());
        return list;
    }
    private void backTrack(int[] nums, LinkedList<Integer> track) {
        //结束条件
        if (track.size() == nums.length) {
            list.add(new LinkedList(track));
            return;
        }
        //选择列表
        for (int i = 0; i < nums.length; i++) {
            //排除不合理的选择
            if (track.contains(nums[i]))
                continue;
            //做出选择
            track.add(nums[i]);
            //进入下一层决策树
            backTrack(nums, track);
            //撤销选择
            track.removeLast();
        }
    }
}

方法二、递归，元素交换实现

class Solution {
    public List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        backTrack(nums, 0);
        return list;
    }
    private void backTrack(int[] nums, int start) {
        //结束条件
        if (start == nums.length) {
            List<Integer> curr = Arrays.stream(nums).boxed().collect(Collectors.toList());//将数组转换为List
            list.add(curr);
        }
        //选择列表
        for (int i = start; i < nums.length; i++) {
            //交换
            int temp = nums[i];
            nums[i] = nums[start];
            nums[start] = temp;
           
            //进入下一层决策树
            backTrack(nums, start + 1);
            //交换回来（撤销之前的交换）
            temp = nums[i];
            nums[i] = nums[start];
            nums[start] = temp;
        }
    }
}

四、LeetCode47. 全排列 II

题目描述

添加链接描述链接
给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]
输出:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

递归，元素交换实现

在上一题的方法二的基础上，添加了一个HashSet去重。

class Solution {
    public List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        backTrack(nums, 0);
        return list;
    }
    private void backTrack(int[] nums, int start) {
        //结束条件
        if (start == nums.length) {
            List<Integer> curr = Arrays.stream(nums).boxed().collect(Collectors.toList());//将数组转换为List
            list.add(curr);
        }
        //选择列表
        HashSet<Integer> set = new HashSet<>();
        for (int i = start; i < nums.length; i++) {
            //去重
            if(set.contains(nums[i]))
                continue;
            set.add(nums[i]);
            
            //交换
            int temp = nums[i];
            nums[i] = nums[start];
            nums[start] = temp;
           
            //进入下一层决策树
            backTrack(nums, start + 1);
            //交换回来（撤销之前的交换）
            temp = nums[i];
            nums[i] = nums[start];
            nums[start] = temp;
        }
    }
}

五、LeetCode17. 电话号码的字母组合

题目描述

链接
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
在这里插入图片描述
示例:

输入："23"
输出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].

方法一、回溯法

class Solution {
    private Map<Character, String> phone = 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");
  }};
    private List<String> res = new ArrayList<String>();
    
    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0){
            return res;
        }
        backTrack(new StringBuilder(), 0, digits);
        return res;
    }

    private void backTrack(StringBuilder combination, int index, String digits) {
        //结束条件
        if (index == digits.length()) {
            res.add(combination.toString());
            return;
        }
        //选择列表
        String currNumChar = phone.get(digits.charAt(index));//index位置的数字所代表的字符序列
        for (int  i = 0; i < currNumChar.length(); i++) {
            //做出选择
            combination.append(currNumChar.charAt(i));
            //进入下一层决策树
            backTrack(combination, index + 1, digits);
            //撤销选择
            combination.deleteCharAt(combination.length() - 1);
        }
    }
}

方法二、用队列解

利用队列先进先出的特点，每次从队列中取出一个元素与新数字所代表的的每一个字符进行拼接并入队。
比如说输入为“23”：

  • 初始队列为空，把“”依次和数字2所代表的“abc”拼接，得到队列[a,b,c]
  • 对于队列[a,b,c],依次和数字3所代表的的“def”拼接：
    – 取出a，与def拼接，得到队列[b,c,ad,ae,af]
    – 取出b，与def拼接，得到队列[c,ad,ae,af,bd,be,bf]
    – 取出c，与def拼接，得到队列[ad,ae,af,bd,be,bf,cd,ce,cf].
class Solution {
    private Map<Character, String> phone = 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");
  }};
    
    public List<String> letterCombinations(String digits) {
        List<String> res = new ArrayList<String>();
        if (digits == null || digits.length() == 0){
            return res;
        }
        res.add("");
        for (int i = 0; i < digits.length(); i++) {
            String currNumChar = phone.get(digits.charAt(i));//获取当前数字代表的字符序列
            int size = res.size();
            for (int j = 0; j < size; j++) {//取出队列中每一个元素，与当前数字代表的每一个字符拼接
                String letter = res.remove(0);//取出第一个字符串
                //并分别和当前数字所代表的的字符串中的每一个字符进行拼接
                for (int k = 0 ; k < currNumChar.length(); k++) {
                    res.add(letter + currNumChar.charAt(k));
                }
            }
        }     
        return res;
    }   
}

六、LeetCode51. N皇后

题目描述

链接
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
在这里插入图片描述

输出:

 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]
解释: 4 皇后问题存在两个不同的解法。

提示：

皇后，是国际象棋中的棋子，意味着国王的妻子。皇后只做一件事，那就是“吃子”。当她遇见可以吃的棋子时，就迅速冲上去吃掉棋子。当然，她横、竖、斜都可走一到七步，可进可退。（引用自 百度百科 - 皇后 ）

回溯法

LeetCode提交时间为8ms

class Solution {
    private List<List<String>> res = new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        if (n < 1) 
            return res;
        List<String> board = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++)
            sb.append('.');
        for (int i = 0; i < n; i++)
            board.add(sb.toString());
        backTrack(n, 0, board);
        return res;
    }
    private void backTrack(int n, int row, List<String> board) {
        //结束条件
        if (row >= n) {
            res.add(new ArrayList<>(board));
            return;
        }
        //选择列表:当前层的每一列
        for (int col = 0; col < n; col++) {
            //排除不合法的选择
            if (!isValid(board, row, col, n)) {
                continue;
            }
            //做选择
            StringBuilder sb = new StringBuilder(board.get(row));
            sb.setCharAt(col, 'Q');
            board.set(row, sb.toString());

            //进入下一层决策树
            backTrack(n, row + 1, board);

            //撤销选择
            sb = new StringBuilder(board.get(row));
            sb.setCharAt(col, '.');
            board.set(row, sb.toString());

        }
    }
    private boolean isValid(List<String> board, int row, int col, int n) {
        //检查同一列有没有冲突
        for (int i = 0; i < row; i++) {
            if (board.get(i).charAt(col) == 'Q')
                return false;
        }
        //检查\列有没有冲突
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board.get(i).charAt(j) == 'Q')
                return false;

        }
        //检查/列有没有冲突
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (board.get(i).charAt(j) == 'Q')
                return false;
        }
        return true;
    }
}

进行代码优化,仅适用2ms：

public class Solution {
    private boolean[] visited;
    private boolean[] dia1;
    private boolean[] dia2;
    private List<List<String>> res = new ArrayList<>(); 
    
    public List<List<String>> solveNQueens(int n) {
        visited = new boolean[n];
        //2*n-1个斜对角线
        dia1 = new boolean[2*n-1];
        dia2 = new boolean[2*n-1];
        backTrack(new ArrayList<String>(), 0, n);
        return res;
    }
    private void backTrack(List<String> list, int row, int n){
        //结束条件
        if (row == n){
            res.add(new ArrayList<String>(list));
            return;
        }
        for (int i = 0; i < n; i++){
            //排除不合法的选择
            if (visited[i] || dia1[row+i] || dia2[row-i+n-1]) 
                continue;
            //做选择
            char[] charArray = new char[n];
            Arrays.fill(charArray, '.');
            charArray[i] = 'Q';
            String rowString = new String(charArray);
            
            list.add(rowString);
            visited[i] = true;
            dia1[row+i] = true;// "/"，row+col用来标识一条“/”
            dia2[row-i+n-1] = true;// "\",row-col用来标识一条“\”,+n-1是为了防止数组越界

            //进入下一层决策树
            backTrack(list, row + 1, n);
            //撤销选择
            list.remove(list.size() - 1);
            charArray[i] = '.';
            visited[i] = false;
            dia1[row+i] = false;
            dia2[row-i+n-1] = false;
        }
    }
}

七、LeetCode52. N皇后 II

题目描述

链接
给定一个整数 n，返回 n 皇后不同的解决方案的数量。

回溯法（稍微修改上一题代码）

class Solution {
    private int count = 0;
    public int totalNQueens(int n) {
        if (n < 1) 
            return count;
        List<String> board = new ArrayList<>();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++)
            sb.append('.');
        for (int i = 0; i < n; i++)
            board.add(sb.toString());
        backTrack(n, 0, board);
        return count;

    }
    private void backTrack(int n, int row, List<String> board) {
        //结束条件
        if (row >= n) {
            count++;
            return;
        }
        //选择列表:当前层的每一列
        for (int col = 0; col < n; col++) {
            //排除不合法的选择
            if (!isValid(board, row, col, n)) {
                continue;
            }
            //做选择
            StringBuilder sb = new StringBuilder(board.get(row));
            sb.setCharAt(col, 'Q');
            board.set(row, sb.toString());

            //进入下一层决策树
            backTrack(n, row + 1, board);

            //撤销选择
            sb = new StringBuilder(board.get(row));
            sb.setCharAt(col, '.');
            board.set(row, sb.toString());

        }
    }
    private boolean isValid(List<String> board, int row, int col, int n) {
        //检查同一列有没有冲突
        for (int i = 0; i < row; i++) {
            if (board.get(i).charAt(col) == 'Q')
                return false;
        }
        //检查\列有没有冲突
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (board.get(i).charAt(j) == 'Q')
                return false;

        }
        //检查/列有没有冲突
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (board.get(i).charAt(j) == 'Q')
                return false;
        }
        return true;
    }
}
yjx@qq.com
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
回溯法练习题
温小二的江湖
06-05 523
目录 前言 一、菱形图案 二、牛妹的蛋糕 三、尼科彻斯定理 四、ABC + DEF = GHI 五、油田问题 六、马的遍历问题 总结 前言 回溯法：又称试探法 从问题的某一种初始状态出发，搜索从这种状态出发所能达到的所有状态，当一条路走到“尽头”的时候（不能再前进)，再后退一步或若干步，从另一种可能的状态出发，继续搜索，直到所有的“路径”(状态）都试探过为止。 一、菱形图案 问题描述： KiKi学习了循环，BoBo老师给他出了...
回溯算法专题练习
_zhy_cq
06-26 972
回溯算法 vector<vector<T>> res; vector<T> path; void backtrack(未探索区域, res, path): if 未探索区域满足结束条件: res.push_back(path) return; for 选择 未探索区域当前可能的选择: if 当前选择符合要求: path.push_back(当前选择) back
回溯练习1
one_zero_one的博客
06-27 109
1219. 黄金矿工：https://leetcode-cn.com/problems/path-with-maximum-gold 你要开发一座金矿，地质勘测学家已经探明了这座金矿中的资源分布，并用大小为 m * n 的网格 grid 进行了标注。每个单元格中的整数就表示这一单元格中的黄金数量；如果该单元格是空的，那么就是 0。 为了使收益最大化，矿工需要按以下规则来开采黄金： 每当矿工进入一个单元，就会收集该单元格中的所有黄金。 矿工每次可以从当前位置向上下左右四个方向走。 每个单元格只能被开采（进
回溯：思想，思考
TOKHE的专栏
07-06 1007
回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索。 回溯法：为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死那些实际上不可能产生所需解的活结点
回溯算法练习
diaolove的博客
11-28 202
给定一个没有重复数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出:[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]] package demo; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class Solution { public static void main(Stri...
算法分析论文——回溯算法的应用.zip
10-19
回溯算法是一种强大的问题求解方法，尤其在解决复杂组合优化问题时表现出高效性。它是一种试探性的解决问题的方法，通过逐步构建可能的解决方案，并在过程中不断检查这些解决方案的有效性。如果发现当前路径无法导出...
迷宫——回溯，递归
03-21
标题中的“迷宫——回溯，递归”指的是在编程问题解决中的一种经典算法，用于在二维矩阵或图中寻找路径。回溯法是一种试探性的解决问题的方法，它尝试通过不断扩展解决方案来找到答案，如果发现当前路径无法到达目标...
最优装载问题——回溯法
10-14
最优装载问题——回溯法 最优装载问题——回溯法 最优装载问题——回溯法
五大常见算法策略之——回溯策略，算法数据结构
04-07
"五大常见算法策略之回溯策略，算法数据结构" 回溯策略是一种常见的算法策略，主要用于解决复杂的组合优化问题。其核心思想是将解空间看作是一棵树的结构，从树根到其中一个叶节点的路径就是一个可能的解，根据约束...
深大算法实验三——回溯法解决地图填色问题代码
03-02
背景知识： 为地图或其他由不同区域组成的图形着色时，相邻国家/地区不能使用相同的颜色。 我们可能还想使用尽可能少的不同颜色进行填涂。一些简单的“地图”（例如棋盘）仅需要两种颜色（黑白），但是大多数复杂的...
图的深搜+回溯练习题：POJ2197
04-16
NULL 博文链接：https://128kj.iteye.com/blog/1772172
17. 电话号码的字母组合（两星推荐）
12-20
Python解答（由于python已经不再更新2.x, 以后提到python默认都是python3） 思路1：Python有一个默认的包 `itertools.product()` 可以解决这个问题  class Solution: def letterCombinations(self, digits: str) -> List[str]: if(digits==""): return [] import itertools num2alpa = dict({'2': ['a','b','c'],
回溯法练习笔记
b9x__的博客
11-23 746
1.回溯法 回溯法按深度优先策略搜索问题的解空间树，首先从根节点出发依次搜索解空间树进行遍历，搜索遍历过程中记录解，已至到最后求出最优解，都每一节点都利用剪枝函数判断该节点是否能继续往下搜索，也就是判断是否还会有解；如果可行，就继续向下搜索；如果不行，则跳过该节点所有可能继续向下的搜索。(行就接着往下搜，不行下面的就都不搜了)         剪枝函数是为了避免无效的搜索。剪枝函数一般：剪
回溯类题目专题训练 -- LeetCode上12道与回溯相关的题
今天你学习了吗？
02-21 321
这个专题中的题目是我跟随代码随想录的刷题计划，在LeetCode上做的与回溯相关的题目，用于加深对回溯的理解！ 下面的内容将会有每一道题目的题意、在代码随想录中对应的参考文章、我的思路以及我所写的Java代码，希望对你有帮助！ 目录1 - LeetCode 77 组合 -- 回溯法2 - LeetCode 216 组合总和 III -- 回溯法3 - LeetCode 17 电话号码的字母组合 -- 回溯法4 - LeetCode 39 组合总和 -- 回溯法5 - LeetCode 131 分割回文串 -
通用解题法——回溯算法（理解+练习）
了迹奇有没
06-20 735
积累算法经验，积累解题方法——回溯算法，你必须要掌握的解题方法！ 什么是回溯算法呢？ 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有“通用解题方法”的美称。 最简单的.
dfs+回溯习题整理（1）
qq_43732110的博客
05-05 247
1.LeetCode17. 电话号码的字母组合 搜索顺序： 按照给出的数字依次进行搜索，对于每一个数字枚举它选用每一个字母的方案。 回溯： 当下一个字符串已经枚举完成时，需要更新当前字符串，此时需要进行回溯。然后进行枚举，到当前字符串的下一个元素。第一次写时，循环的意义没有考虑清楚，这个做法的循环是枚举当前字符串的每个字符，而不是下一个字符串的每个字符。 class Solution { publ...
回溯算法与相关习题详解
码农ZZK的博客
04-20 328
回溯算法简介 回溯算法是一种遍历所有情况找到最优解的算法。 通过回溯，重新做一次选择，从而得到最优解 我们可以认为这是一种有规律的枚举法，再加上递归的使用，使得整个过程更加有序 回溯算法初接触 回溯算法通常可以解决求最优解，求全排列，匹配括号，上色等等 通常回溯算法有一种较为通用的模板 def 主函数： res = [] def backtrace(xxxxx):# 回溯方法本身 i...
回溯及其简单题目示例
weixin_45696320的博客
08-06 191
一路一直走、走到头（走不下去没有其他分支）返回到沿途有分支的地方，继续一路走到黑直到走完所有路。有没有感觉到其实现在基本掌握这一类题型了，加油。还是不强行语言表述了，看图就懂了。...
递归、回溯练习题答案
Still waters run deep
03-07 499
这是上一篇博文的答案。
0-1背包问题——回溯法求解
最新发布
06-10
0-1背包问题可以用回溯法求解，基本思路如下： 1.定义一个全局最优解变量max_value，从0开始； 2.定义一个当前解变量current_value，从0开始； 3.定义一个当前重量变量current_weight，从0开始； 4.定义一个当前...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值