回溯算法(精炼版)

最新推荐文章于 2022-03-27 11:21:08 发布
最新推荐文章于 2022-03-27 11:21:08 发布
阅读量327 收藏
点赞数
分类专栏： 算法题 文章标签： 算法 c语言 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45014721/article/details/120276980
版权

文章目录

1.总说

管他是什么子集问题、排列问题、组合问题，关键是看树长什么样

Solution78

在这里插入图片描述

在这里插入图片描述

class Solution {
    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    public List<List<Integer>> subsets(int[] nums) {
        if (nums.length == 0){
            result.add(new ArrayList<>());
            return result;
        }
        subsetsHelper(nums, 0);
        return result;
    }

    private void subsetsHelper(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));//「遍历这个树的时候，把所有节点都记录下来，就是要求的子集集合」。
        if (startIndex >= nums.length){ 
            return;
        }
        for (int i = startIndex; i < nums.length; i++){
            path.add(nums[i]);
            subsetsHelper(nums, i + 1);
            path.removeLast();
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？

在这里插入图片描述

2.递归的参数是什么？
题目给的数组int[] nums 还有 startIndex

3.递归结束的条件是什么？
剩余集合为空时，也就是startIndex已经大于数组的长度了，就终止了，因为没有元素可取了。

if (startIndex >= nums.length){ 
    return;
}

4.如何去重？
无需去重（因为for循环是startlndex所以无需同一树枝内去重，因为集合{1,2,3}不含重复元素无需横向去重）

5.数组需要排序不？
不需要，因为不含重复元素

Solution90

在这里插入图片描述

在这里插入图片描述

class Solution {
   List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
   LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
   boolean[] used;
   
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if (nums.length == 0){
            result.add(path);
            return result;
        }
        Arrays.sort(nums);
        used = new boolean[nums.length];
        subsetsWithDupHelper(nums, 0);
        return result;
    }
    
    private void subsetsWithDupHelper(int[] nums, int startIndex){
        result.add(new ArrayList<>(path));
        if (startIndex >= nums.length){
            return;
        }
        for (int i = startIndex; i < nums.length; i++){
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){
                continue;
            }
            path.add(nums[i]);
            used[i] = true;
            subsetsWithDupHelper(nums, i + 1);
            path.removeLast();
            used[i] = false;
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？
第一个树枝已经取过1了，第二个树枝第三个树枝不能再取1，所以要用startlndex

2.递归的参数是什么？
题目给的数组int[] nums 还有 startIndex

3.递归结束的条件是什么？
剩余集合为空时，也就是startIndex已经大于数组的长度了，就终止了，因为没有元素可取了。

        if (startIndex >= nums.length){
            return;
        }

4.如何去重？
集合中有重复元素，必然要横向去重（也就是同一层树枝要进行去重）
used[i - 1] == true，说明同⼀树⽀nums[i - 1]使⽤过，无需去重；used[i - 1] == false，说明同⼀树层nums[i - 1]使⽤过，需要去重

if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]){  //used[i - 1]=false说明nums[i - 1]使⽤过，那就continue
      continue;
}

5.凡是数组中元素可能重复的，必然要排序

Arrays.sort(nums);

Solution46

在这里插入图片描述
在这里插入图片描述

class Solution {

    List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
    LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
    boolean[] used;
    
    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0){
            return result;
        }
        used = new boolean[nums.length];
        permuteHelper(nums);
        return result;
    }

    private void permuteHelper(int[] nums){
        if (path.size() == nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++){
            if (used[i]){
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            permuteHelper(nums);
            path.removeLast();
            used[i] = false;
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？
第一个树枝已经取过1了，第二个树枝和第三个树枝还能再取1，所以从0到n
凡是for从0取到n的都要考虑同一树枝内进行去重

            if (used[i]) {
                continue;
            }

2.递归的参数是什么？
题目给的数组int[] nums

3.递归结束的条件是什么？
当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

        if (path.size() == nums.length){
            result.add(new ArrayList<>(path));
            return;
        }

4.如何去重？

            if (used[i]){
                continue;
            }

在这里插入图片描述

5.数组需要排序不？
不需要，因为数据没有重复项

Solution47

在这里插入图片描述
在这里插入图片描述

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    boolean[] used;

    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        Arrays.sort(nums);
        backTrack(nums);
        return result;
    }

    private void backTrack(int[] nums) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }

            if (used[i]) {
                continue;
            }

            used[i] = true;
            path.add(nums[i]);
            backTrack(nums);
            path.remove(path.size() - 1);
            used[i] = false;//回溯
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？
第一个树枝已经取过1了，但是你看看第三个树枝还能再取1，所以从0到n。
凡是for从0取到n的都要考虑同一树枝内进行去重

            if (used[i]) {
                continue;
            }

2.递归的参数是什么？
题目给的数组int[] nums

3.递归结束的条件是什么？
当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }

4.如何去重？

			//used[i - 1]=false说明nums[i - 1]使⽤过，那就continue
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            
			//同一树枝不能重复使用
            if (used[i]) {
                continue;
            }

5.数组需要排序不？
需要，因为数据有重复项

Solution77

在这里插入图片描述
在这里插入图片描述

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return result;
    }

    /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
        //终止条件
        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？
第一个树枝已经取过1了，第二个树枝第三个树枝不能再取1，所以要用startlndex

2.递归的参数是什么？
题目给的n，k，还有startIndex

3.递归结束的条件是什么？
当收集元素的数组path的大小达到和nums数组一样大的时候，说明找到了一个全排列，也表示到达了叶子节点。

        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }

4.如何去重？
无需去重（因为for循环是startlndex所以无需同一树枝内去重，因为{1,2,3,4}不含重复元素无需横向去重）

5.数组需要排序不？
不需要，因为集合{1,2,3,4}中不含重复元素

Solution17

在这里插入图片描述
在这里插入图片描述

class Solution {

    List<String> list = new ArrayList<>();
    StringBuilder temp = new StringBuilder();//每次迭代获取一个字符串，所以会设计大量的字符串拼接，所以这里选择更为高效的 StringBuild

    public List<String> letterCombinations(String digits) {
        if (digits == null || digits.length() == 0) {
            return list;
        }
        //按键上2对应"abc",我们这里新增了两个无效的字符串""，那么numString[2]对应的也是"abc"
        String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        backTracking(digits, numString, 0);
        return list;

    }

    public void backTracking(String digits, String[] numString, int num) {
        //遍历全部一次记录一次得到的字符串
        if (num == digits.length()) {
            list.add(temp.toString());
            return;
        }
        //str 表示当前num对应的字符串
        String str = numString[digits.charAt(num) - '0'];//将num指向的数字转为int，取数字对应的字符集
        for (int i = 0; i < str.length(); i++) {
            temp.append(str.charAt(i));
            backTracking(digits, numString, num + 1);// 递归，注意num+1，一下层要处理下一个数字对应的字符集了
            temp.deleteCharAt(temp.length() - 1);
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？

在这里插入图片描述

2.递归的参数是什么？

3.递归结束的条件是什么？

        if (num == digits.length()) {
            list.add(temp.toString());
            return;
        }

4.如何去重？
无需去重

5.数组需要排序不？
不需要，因为没有重复元素

Solution39

在这里插入图片描述
在这里插入图片描述

class Solution {

    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path =new ArrayList<>();
    
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        
        Arrays.sort(candidates); // 先进行排序
        backtracking(candidates, target, 0, 0);
        return res;
    }

    public void backtracking(int[] candidates, int target, int sum, int idx) {
        // 找到了数字和为 target 的组合
        if (sum == target) {
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = idx; i < candidates.length; i++) {
            // 如果 sum + candidates[i] > target 就终止遍历
            if (sum + candidates[i] > target) break;
            path.add(candidates[i]);
            backtracking(candidates, target, sum + candidates[i], i);
            path.remove(path.size() - 1); // 回溯，移除路径 path 最后一个元素
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？
根节点是{2,5,3}，
第一个树枝的第一层可以取2、5、3，第二层还可以从2开始取（还可以取2、5、3）
但是第二个树枝不论第一层还是第二层只能从5开始取
第三个树枝不论第一层还是第二层只能从3开始取
典型的从startIndex

2.递归的参数是什么？
题目给的int[] candidates,和int target，还有我们需要的 int sum和 int idx（idx其实就是startIndex）

3.递归结束的条件是什么？

在这里插入图片描述

4.如何去重？
无需去重（因为for循环是startlndex所以无需同一树枝内去重，因为{2，5，3}不含重复元素无需横向去重）

5.数组需要排序不？
不需要，因为数组不含重复元素（但是考虑到剪枝优化就需要排序）

6.剪枝优化

在这里插入图片描述
在这里插入图片描述

Solution40

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

class Solution {
    List<List<Integer>> lists = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used;
    int sum = 0;

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        used = new boolean[candidates.length];
        backTracking(candidates, target, 0);
        return lists;
    }

    public void backTracking(int[] arr, int target, int startIndex) {
        if (sum == target) {
            lists.add(new ArrayList(path));
            return;
        }
        for (int i = startIndex; i < arr.length && arr[i] + sum <= target; i++) {

            if (i > 0 && arr[i] == arr[i - 1] && !used[i - 1]) {
                continue;
            }
            used[i] = true;
            sum += arr[i];
            path.add(arr[i]);
            backTracking(arr, target, i + 1);
            int temp = path.removeLast();
            used[i] = false;
            sum -= temp;
        }
    }
}

主要关注一下几个点：

1.for循环是从0到n呢还是从startIndex到n呢？
第一个树枝已经取过第一个元素了，第二个树枝和第三个树枝不能再取，所以从startIndex到n

2.递归的参数是什么？
题目给的int[] arr和 int target，我们的startIndex

3.递归结束的条件是什么？

        if (sum == target) {
            lists.add(new ArrayList(path));
            return;
        }

4.如何去重？

			//used[i - 1]=false说明nums[i - 1]使⽤过，那就continue
            if (i > 0 && arr[i] == arr[i - 1] && !used[i - 1]) {
                continue;
            }

5.数组需要排序不？
需要，因为数据有重复项

总结：

①看root根节点是否有重复元素，如果有那就需要横向去重，而且需要排序；
②for循环是从0到n呢还是从startIndex到n呢，凡是for从0取到n的都要考虑同一树枝内进行去重
③考虑递归的参数
④考虑递归的结束条件

BlackTurn
关注
专栏目录
【kafka源码】kafka分区副本的分配规则
石臻臻的杂货铺(szzdzhp001)
08-29 1988
我们有分析过【kafka源码】TopicCommand之创建Topic源码解析; 因为篇幅太长所以 关于分区分配的问题单独开一篇文章写; 源码分析 创建Topic的源码入口 AdminManager.createTopics() 以下只列出了分区分配相关代码其他省略 def createTopics(timeout: Int, validateOnly: Boolean, toCreate: Map[String, Creatab
高级算法课件压缩版
04-16
《高级算法》是一门深入...《高级算法》的压缩版课件将这些复杂的概念和技巧进行了精炼，使得学习者可以在有限的时间内掌握关键知识点。无论你是准备面试、提升技术能力，还是进行科研工作，这门课程都将是宝贵的资源。
c语言string函数的用法_C语言奇淫技巧，字符串的三种表示方法，不会用不是合格的程序员...
weixin_39926943的博客
11-21 1072
1.在C语言中，是将字符串作为字符数组来处理的，字符串是逐个存放到数组元素中的例如用一个一维的字符数组存放字符串"I am a boy."，如下代码：char c[12] = {'I','a','m','a','b','o','y','.'};这个字符串的实际长度是11，数组长度是12，实际工作中，人们关心的往往是字符串的有效长度而不是字符串的数组长度，例如要打印字符串，这是就要知道字符串的实际长...
SwiftGG 字符串和字符
weixin_42321619的博客
11-12 275
字符串字面量 字符串字面量是有一对双引号包裹着的具有固定顺序的字符集 可以用于为常量和变量提供初始值 let someString = "Some string literal value" 多行字符串字面量 多行字符串字面量由一对三个双引号包裹着的具有固定顺序的文本字符集 let quotation = """ The White Rabbit put on his spectacles. "Where shall I begin, please your Majesty?" he as
kafka源码解析-分区副本的分配
worldchinalee的博客
08-31 476
主要介绍是未指定机架信息的分配策略，kafka版本是2.0.0，具体实现为kafka.admin.AdminUtils.scala文件中的 assignReplicasToBrokersRackUnaware()方法，该方法的内容如下： private def assignReplicasToBrokersRackUnaware(nPartitions: Int,//分区数 ...
杭电算法PPT详解以及各类算法精炼
07-19
【杭电算法PPT详解及各类算法精炼】是一份针对计算机科学与技术领域的学习资料，主要涵盖了中级算法的学习和实践。这份资源旨在帮助学习者深入理解和掌握算法，提升编程能力，尤其对于C++和C语言的使用者具有很高的...
算法练习，常见算法，面试常用
最新发布
03-12
"labuladong的算法小抄完整版.pdf"和"（算法小抄）- top101.pdf"这两份文档很可能是关于算法的精炼总结，由知名博主labuladong提供。labuladong以其通俗易懂的讲解方式深受读者喜爱，他的算法小抄通常会涵盖排序、...
算法导论 黑皮书 期末复习笔记
01-10
5. **回溯与分支限界**：用于解决组合优化问题，如八皇后问题、N皇后问题、数独求解等。这两种方法可以有效地在搜索空间中找到解决方案。 6. **数据结构**：如数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑...
基本数据类型
怪咖
02-04 259
基本数据类型 JavaScript的基本数据类型有如下 5 个。 数值类型：包含整数或浮点数。 布尔类型： 只有 true 或 false 两个值。 字符串类型： 字符串变量必须用引号括起来，引号可以是单引号，也可以是双引号。 undefined 类型： 专门用来确定一个已经创建但是没有初值的变量。 null 类型： 用于表明某个变量的值为空。 数值类型 JavaScrip...
startindex 不能大于字符串长度_Stata中字符串函数的简单介绍
weixin_39948824的博客
12-04 2356
本文作者：鲁津旗 宋莹然 谢梦瑶 高晨 导读在之前的推文《Stata中日期函数的简单介绍》中，我们对Stata的日期函数进行了简单介绍。在Stata中，字符串函数的使用频率很高，今天我们来简单介绍一下Stata中的字符串函数。本文主要分为四个部分：字符串的提取与查找、字符串的替换与删减、字符串的连接与转换、字符串的长度获取。用法介绍函数举例字符串...
Java-回溯学习中2
qq_54962034的博客
03-27 559
本题来自leetcode，初步理解回溯之后，这道题，给了我非常大的对于回溯的感觉，这道题不难，但是我也是参考了别人的思路，才算是初步看到了回溯的力量。 Leet_39 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。 candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组
在二元树中找出和为某一值的所有路径
Talk Is Cheap
11-25 655
题目：输入一个整数和一棵二元树。  从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。  打印出和与输入整数相等的所有路径。  例如输入整数22 和如下二元树  10  / \  5 12  /\  4 7  则打印出两条路径：10, 12 和10, 5, 7。  二元树节点的数据结构定义为：  struct BinaryTreeNode // a node
StartIndex 不能小于 0。
热门推荐
慢谈人生
05-28 1万+
string name="1598"; name=name.Substring(name.Length - 6)； 这种情况就会报错StartIndex 不能小于 0，因为name的长度是小于6的，所以得到的是小于0的数，解决方案： name=name.Substring(name.Length - 4)； ...
startindex 不能大于字符串长度_[Redis]-Redis-数据结构-字符串编码选择流程
weixin_39953100的博客
12-01 603
Redis 内部针对 string提供了三种编码格式，分别是：int，embstr，raw一、字符串编码选择流程int编码：8个字节的长整形，当数字长度小于20同时能够被强制转换成long long 类型使用 int编码，长度大于20，或者超出 long long 类型范围的时候会转换使用embstrembstr编码:小于等于44字节的字符串raw编码：大于44个字节的字符串二、验证编码选择流程2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BlackTurn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值