力扣刷题Day21

最新推荐文章于 2024-10-14 18:52:56 发布
最新推荐文章于 2024-10-14 18:52:56 发布
阅读量165 收藏
点赞数
分类专栏： leetcode刷题 文章标签： leetcode 算法 java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/witch2026/article/details/129791006
版权
文章详细介绍了回溯算法的概念，它作为递归的副产品，通常用于解决组合、切割、子集和排列等搜索问题。回溯法通过构建树形结构来解决问题，具有穷举性质但可通过剪枝优化提高效率。文中以组合问题为例，展示了回溯法的模板和剪枝优化策略，并提供了具体的代码实现。
摘要由CSDN通过智能技术生成

回溯算法理论基础

回溯算法 - 

一种搜索方式。

回溯是递归的副产品，只要有递归就会有回溯。 

递归函数的下面就是回溯的过程。

一般说回溯函数就是递归函数。

回溯搜索法的效率：纯暴力，穷举「并不高效」。 --- 因为有些问题很复杂，只能穷举，最多剪枝。

一般可以解决如下几种问题：

  • 组合问题：N个数里面按一定规则找出k个数的集合

  • 切割问题：一个字符串按一定规则有几种切割方式

  • 子集问题：一个N个数的集合里有多少符合条件的子集

  • 排列问题：N个数按一定规则全排列，有几种排列方式

  • 棋盘问题：N皇后，解数独等等

如何理解？抽象为树形结构

因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。

回溯法的模板：

回溯三部曲

  • 回溯函数模板返回值以及参数（回溯算法中函数返回值一般为void。回溯算法需要的参数可不像二叉树递归的时候那么容易一次性确定下来，所以一般是先写逻辑，然后需要什么参数，就填什么参数。）

void backtracking(参数)

  • 回溯函数终止条件（什么时候达到了终止条件，树中就可以看出，一般来说搜到叶子节点了，也就找到了满足条件的一条答案，把这个答案存放起来- 收集结果，并结束本层递归。）

if (终止条件) {
    存放结果;
    return;
}

  • 回溯搜索的遍历过程

在上面我们提到了，回溯法一般是在集合中递归搜索，集合的大小构成了树的宽度，递归的深度构成的树的深度。

for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
    处理节点;
    backtracking(路径，选择列表); // 递归
    回溯，撤销处理结果
}

参考资料：https://programmercarl.com/回溯算法理论基础.html#题目分类大纲如下

77. 组合

力扣链接：https://leetcode.cn/problems/combinations/

这道题用暴力的方式：如果是k=50的情况，那么就需要50个for循环嵌套，那么是很难实现的。

因此只能考虑回溯。

组合问题抽象为如下树形结构：

n相当于树的宽度，k相当于树的深度。

可以看出这棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不再重复取。

第一次取1，集合变为2，3，4 ，因为k为2，我们只需要再取一个数就可以了，分别取2，3，4，得到集合[1,2] [1,3] [1,4]，以此类推。

每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。

图中可以发现n相当于树的宽度，k相当于树的深度。

图中每次搜索到了叶子节点，我们就找到了一个结果。

相当于只需要把达到叶子节点的结果收集起来，就可以求得 n个数中k个数的组合集合。

依照回溯三部曲「for循环中嵌套一个递归思路」：

  • 回溯返回值以及参数：

需要两个全局变量 - 一个存放所有的结果集；一个存放单个集合的结果集「可以将这两个变量放入回溯方法中，但是影响代码可读性 - 适合作为全局变量」

List<List<Integer>> result；
List<Integer> list；

返回值：void 

参数：int k 「组合的大小」，int n「右边的位置」，int left「左边的位置 - 确定从那个地方开始取数（搜索的起始位置）」

  • 回溯的终止条件：如果list.size = k，那就将这个结果储存进集合，然后返回。

  • 回溯的单层逻辑：使用for循环（int left; left <=n; left++） - 将i放入list，然后递归backtraking（k, n, i+1）；回溯：删除list中最后一个元素 - list.remove(list.size()-1)。

具体代码实现：

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

    public void backtraking(int n, int k, int left){
        //终止条件
        if(list.size() == k){
            result.add(new ArrayList<>(list));//需要注意 - 不能添加list，这是一个引用地址；需要新建一个ArrayList存放list中的数据；list是会改变的
            return;
        }
        
        //单层处理逻辑
        for(int i=left; i<=n; i++){
            list.add(i);
            //递归
            backtraking(n, k, i+1);
            //回溯
            list.remove(list.size()-1);
        }
    }
    
}

注意在存放结果集的时候不要存放引用地址。

参考资料：https://programmercarl.com/0077.组合.html#回溯法三部曲

剪枝优化

这里也有一个可以考虑的剪枝优化：

可以看出来，在[1234]集合中，当取4的时候，这个集合就是空的。

因此是可以剪枝的 - 对于搜索效率的提升是很大的。

那么怎么确定这个剪枝的范围呢？

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

优化过程如下：

  1. 已经选择的元素个数：list.size();

  1. 所需需要的元素个数为: k - list.size();

  1. 列表中剩余元素（n-i） >= 所需需要的元素个数（k - path.size()）

  1. 在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历

所以优化之后的for循环是：

for(int i = startIndex; i <= n -(k - path.size())+1; i++)

具体代码：

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

    public void backtraking(int n, int k, int left){
        //终止条件
        if(list.size() == k){
            result.add(new ArrayList<>(list));//需要注意 - 不能添加list，这是一个引用地址；需要新建一个ArrayList存放list中的数据；list是会改变的
            return;
        }
        
        //单层处理逻辑
        for(int i=left; i<=n-(k-list.size())+1; i++){//剪枝优化
            list.add(i);
            //递归
            backtraking(n, k, i+1);
            //回溯
            list.remove(list.size()-1);
        }
    }
    
}

216.组合总和III

力扣链接：https://leetcode.cn/problems/combination-sum-iii/

不能使用暴力的原因：不能控制要嵌套几层for循环 - 考虑回溯

这里的条件是：集合是固定的 - 从1到9；求和为n，size为k

本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

回溯三部曲：

  • 确定回溯返回值以及输入参数：

两个全局变量：

List<List<Integer>> result；
List<Integer> list；

输入：backtraking(int n「求和值」, int k「集合要求大小」, int left「取值起始位置」, int sum「此时list求和大小」);

输出：void

  • 回溯终止条件：当list.size() == k时：如果sum == n，那么将list放入result，然后return；否则直接return；

  • 回溯单层逻辑：for(int i= left; i<=9; i++){list.add(i); sum+= i}; 递归 - backtraking(n, k, i+1; sum); 回溯：sum-= list.(list.size()-1); list.remove(list.size()-1);

这里也可以进行剪枝优化：

  1. 对遍历的树宽度进行优化：

深度为k，因此还需要的数是：k - list.size()； 

这里的元素总共为9，起始点为i --- 因此 9-i >= k - list.size(), 才需要往后遍历： i<=9-(k-list.size())+1

  1. 如果sum已经比n大了，那么就不用再往下进行回溯搜索了，因为后面都比n要大。 -- 注意在return之前需要进行回溯操作｜或者放在终止条件中，就不用再回溯

代码具体实现1：

class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        list = new ArrayList<>();
        backtraking(k, n, 0, 1);

        return result;
    }

    List<List<Integer>> result;
    List<Integer> list;
    public void backtraking(int k, int n, int sum, int left){
        //终止条件
        if(list.size() == k){
            if(sum == n){
                result.add(new ArrayList<>(list));
            }

            return;
        }

        for(int i=left; i<= 9-(k-list.size())+1; i++){//单层循环+剪枝优化1
            list.add(i);
            sum += i;

            //剪枝优化2
            if(sum > n){
                //先回溯
                sum -= list.get(list.size()-1);
                list.remove(list.size()-1);
                //再return

                return;
            }

            //递归
            backtraking(k, n, sum, i+1);
            //回溯
            sum -= list.get(list.size()-1);
            list.remove(list.size()-1);
        }
    }

}

代码具体实现2：

class Solution {
    public List<List<Integer>> combinationSum3(int k, int n) {
        result = new ArrayList<>();
        list = new ArrayList<>();
        backtraking(k, n, 0, 1);

        return result;
    }

    List<List<Integer>> result;
    List<Integer> list;
    public void backtraking(int k, int n, int sum, int left){
        //终止条件
        if(sum > n){ //剪枝优化2
                return;
            }

        if(list.size() == k){
            if(sum == n){
                result.add(new ArrayList<>(list));
            }

            return;
        }

        for(int i=left; i<= 9-(k-list.size())+1; i++){//单层循环+剪枝优化1
            list.add(i);
            sum += i;
            
            //递归
            backtraking(k, n, sum, i+1);
            //回溯
            sum -= list.get(list.size()-1);
            list.remove(list.size()-1);
        }
    }

}

参考资料：https://programmercarl.com/0216.组合总和III.html

17.电话号码的字母组合

题目链接：https://leetcode.cn/problems/letter-combinations-of-a-phone-number/

首先这道题是输入电话号码 - 然后给出可能的字母组合。

因此需要对数字 - 字母做一个映射。

可以考虑的方式是 - 采用map；或者用数组。

有一个巧妙的方式是使用一维数组：对应下标储存对应的字符串。

String[] map = {"", "", abc, def....}

这样直接使用mep[i]就能找到对应的字母。

同样，因为不能确定需要使用多少层的for循环进行嵌套 ---这道题需要用回溯算法。

树的深度是数字的个数；树的宽度是第一个集合中的字母数量

回溯三部曲：

  • 输出以及输入的参数：

两个全局变量：List<String>  result - 所有字符串组合; String s - 当前字符串

输出：void

输入：backtraking(String digits  - 输入字符串, int index - 当前遍历到数字的下标) - 这道题和之前77.组合不一样的是：之前是在一个集合里面遍历，因此需要确定第二层起始的遍历的位置；而这里是在不同的集合中进行比那里，因此需要确定的是第二层需要遍历的集合是哪一个。

  • 回溯的终止条件：if(index = digits.length()) - 当index等于字符串的长度时，s中的元素已经满了「这里index代表的是当前遍历到的数字的下标，因此当index = digits.length()的时候，已经把数字都遍历完了，此时index已经不在digits这个字符中了，也就结束了」。「也可以用其他的参数控制，比如说」

  • 回溯的单层逻辑：先找到数字的映射 letters，然后for(int i = 0; i<letter.length();i++) - 将letters.chatAt(i) 放入s中；递归 —— backtraking(digits, index+1); 回溯：删除s最后一个字符

具体代码实现：

class Solution {
    public List<String> letterCombinations(String digits) {
        result = new ArrayList<>();
        s = new StringBuffer();

        //判断一下空的情况
        if(digits == null || digits.length() ==0){
            return result;
        }

        backtraking(digits, 0);

        return result;
    }

    String[] map = {"", "", "abc", "def", "ghi", "jkl", "mno", "qprs", "tuv", "wxyz"};
    List<String> result;
    StringBuffer s;
    public void backtraking(String digits, int index){
        //终止条件
        if(index == digits.length()){
            result.add(s.toString());
            return;
        }

        //获得映射字母串
        int d = digits.charAt(index) -'0';
        String m = map[d];

        for(int i=0; i< m.length(); i++){
            s.append(m.substring(i,i+1));
            
            //递归
            backtraking(digits, index+1);

            //回溯
            s.deleteCharAt(s.length()-1);
        }
    }
}

参考资料：https://programmercarl.com/0017.电话号码的字母组合.html#java

Ade-My，自由
关注
专栏目录
力扣之数组——
weixin_46314604的博客
10-17 256
这道题的思路容易被题目的意思打乱，两个数比较较小的数移到数组的末尾，我们就会想如何去移动数组元素，因为数组一个元素的下标变了，会波及其他元素，从而给我们的题解带来很大的麻烦，然而，我们需要知道我们实现的功能是返回满足游戏规则的那个赢家，而不是去跟随题目的意思去编写代码，所以我们需要去玩几把游戏，就像题目中给出的示例一样，几乎已经覆盖了所有情况，下面我们来进行列举： 首先，无论k值多大，赢家都应该在这个数组中，这是毋庸置疑的 遇到数组中的最大值之前都没有出现满足条件的赢家，那么赢家肯定是这个数组的最大值..
力扣问题总结
weixin_42049492的博客
02-24 2396
问题1： 问（1）：int* twoSum(int* nums, int numsSize, int target, int* returnSize)中== returnsize ==是什么意思？ 答：returnsize的作用是返回，告知调用者结果数组的大小。 问（2）：错误提示：load of null pointer of type ‘const int’ . 答： 在调用函数时，如果返回值...
详解力扣中int *returnSize和int **returnColumnSizes
热门推荐
m0_52775920的博客
11-21 1万+
在用C语言刷力扣的时候，我们经常会看到这两个东西，int* returnSize 和 int** returnColumnSizes。连题目都看不懂，更何况是做题呢？我也是查找了网上零零碎碎的资料和做了蛮多题之后，终于想明白了。遂整理成此文，希望能帮到后来者。个人理解，如有不足，烦请斧正。 首先我们来看一道题，力扣的第 15 题，三数之和。这是笔者第一次接触到这两个东西的题目。 三数之和 题干： 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + .
力扣刷题Day2
witch2026的博客
10-13 2166
常见数组力扣题
求职力扣刷题DAY21--二叉树 part07
qq_44486787的博客
06-12 310
中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。中序遍历，使用全局变量prev记录上一个遍历的元素，给你一个含重复值的二叉搜索树（BST）的根节点。差值是一个正数，其数值等于两值之差的绝对值。，找出并返回 BST 中的所有。如果树中有不止一个众数，可以按。给你一个二叉搜索树的根节点。（即，出现频率最高的元素）。
力扣刷题day1(顺序表）
njsnb的博客
08-31 324
本题的思想在于寻找逆序对个数，我们知道，如果一些数是（从小到大）自然排列的那么逆序对的数量为0，所以，我们首先寻找逆序对的个数，若逆序对的个数大于等于2了，那么说明只改变一个就无法使他有序，当没有逆序对的时候，自然是可以。如果只有一个逆序对，就要分情况讨论了，例如下面的一组数据：如果逆序对的位置在第一个数，那么只改变第一个数即可。如果逆序对的位置在倒数第二个数，那么只改变倒数第二个数即可。
力扣刷题Day1
RAN_PAND的博客
08-13 934
力扣刷题Day1
力扣刷题总结
weixin_43270322的博客
01-12 1029
总结刷过的力扣题目的一些思路
力扣刷题Day4
2301_79328557的博客
05-07 553
1. 对于c语言中的l，需要求字符串长度，使用strlen即可，不要用sizeof，否则会报错2.注意，这种题目中带着每这个字眼的，需要想到利用for循环，然后举个例子，来判断不同情况下所需要的代码块3.注意在while循环中别忘了要让两个“指针”移动——++和--,否则会导致无限循环，出错。4.在for循环中i要加2k,注意这里的2k不能直接这样写，要写成2*k,否则会报错——如下：通过变换k来实现，不过这个没有if语句好想起来。
力扣刷题百天计划 Day12 环形链表 力扣题库第141题 C# 哈希表+双指针
m0_48781656的博客
01-24 233
学习目标： 我会持续更新我独特的算法思路，希望能给大家带来不一样的思维拓展！ 如果大家感觉有帮助的话，欢迎点赞关注支持哦！ 你们的鼓励是我坚持下去的动力！ ！！！ 力扣题库第141题 官方链接 学习内容： 环形链表 给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注
力扣刷题百天计划 Day4 Z 字形变换
m0_48781656的博客
01-10 329
学习目标： 我会持续更新我独特的算法思路，希望能给大家带来不一样的思维拓展！ 如果大家感觉有帮助的话，欢迎点赞关注支持哦！ 你们的鼓励是我坚持下去的动力！ ！！！
SQL力扣刷题七
默主归沙的博客
07-30 529
Table: Table: 编写SQL查询以查找每种产品的平均售价。 应该四舍五入到小数点后两位。 查询结果格式如下例所示： 题解一 题解二 题解三 1264. 页面推荐 朋友关系列表： 喜欢列表： 写一段 SQL 向user_id = 1 的用户，推荐其朋友们喜欢的页面。不要推荐该用户已经喜欢的页面。你返回的结果中不应当包含重复项。返回结果的格式如下例所示。示例 1: 题解一 题解二 题解三 题解四 1270. 向公司CEO汇报工作的所有人 员工表： 用 SQL 查询出所有直接或间接向公司
【力扣刷题总结】
weixin_53061888的博客
12-21 592
每日一练1.题目与思路分析2.代码实现3.总结 1.题目与思路分析 1154. 一年中的第几天 给你一个字符串 date ，按 YYYY-MM-DD 格式表示一个 现行公元纪年法 日期。请你计算并返回该日期是当年的第几天。 通常情况下，我们认为 1 月 1 日是每年的第 1 天，1 月 2 日是每年的第 2 天，依此类推。每个月的天数与现行公元纪年法（格里高利历）一致。 示例 1： 输入：date = “2019-01-09” 输出：9 示例 2： 输入：date = “2019-02-10” 输出：41
力扣刷题 ｜ 数据库
然然然然_
05-23 640
利用好 自连接、嵌套查询、group by having、order、case when 等
leetcode209:长度最小的子数组
D2510466299的博客
10-12 595
我们需要从一个包含。
leetcode链表（四）-删除链表的倒数第N个节点
weixin_40198632的博客
10-11 389
给你一个链表，删除链表的倒数第n个结点，并且返回链表的头结点。
Leetcode 1168. 水资源分配优化
m0_51437455的博客
10-14 477
对于每个房子 i，我们有两种可选的供水方案：一种是直接在房子内建造水井，成本为 wells[i – 1] （注意 -1 ，因为 索引从0开始 ）；另一种是从另一口井铺设管道引水，数组 pipes 给出了在房子间铺设管道的成本，其中每个 pipes[j] = [house1_j, house2_j, cost_j] 代表用管道将 house1_j 和 house2_j连接在一起的成本。第二步，使用Prim算法模板或者Kruskal算法模板解除最小生成树的权值和（详情可以看下代码的注释）
LeetCode：1884. 鸡蛋掉落-两枚鸡蛋（dp Java）
最新发布
Cosmoshhhyyy的博客
10-14 508
f[i]为i层需要的最小次数。 第一次如果第 i 层碎了，那么说明f位于1- i之间，最后一次尝试i - 0次。 第一次如果没碎，那么说明位于i~n之间，那么就转换为n - j层的子问题。
LeetCode | 704.二分查找
编程菜鸟的学习记录
10-12 269
LeetCode | 704.二分查找
力扣刷题C++常用操作
10-18
好的，关于力扣刷题C++常用操作，我可以给你一些常见的操作和技巧： 1. 使用 STL 容器和算法库：STL（Standard Template Library）是 C++ 标准库中的一个重要组成部分，包含了许多常用的容器和算法。在力扣刷题中，使用 STL 可以大大提高代码的效率和可读性。例如，vector 可以用来存储动态数组，sort 可以用来排序等等。 2. 使用 auto 关键字：auto 关键字可以自动推导变量类型，可以减少代码量和提高可读性。例如，auto x = 1; 可以自动推导出 x 的类型为 int。 3. 使用 lambda 表达式：lambda 表达式是 C++11 中引入的一种匿名函数，可以方便地定义一些简单的函数对象。在力扣刷题中，使用 lambda 表达式可以简化代码，例如在 sort 函数中自定义比较函数。 4. 使用位运算：位运算是一种高效的运算方式，在力扣刷题中经常会用到。例如，左移运算符 << 可以用来计算 2 的幂次方，右移运算符 >> 可以用来除以 2 等等。 5. 使用递归：递归是一种常见的算法思想，在力扣刷题中也经常会用到。例如，二叉树的遍历、链表的反转等等。 6. 使用 STL 中的 priority_queue：priority_queue 是 STL 中的一个容器，可以用来实现堆。在力扣刷题中，使用 priority_queue 可以方便地实现一些需要维护最大值或最小值的算法。 7. 使用 STL 中的 unordered_map：unordered_map 是 STL 中的一个容器，可以用来实现哈希表。在力扣刷题中，使用 unordered_map 可以方便地实现一些需要快速查找和插入的算法。 8. 使用 STL 中的 string：string 是 STL 中的一个容器，可以用来存储字符串。在力扣刷题中，使用 string 可以方便地处理字符串相关的问题。 9. 注意边界条件：在力扣刷题中，边界条件往往是解决问题的关键。需要仔细分析题目，考虑各种边界情况，避免出现错误。 10. 注意时间复杂度：在力扣刷题中，时间复杂度往往是评判代码优劣的重要指标。需要仔细分析算法的时间复杂度，并尽可能优化代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值