LeetCode刷题day46

已于 2022-03-08 16:01:52 修改
阅读量615 收藏 4
点赞数 10
分类专栏： LeetCode刷题 文章标签： list leetcode c++
于 2022-03-07 22:43:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LXYDSF/article/details/123341986
版权

文章目录

78. 子集

题目描述

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

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

示例 2：

输入：nums = [0]
输出：[[],[0]]
思路分析

如果把 子集问题、组合问题、分割问题都抽象为一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！

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

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

以示例中nums = [1,2,3]为例把求子集抽象为树型结构，如下：

78.子集

回溯三部曲

  • 确定递归参数和返回值

递归参数:需要遍历的数组 vector<int> &nums,每层遍历的起始下标startIndex .

返回值:由于定义全局变量来保存最终结果集以及单一结果,所以并不需要返回值.

  • 确定结束条件

由于这次是寻找所有的组合,所以并不需要结束条件.没递归一层就把对应的结果放入到结果集中.

  • 确定单层递归逻辑

将当前组合数加入单一结果集,递归,回来后进行回溯.进行下一次循环.

参考代码
#include<bits/stdc++.h>
using namespace std;

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int> &nums,int startIndex){
	result.push_back(path);
	for(int i = startIndex; i < nums.size(); i++){
		path.push_back(nums[i]);
		backtracking(nums,i+1);
		path.pop_back();
	}
}

vector<vector<int>> subsets(vector<int>& nums) {
	result.clear();
	path.clear();
	backtracking(nums,0);
	return result;
}

90. 子集 II

题目描述

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入：nums = [0]
输出：[[],[0]]
思路分析

这个题的数组nums可能包含重复元素,则需要对树层进行去重. 目前我们有三种去重方法:利用vector<bool> used , 利用startIndex, 利用ordered_set<int> ,下面我们将逐一进行演示.

用示例中的[1, 2, 2] 来举例，如图所示： （注意去重需要先对集合排序）

90.子集II

本题不再分析递归三部曲了,关键部分将添加相关注释.

参考代码

方法一: 利用vector<bool> used 去重

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int> &nums,int startIndex,vector<bool> &used){//参数相比上次就过个used
	result.push_back(path);
	for(int i = startIndex; i < nums.size(); i++){
		if(i > 0 && nums[i]==nums[i-1] && used[i-1]==false){//如果同一树层元素重复了,则跳过本次循环
			continue;
		}
		path.push_back(nums[i]);
		used[i] = false;
		backtracking(nums,i+1,used);
        //递归后的回溯
		path.pop_back();
		used[i] = true;
	}
}

vector<vector<int>> subsetsWithDup(vector<int>& nums) {
	vector<bool> used(nums.size());//定义一个used数组,用来树层去重
	result.clear();
	path.clear();
	sort(nums.begin(),nums.end());
	backtracking(nums,0,used);
	return result;
}

方法二:使用startIndex去重

void backtracking(vector<int> &nums,int startIndex){
	result.push_back(path);
	for(int i = startIndex; i < nums.size(); i++){
		if(i > startIndex && nums[i]==nums[i-1]){	//使用startIndex去重也可以. 
			continue;
		}
		path.push_back(nums[i]);
		backtracking(nums,i+1,used);
		path.pop_back();
	}
}

方法三:使用ordered_set<int> uset去重

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
    result.push_back(path);
    unordered_set<int> uset;//定义
    for (int i = startIndex; i < nums.size(); i++) {
        if (uset.find(nums[i]) != uset.end()) {//如果能在uset中找到当前值nums[i],则当前树层重复
            continue;
        }
        uset.insert(nums[i]);//由于uset仅用于去重,所以后文不用进行回溯.不然就无意义了
        path.push_back(nums[i]);
        backtracking(nums, i + 1, used);
        path.pop_back();
    }
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
    result.clear();
    path.clear();
    vector<bool> used(nums.size(), false);
    sort(nums.begin(), nums.end()); // 去重需要排序
    backtracking(nums, 0, used);
    return result;
}

491. 递增子序列

题目描述

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]
思路分析

本题的一个坑: 不能对nums进行排序, 不然就和示例对不上了.

以[4, 7, 6, 7]这个数组为例，抽象为树形结构如图：

491. 递增子序列1

递归三部曲:

  • 确定递归参数和返回值

递归参数:虽然求的是序列,有顺序,但是因为元素不可以重复,并且有一定的顺序(从前往后的方向),所以需要startIndex. 当然也需要递归的数组: vector<int>&nums

返回值: 因为定义了全局变量,所以并不需要

  • 确定递归结束条件

当元素个数 path.size() >= 2,可将临时组合存入结果集中.

  • 确定单层递归逻辑

由于数组中有重复元素,所以需要进行去重.而且是无序的,所以采用 ordered_set<int> uset. 另外序列也需要递增

每次循环判断当前组合数是否本层重复以及递增,如果是,则放入临时组合集=> uset更新=>递归=>回溯=>循环下一个数. 如果不是,则进入跳过当前的数,进行下一个循环.

备注:因为 -100 <= nums[i] <= 100, 数据范围较小所以我们可以使用 int used[201]去重.这个相比ordered_set效率更高.

参考代码

方法一:使用unordered_set<int> uset去重

vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>&nums,int startIndex) {//因为元素不可以重复,并且有一定的顺序,所以需要 startIndex参数
	if(path.size()>1) {
		result.push_back(path);
        //return; 这里不需要return 哦,因为序列是 >= 2 的.
	}
	unordered_set<int> uset;//用于去重
	for(int i = startIndex; i < nums.size(); i++) {
		if((!path.empty() && nums[i] < path.back() ) || uset.find(nums[i])!=uset.end()) { //元素不是递增  || 元素和之前的重复  都不可
			continue;
		}
		path.push_back(nums[i]);
		uset.insert(nums[i]);//不用进行回溯,只用于判断该元素是否本层中使用过
		backtracking(nums,i+1);
		path.pop_back();
	}
}

vector<vector<int>> findSubsequences(vector<int>& nums) {
	result.clear();
	path.clear();
	backtracking(nums,0);
	return result;
}

方法二:使用int[201] used去重

//方法二,使用int数组来去重 
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>&nums,int startIndex) {//因为元素不可以重复,并且有一定的顺序,所以需要 startIndex参数
	if(path.size()>1) {
		result.push_back(path);
	}
	int used[201] = {0};//用于去重  -100-100   0 200
	for(int i = startIndex; i < nums.size(); i++) {
		if((!path.empty() && nums[i] < path.back() ) || used[nums[i]+100]) { //元素不是递增  || 元素和之前的重复  都不可
			continue;
		}
		path.push_back(nums[i]);
		used[nums[i]+100] = 1;
		backtracking(nums,i+1);
		path.pop_back();
	}
}

vector<vector<int>> findSubsequences(vector<int>& nums) {
	result.clear();
	path.clear();
	backtracking(nums,0);
	return result;
}

46. 全排列

题目描述

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

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

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]
思路分析

排列里面的数字有一定顺序性,而组合与顺序无关.这决定了startIndex的起始位置.

以[1,2,3]为例，抽象成树形结构如下：

46.全排列

回溯三部曲

  • 确定递归参数和返回值

递归参数:递归的数组vector<int>&nums ,用于标记元素的数组 vector<bool>& used

递归返回值:定义全局变量,无需返回值.

  • 确定递归结束条件

全排列要求排列后的数据和数组里面的数据个数相同. 所以结束条件: path.size()==nums.size()

  • 确定单层递归逻辑

判断当前循环的数是否被使用过,没被使用=>放入临时全排列集=>改变used=>递归=>回溯=>循环下一个数

注意:used数组常用于组合中树层/树枝的去重(常伴随着元素先排序), 也常用于排列中数据的标记. ordered_set常用于进行树层去重.

参考代码
vector<int> path;
vector<vector<int>> result;

void backtracking(vector<int>&nums,vector<bool>& used){//used用于取没有使用过的元素 
	if(path.size()==nums.size()){
		result.push_back(path);
		return;
	}
	for(int i = 0;i < nums.size();i++){
		if(!used[i]){
			path.push_back(nums[i]);
			used[i] = true;
			backtracking(nums,used);
			path.pop_back();
			used[i] = false;
		}
	}
}

vector<vector<int>> permute(vector<int>& nums) {
	path.clear();
	result.clear();
	vector<bool> used(nums.size(),false);
	backtracking(nums,used);
	return result;
}

47. 全排列 II

题目描述

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
思路分析

这道题目和 46.全排列 的区别在与给定一个可包含重复数字的序列，要返回所有不重复的全排列,牵涉到树层的去重. 我们可以采取 vector<bool> used , 利用ordered_set<int>进行去重.

我以示例中的 [1,1,2]为例 ,抽象为一棵树，去重过程如图：

47.全排列II1

参考代码

方法一:使用vector<bool> used去重

#include<bits/stdc++.h>
using namespace std;

vector<int> path;
vector<vector<int>> result;

void backtracking(vector<int>&nums,vector<bool>& used) {
	if(path.size()==nums.size()) {
		result.push_back(path);
		return;
	}
	for(int i = 0; i< nums.size(); i++) {
		//同一树层进行去重
		if(i > 0 && nums[i]==nums[i-1] && !used[i-1]) {
			continue;
		}
		if(!used[i]) {
			path.push_back(nums[i]);
			used[i] = true;
			backtracking(nums,used);
			path.pop_back();
			used[i] = false;
		}
	}
}

vector<vector<int>> permuteUnique(vector<int>& nums) {
	path.clear();
	result.clear();
	sort(nums.begin(),nums.end());//用到同层去重必排序
	vector<bool> used(nums.size(),false);
	backtracking(nums,used);
	return result;
}

方法二:使用ordered_set进行去重

void backtracking (vector<int>& nums, vector<bool>& used) {
    if (path.size() == nums.size()) {
        result.push_back(path);
        return;
    }
    unordered_set<int> uset; // 控制某一节点下的同一层元素不能重复
    for (int i = 0; i < nums.size(); i++) {
        if (uset.find(nums[i]) != uset.end()) {
            continue;
        }
        if (used[i] == false) {
            uset.insert(nums[i]); // 记录元素
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
}

如果有收获！！！ 希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客

爱编程的大李子
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
最低加油次数leetcode-LeetCode:LeetCode刷题笔记
06-30
LeetCode刷题笔记 Day1 1. 两数之和 知识点：哈希表，键为元素值，值为索引。边遍历边判断差值是否存在于哈希表 2. 两数相加 知识点：链表遍历 53. 最大子序和 知识点：动态规划或者贪心算法 983. 最低票价 知识点：...
LeetCode刷题Day7
weixin_45101231的博客
03-13 912
【代码】LeetCode刷题Day7。
LeetCode刷题day46|139.单词划分、多重背包
weixin_46081231的博客
11-07 230
139.单词划分、多重背包
Leetcode刷题——Day1
柠檬黄先生的博客
05-10 536
一边看算法，一边刷题吧，先从简单的开始： 刷题之路这就开始了？ 561. Array Partition I Given an array of 2n integers, your task is to group these integers into n pairs of integer, say (a1, b1), (a2, b2), …, (an, bn) which makes...
LeetCode刷题day56
LXYDSF的博客
03-25 6404
LeetCode刷题day56
LeetCode刷题DAY1
cheung的博客
11-23 3215
力扣（LeetCode）刷题：1480. 一维数组的动态和
leetcode卡-LeetCode-solution:LeetCode刷题打卡
07-06
LeetCode刷题打卡—监督自己！不懂的代码Debug一遍 Day1: 2021年5月31日 Day2: 2021年6月1日 Day3: 2021年6月2日 Day4: 2021年6月3日 Day5: 2021年6月4日 Day6: 2021年6月5日 Day7: 2021年6月6日 Day8: 2021年6月7日...
Leetcode扑克-LeetCodeJava:leetcode刷题java
06-30
Leetcode扑克 LeetCodeJava LeetCode部分习题Java版，包括多种解法，时间复杂度和空间复杂度自行分析。 Day01 逆波兰表达式求值 Day02 合并两个有序链表 Day03 合并K个排序链表 Day04 验证二叉搜索树 Day05 二叉树中...
LeetCode判断字符串是否循环-myLeetCode:leetcode刷题
07-01
leetcode刷题 语言：python 平台：jupyter notebook 字符串 day01 验证回文字符串 思路：先对字符串判断，是否为空，若为空，则为回文串 其次再对非空字符串判断，首先将字符串全部转化为小写字符，然后定义类似指针...
谷歌师兄的leetcode刷题笔记-day_7_Premiers_programmes:day_7_Premiers_programmes
06-30
谷歌师兄的leetcode刷题笔记第七天 列表练习： 多 Caesar 这里有两个版本都可以使用。 每个人都做了自己的。 雷曼兄弟 Google 运行脚本时要小心。 更改或注释要运行的函数。 莎士比亚 运行脚本时要小心。 更改或注释...
四、Redis五种常用数据类型-List
qq_41056506的博客
05-08 1165
List是Redis中的列表，按照插入顺序保存数据，插入顺序是什么样的，数据就怎么保存。可以添加一个元素到列表的头部(左边)或者尾部(右边)。一个列表最多可以包含232-1个元素(4294967295，每个列表超过40亿个元素)。是一种双向列表结构。与中的类似，中的是一个双向链表，也是由一个个的节点组成。借助语言的链表节点结构如下： 指向前一个节点，指向下一个节点，保存着当前节点对应的数据对象。结构示意图如下： 链表的结构如下： 指向链表的头结点，指向链表的尾节点。表示链表有多少个节点，这样可以在的时间复
list转成tree返回前端
tellmewhoisi的博客
05-09 286
到处之前excel导入的数据，参照之前写的网址。耻辱，现在不会用他们封装的方法。就贴一个control层。
springboot通过 EasyExcel.read（）方法解析csv（excel）文件中的数据用list接收
最新发布
qq_57703172的博客
05-14 292
EasyExcel采用一行一行的解析模式，并将一行的解析结果以观察者模式通知处理(AnalysisEventListener)。
Java 集合-List
qq_43339789的博客
05-10 966
集合主要分为两组(单列集合, 双列集合)
Typescript高级: 对泛型和多态的应用, 实现Java中的ArrayList和LinkedList
Wang的专栏
05-12 847
LinkedList 类实现了 List 接口，并包含了维护链表状态的重要属性。在 LinkedList 的实现中，节点被定义为一个名为 N 的内部类。ArrayList 这个类继承List接口，并实现其所有的方法。删除元素：remove 方法遍历链表，查找并删除指定的元素。获取元素：get 方法通过遍历链表找到指定位置的元素。在基础List类型中，我们定义了如下方法和属性。添加元素：add 方法在链表尾部添加一个新节点。这里面实现了方法的多态和泛型。
leetcode1290-Convert Binary Number in a Linked List to Integer
我的程序人生
05-08 432
给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。这道题目就遍历链表就可以实现，先确定每一位的位数，然后分别计算每一位二进制对应的十进制数累加即可。解释：二进制数 (101) 转化为十进制数 (5)请你返回该链表所表示数字的 十进制值。输入：head = [1,0,1]
java 树型结构转list
轻描时光
05-08 578
/ System.out.println("找到了节点: " + result.value);// System.out.println("未找到节点");// 查找值为5的节点。
使用com.google.common.collect依赖包中的Lists.transform()方法转换集合对象之后，修改集合中的对象属性，发现不生效
•一个写代码的• •知识星球•https://t.zsxq.com/15rGFbGEk
05-10 471
从上面就可以看出来啦，当我们使用Lists.transform()方法转换得到的集合对象，如果没有对其数据进行修改操作，只是遍历集合，那么返回的数据就是相同的，但是，如果有对其进行修改操作，那么此时Lists.transform()方法会创建一个新的对象，修改也只是这个新的对象的数据，不会影响转换的集合数据，可以理解为：修改的数据只是一个临时对象，并不是原对象。针对上面的情况，解决方案当然是，直接通过new的方式，创建一个新的集合，然后对这个新的集合数据进行修改。
leetcode876-Middle of the Linked List
我的程序人生
05-12 245
给你单链表的头结点 head ，请你找出并返回链表的中间结点。用快慢指针即可，在快指针遍历完以后慢指针指向的就是目标结点。如果有两个中间结点，则返回第二个中间结点。输入：head = [1,2,3,4,5]解释：链表只有一个中间结点，值为 3。输出：[3,4,5]
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册主要包括了LeetCode网站上的题目分类和解题思路。它以系统的方式组织了数百道LeetCode题目，并提供了针对每道题目的解题思路和详细的C语言代码实现。通过这本手册，程序员可以快速了解各种算法和数据结构的特点，掌握它们在解决实际问题中的应用。 LeetCode刷题手册C版的优势在于它提供了C语言的实现和相关的技巧。C语言是一种高效、灵活且广泛使用的编程语言，掌握C语言的编程技巧能够帮助程序员更好地理解算法和数据结构的原理，并设计出高质量的代码。此外，C语言也是很多面试中常见的编程语言，因此掌握LeetCode刷题手册C版可以帮助程序员在面试中更好地展示自己的技术能力。 总之，LeetCode刷题手册C版是一个针对C语言程序员的宝贵资源，它可以帮助程序员提升编程能力、学习算法和数据结构，并在面试中展现自己的优势。通过刷题手册C版的学习，程序员可以更好地理解LeetCode题目，提高解题效率，进一步提升自己的技术水平。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

爱编程的大李子

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

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

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

打赏作者

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

抵扣说明：

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

余额充值