LeetCode刷题总结 --- 排列组合框架

最新推荐文章于 2024-04-24 14:05:59 发布
最新推荐文章于 2024-04-24 14:05:59 发布
阅读量423 收藏 1
点赞数
分类专栏： LeetCode 算法 go语言 文章标签： 算法 leetcode go backtrack 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19018277/article/details/103749850
版权
go语言 同时被 3 个专栏收录
42 篇文章 2 订阅
订阅专栏
算法
12 篇文章 0 订阅
订阅专栏
LeetCode
8 篇文章 1 订阅
订阅专栏

文章目录

求解排列组合问题

导言

  1. 以下代码都存放于 我的GitHub仓库 ，如果小伙伴觉得有用，请给我颗星星哈。
  2. 以下代码都是提交过的，正确性可以保证。

1. 框架

// 这个框架能够求出数组中所有的具体排列组合
// 比如求: 
//      在可重复选取的数组 [1,2,3] 中组成 4 的组合。
//      那么这个框架可以得出的结果集是: [[1,1,1,1],[1,1,2],[2,2],[1,3]]，
//      且最终这个结果存放在 resultSet 中。

var resultSet [][]int    // 结果集

// 返回结果集的函数
func resultSetReturner() [][]int {	
	/* 
	   1. 进行一些预处理
	      a. 如果数组中有重复元素，且该问题是组合问题的话，那么这里需要排序，
	         为什么要排序？ 请看下面的    3. 对框架的一些解答
	*/
	/* 2. 调用回溯函数 */
	/* 5. 返回结果集 */
}

// 回溯函数
func backtracer() {
	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	
	isVisit := make(map[int]bool)   // 有重复元素才需要这个结构，没有重复元素的话，这个结构可以直接删除。
	
	for i : =0; i < len(nums); i++{
		// 判断在该层，这个数字是否已经使用过了
		if isVisit[nums[i]] == true  {
			// 使用过时
			continue
		}
		 isVisit[nums[i]] = true
		/* 
		   4.继续调用回溯函数，这里会有以下几种情况。
		        a. 如果题目要求: 求组合数，不能重复选取的话, 那么下一层处理的应该是 nums[i+1:]。
		        b. 如果题目要求: 求组合数，能重复选取的话, 那么下一层处理的应该是 nums[i:]。
		        c. 如果题目要求: 求排列数，能重复选取的话，那么下一层处理的应该是 nums[:]，即还是 nums。
		        d. 如果题目要求: 求排列数，不能重复选取的话，那就把nums[i]与nums[0]交换后，处理nums[1:]，处理好后再交换回来。
		*/
	}
}

2. 力扣排列组合问题分析

在这里插入图片描述

3. 实例

3.1 组合问题 — 没有重复元素、可重复选取

39. 组合总和

var combinationSequence [][]int    // 结果集

// 返回结果集的函数
func combinationSum(candidates []int, target int) [][]int {
	/* 1. 进行一些预处理 */
	combinationSequence = make([][]int, 0)

	/* 2. 调用回溯函数 */
	combinationSumExec(candidates, target, make([]int, 0, 100))

	/* 5. 返回结果集 */
	return combinationSequence
}

// 回溯函数
func combinationSumExec(candidates []int, target int, sequence []int) {
	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	// 剪枝
	if target < 0 {
		return
	}
	if target == 0 {
		combinationSequence = append(combinationSequence, newSlice(sequence))
		return
	}

	for i := 0; i < len(candidates); i++ {
		/* 4. 继续调用回溯函数 */
		// 因为题目要求的是组合数且能重复选取，所以下一层处理的是 candidates[i:]
		combinationSumExec(candidates[i:], target-candidates[i], append(sequence, candidates[i]))
	}
}

// 深拷贝
func newSlice(oldSlice []int) []int {
	slice := make([]int, len(oldSlice))
	copy(slice, oldSlice)
	return slice
}

3.2 组合问题 — 有重复元素、不可重复选取

40. 组合总和 Ⅱ

var combinationSequence [][]int	// 结果集

// 返回结果集的函数
func combinationSum2(candidates []int, target int) [][]int {
	/* 1. 进行一些预处理 */
	combinationSequence = make([][]int, 0)
	sort.Ints(candidates)	// 有重复元素的组合问题就要排序。

	/* 2. 调用回溯函数 */
	combinationSumExec(candidates, target, make([]int, 0, 5))

	/* 5. 返回结果集 */
	return combinationSequence
}

// 回溯函数
func combinationSumExec(candidates []int, target int, sequence []int) {

	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	if target < 0 {
		return
	}
	if target == 0 {
		combinationSequence = append(combinationSequence, newSlice(sequence))
		return
	}

	isVisited := make(map[int]bool)	// 题目有重复元素，所以需要这个结构
	for i := 0; i < len(candidates) && target >= candidates[i]; i++ {
		if isVisited[candidates[i]] == true {
			continue
		}
		isVisited[candidates[i]] = true

		/* 4. 继续调用回溯函数 */
		// 因为题目要求的是组合数且不能重复选取，所以下一层处理的是 candidates[i+1:]
		combinationSumExec(candidates[i+1:], target-candidates[i], append(sequence, candidates[i]))
	}
}

// 深拷贝
func newSlice(oldSlice []int) []int {
	slice := make([]int, len(oldSlice))
	copy(slice, oldSlice)
	return slice
}

90. 子集 Ⅱ

var subsetSequence [][]int	// 结果集

// 返回结果集的函数
func subsetsWithDup(nums []int) [][]int {
	/* 1. 预处理 */
	subsetSequence = make([][]int, 0)
	sort.Ints(nums) 	// 有重复元素的组合问题就要排序。为什么要排序呢？后面会说

	/* 2. 调用回溯函数 */
	subsetsExec(nums, []int{})

	/* 5. 返回结果集 */
	return subsetSequence
}
// 回溯函数
func subsetsExec(nums []int, sequence []int) {
	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	subsetSequence = append(subsetSequence, newSlice(sequence))

	isVisit := make(map[int]bool) // 记录数字是否使用过，防止出现重复的结果
	for i := 0; i < len(nums); i++ {
		if isVisit[nums[i]] {
			continue
		}
		isVisit[nums[i]] = true

		/* 4. 继续调用回溯函数 */
		// 因为题目要求的是组合数且不能重复选取，所以下一层处理的是 nums[i+1:]
		subsetsExec(nums[i+1:], append(sequence, nums[i]))
	}
}

// 深拷贝
func newSlice(slice []int) []int {
	s := make([]int, len(slice))
	copy(s, slice)
	return s
}

3.3 组合问题 — 没有重复元素、不可重复选取

78. 子集

var subsetSequence [][]int    // 结果集

// 返回结果集的函数
func subsets(nums []int) [][]int {
	/* 1. 预处理 */
	subsetSequence = make([][]int, 0)

	/* 2. 调用回溯函数 */
	subsetsExec(nums, []int{})

	/* 5. 返回结果集 */
	return subsetSequence
}

func subsetsExec(nums []int, sequence []int) {
	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	subsetSequence = append(subsetSequence, newSlice(sequence))

	for i := 0; i < len(nums); i++ {
		/* 4. 继续调用回溯函数 */
		// 因为题目要求的是组合数且不能重复选取，所以下一层处理的是 nums[i+1:]
		subsetsExec(nums[i+1:], append(sequence, nums[i]))
	}
}

func newSlice(slice []int) []int {
	s := make([]int, len(slice))
	copy(s, slice)
	return s
}

216. 组合总和 Ⅲ

var combinationSequence [][]int    // 结果集

func combinationSum3(k int, n int) [][]int {
	/* 1. 进行一些预处理 */
	candidates := make([]int, 9)
	combinationSequence = make([][]int, 0)
	for i := 1; i <= 9; i++ {
		candidates[i-1] = i
	}

	/* 2. 调用回溯函数 */
	combinationSumExec(candidates, n, k, make([]int, 0, 10))

	/* 5. 返回结果集 */
	return combinationSequence
}

func combinationSumExec(candidates []int, n int, k int, sequence []int) {

	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	if n == 0 && k == 0 {
		combinationSequence = append(combinationSequence, newSlice(sequence))
		return
	}
	if n == 0 || k == 0 {
		return
	}

	for i := 0; i < len(candidates); i++ {
		/* 4. 继续调用回溯函数 */
		// 因为题目要求的是组合数且不能重复选取，所以下一层处理的是 candidates[i+1:]
		combinationSumExec(candidates[i+1:], n-candidates[i], k-1, append(sequence, candidates[i]))
	}
}

// 深拷贝
func newSlice(oldSlice []int) []int {
	slice := make([]int, len(oldSlice))
	copy(slice, oldSlice)
	return slice
}

3.4 排列问题 — 没有重复元素、不可重复选取

46. 全排列

var permuteSequence [][]int // 结果集

// 返回结果集的函数
func permute(nums []int) [][]int {
	/* 1. 进行一些预处理 */
	permuteSequence = make([][]int, 0)

	/* 2. 调用回溯函数 */
	permuteUniqueExec(nums, []int{})

	/* 5. 返回结果集 */
	return permuteSequence
}

// 回溯函数
func permuteUniqueExec(nums []int, sequence []int) {
	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	if len(nums) == 0 {
		permuteSequence = append(permuteSequence, newSlice(sequence))
		return
	}


	for i := 0; i < len(nums); i++ {
		/* 4. 继续调用回溯函数，这里会有以下几种情况。*/
		// 因为题目要求的是排列数，且不可重复选取，所以处理如下。
		nums[0], nums[i] = nums[i], nums[0]
		permuteUniqueExec(nums[1:], append(sequence, nums[0]))
		nums[0], nums[i] = nums[i], nums[0]
	}
}

// 深拷贝
func newSlice(oldSlice []int) []int {
	slice := make([]int, len(oldSlice))
	copy(slice, oldSlice)
	return slice
}

3.5 排列问题 — 有重复元素、不可重复选取

47.全排列 Ⅱ

var permuteSequence [][]int // 结果集

// 返回结果集的函数
func permuteUnique(nums []int) [][]int {
	/* 1. 进行一些预处理 */
	permuteSequence = make([][]int, 0)

	/* 2. 调用回溯函数 */
	permuteUniqueExec(nums, []int{})

	/* 5. 返回结果集 */
	return permuteSequence
}

// 回溯函数
func permuteUniqueExec(nums []int, sequence []int) {
	/* 3. 判断是否需要加入结果集以及进行剪枝 */
	if len(nums) == 0 {
		permuteSequence = append(permuteSequence, newSlice(sequence))
		return
	}

	isVisit := make(map[int]bool)   // 有重复元素才需要这个结构，没有重复元素的话，这个结构可以直接删除。

	for i := 0; i < len(nums); i++ {
		if isVisit[nums[i]] == true  {
			// 使用过时
			continue
		}
		isVisit[nums[i]] = true
		/* 4. 继续调用回溯函数，这里会有以下几种情况。*/
		// 因为题目要求的是排列数，且不可重复选取，所以处理如下。
		nums[0], nums[i] = nums[i], nums[0]
		permuteUniqueExec(nums[1:], append(sequence, nums[0]))
		nums[0], nums[i] = nums[i], nums[0]
	}
}

// 深拷贝
func newSlice(oldSlice []int) []int {
	slice := make([]int, len(oldSlice))
	copy(slice, oldSlice)
	return slice
}

4. 对框架的一些解答

4.1 为什么有重复元素的组合问题预处理时需要进行排序呢？

假如有一个不可重复选取的数组 [1, 4, 1], 我们要求出组成总和为 5 的所有组合。 我们调用上面的框架，但是不对他进行排序。

那么我们得出的结果是 : [[1, 4], [4, 1]]，显然，这 2 个组合是一样的，那是什么导致了这个问题呢？

先说说这两个元组的形成原因:

  • 在第一个 1 后，它发现自己和后面的 4 相加就能组成 5，于是出现 [1, 4] 这个组合。
  • 而在 4 后面，它发现自己和后面的 1 相加就能组成 5，于是出现 [4, 1] 这个组合。

那我们如何避免这种重复组合的情况呢？

最简单的方法就是使用排序，让数组有序化，这样就不会出现 a 与后面的 b 组合后，b 又与后面另外一个 a 进行组合。

于是，[1, 4, 1] 这个数组经过排序后，变为了 [1, 1, 4]，4 的后面没有 1，这样就不会导致重复组合的情况了。

而你此时可能会问: 为什么此时不会出现两个[1, 4]的情况呢？即返回结果是[[1, 4], [1, 4]]。

这个问题我们已经用框架中的isVisited这个结构解决了，当第一个 1 被加入 sequence 后，我们把 1 标记为已访问。
之后在该层又遇到 1, 此时由于我们已经标记了 1，即此时 isVisited[1] == true，于是接下来会执行 continue 操作，
跳过了这个1的后续操作，所以不会出现两个[1, 4]的情况

5. 注意点

  • 上面的框架可以求出具体的排列组合，于是我们也可以得出这些排列组合的长度、种数，但是实际上还有更好的方法求出排列组合的种数，比如采用动态规划。
  • 以上框架在实际问题中可能需要经过一些转换、改变，所以需要灵活运用。

6. 练习题

I am a gopher
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode刷题笔记-堆
08-19
Leetcode刷题笔记—堆相关题型，刷透一道题顶10盲刷10道题，还在苦苦纠结于打开力扣直奔题解的苦恼吗? 赶快来看一看吧
C++leetcode刷题c-c-master.zip
03-18
本资料“C++leetcode刷题c-c-master.zip”正是围绕C++语言，针对LeetCode平台进行深入学习和实践的资源集合。 首先，让我们来了解一下C++。C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化...
LeetCode刷题指南 - 算法必读篇
weixin_622464的博客
04-24 1388
LeetCode刷题指南 - 算法必读篇
LeetCode刷题系列 -- 567. 字符串的排列
qq_33775774的博客
12-14 149
s2 包含 s1 的排列之一 ("ba").
LeetCode刷题 -- 分治算法
qq_43325216的博客
10-13 273
就是把一个复杂的问题分成两个或者更多相同或者相似的子问题（分），在把子问题分成更小的子问题...一直到最后的子问题可以简单的直接求解出来，那么原问题的解就是分出来的这些子问题的合并（治）。n为偶数时：x^n = x^(n/2) * x^(n/2) ===》这个场景不需要考虑n的正负。x^n = x^(n/2) * x^(n/2) * x ===》n为正数。x^n = x^(n/2) * x^(n/2) / x ===》n为负数。3、合并：将已求解的各个子问题的解，逐步合并为原问题的解。
leetcode刷题记录总结-7.二叉树
xingzhes_的博客
01-30 578
在我们解题过程中二叉树有两种主要的形式：满二叉树和完全二叉树。满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。如图所示：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QBInXkoR-1675071115879)(assets/20200806185805576.png)]这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。什么是完全二叉树？完全二叉
LeetCode刷题指南 - 动态规划篇
最新发布
weixin_622464的博客
04-24 902
LeetCode刷题指南 - 动态规划篇
LeetCode刷题系列 -- 438. 找到字符串中所有字母异位词
qq_33775774的博客
12-15 262
1. 定义 left 与 right 两个变量，作为 s滑动窗口的 左边下标 与右边下标，且为 闭开区间，[left,right)，定义 valid ，当 s 中的子字符串 中各字符的数量与 p 中各字符的数量相等，而且 s 的子字符串的长度与p字符串的长度相等.2. 定义 两个map ，分别为 need 与 window，need 用于记录 字符串 p 中有哪些字符以及每个字符出现的次数，window 记录 s[left,right) 区间子字符串中而且在 p 中出现的字符的个数。不考虑答案输出的顺序。
LeetCode刷题指南 - 数据结构篇
weixin_622464的博客
04-24 310
LeetCode刷题指南-数据结构篇
Leetcode刷题--116. 填充每个节点的下一个右侧节点指针
qq_44787943的博客
01-26 118
题解链接参考：https://labuladong.gitbook.io/algo/shu-ju-jie-gou-xi-lie/shou-ba-shou-shua-er-cha-shu-xun-lian-di-gui-si-wei/er-cha-shu-xi-lie-1 难度中等，本题思想在于细分，以及树的递归模板使用 写在前头 递归算法的关键要明确函数的定义，相信这个定义，而不要跳进递归细节。 写二叉树的算法题，都是基于递归框架的，我们先要搞清楚root节点它自己要做什么，然后根据题目要求选择使用前序，中
LeetCode刷题 - 基础算法小结
happylls666的博客
07-09 515
LeetCode刷题所需的基础算法
leetcode刷题账号-leetcode:leetcode
07-06
leetcode刷题账号 Leet Code 每日刷 LeetCode 题目我会定时更新一些，数组、链表、栈、队列、二叉树等经典题目 解法会从遍历、递归、动态规划等逐步展开 刷题步骤 修改自己的刷题群备注为自己的 Coding 账号名称，...
JAVA小白leetcode刷题顺序--offer:-提供
07-06
JAVA小白leetcode刷题顺序 本人也是java小白一个，刷题剑指offer也是开始第三遍，准备记录一下每道题的一些通用解法，可能不是最优的，但一定是最容易理解和接受的~ 小白选取的《剑指offer》是LeetCode上面的剑指...
谷歌师兄的leetcode刷题笔记-momentum:势头
06-30
谷歌师兄的leetcode刷题笔记动力是给男人的 我们的重点是男人的工作，并成为我们能做到的最好的男人。 我们支持男人拥有真正的友谊 当然，我们喜欢一起玩乐，但我们正在寻找更多的东西：与我们信任的伟人建立真正的...
Go语言实现第三方登录Github (通过OAuth2.0)
qq_19018277的博客
03-18 3474
以下将采用一个实例，实现第三方网站登录 Github
类图、依赖、泛化(继承)、实现、关联、组合、聚合
qq_19018277的博客
03-18 1187
下面将会用简单的语言分别描述什么是类图、依赖、泛化(继承)、实现、关联、组合、聚合。
LeetCode刷题总结 --- 记忆化搜索框架
qq_19018277的博客
12-29 775
这是记忆化搜索框架哇！
go语言 --- 切片与数组
qq_19018277的博客
09-07 469
在下面，我会先说说切片和数组的关系，之后再提及切片的追加、切片的拷贝和切片作为参数的一些注意点，至于切片元素的删除等基本操作，本文不涉及。
AcWing暑期LeetCode刷题班-树专题：判断BST
"AcWing夏季LeetCode刷题活动介绍及树相关题目解析" 在AcWing的暑期LeetCode刷题活动中，参与者将面临一系列精选的高频率算法题目，总计80道，涵盖了各种数据结构和算法主题。活动分为8周进行，每周会有10道题目，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值