github/leetcode-master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新图床

Browse Source
This commit is contained in:
programmercarl
2023-03-10 14:02:32 +08:00
parent 2a9b627a90
commit 17cb4b45c7
134 changed files with 1169 additions and 829 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
problems/0077.组合.md
View File

@@ -1,3 +1,4 @@
<p align="center">
<a href="https://programmercarl.com/other/xunlianying.html" target="_blank">
<img src="../pics/训练营.png" width="1000"/>
@@ -7,31 +8,32 @@
# 第77题. 组合
[力扣题目链接](https://leetcode.cn/problems/combinations/ )
给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
# 算法公开课
# 算法公开课
**《代码随想录》算法视频公开课：[带你学透回溯算法-组合问题（对应力扣题目：77.组合）](https://www.bilibili.com/video/BV1ti4y1L7cv)，[组合问题的剪枝操作](https://www.bilibili.com/video/BV1wi4y157er)，相信结合视频在看本篇题解，更有助于大家对本题的理解**。
# 思路
# 思路
本题是回溯法的经典题目。
@@ -39,6 +41,7 @@
直接的解法当然是使用for循环，例如示例中k为2，很容易想到 用两个for循环，这样就可以输出 和示例中一样的结果。
代码如下：
```CPP
int n = 4;
for (int i = 1; i <= n; i++) {
@@ -66,7 +69,7 @@ for (int i = 1; i <= n; i++) {
**此时就会发现虽然想暴力搜索，但是用for循环嵌套连暴力都写不出来！**
咋整？
咋整？
回溯搜索法来了，虽然回溯法也是暴力，但至少能写出来，不像for循环嵌套k层让人绝望。
@@ -86,7 +89,7 @@ for (int i = 1; i <= n; i++) {
那么我把组合问题抽象为如下树形结构：
![77.组合](https://img-blog.csdnimg.cn/20201123195223940.png)
![77.组合](https://code-thinking-1253855093.file.myqcloud.com/pics/20201123195223940.png)
可以看出这棵树，一开始集合是 1，2，3，4， 从左向右取数，取过的数，不再重复取。
@@ -94,7 +97,7 @@ for (int i = 1; i <= n; i++) {
**每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围**。
**图中可以发现n相当于树的宽度，k相当于树的深度**。
**图中可以发现n相当于树的宽度，k相当于树的深度**。
那么如何在这个树上遍历，然后收集到我们要的结果集呢？
@@ -107,7 +110,7 @@ for (int i = 1; i <= n; i++) {
## 回溯法三部曲
* 递归函数的返回值以及参数
* 递归函数的返回值以及参数
在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。
@@ -124,25 +127,25 @@ vector<int> path; // 用来存放符合条件结果
然后还需要一个参数，为int型变量startIndex，这个参数用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
为什么要有这个startIndex呢？
为什么要有这个startIndex呢？
**建议在[77.组合视频讲解](https://www.bilibili.com/video/BV1ti4y1L7cv)中，07:36的时候开始听，startIndex 就是防止出现重复的组合**。
从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，那么下一层递归如何知道从[2,3,4]中取数呢，靠的就是startIndex。
![77.组合2](https://img-blog.csdnimg.cn/20201123195328976.png)
![77.组合2](https://code-thinking-1253855093.file.myqcloud.com/pics/20201123195328976.png)
所以需要startIndex来记录下一层递归，搜索的起始位置。
所以需要startIndex来记录下一层递归，搜索的起始位置。
那么整体代码如下：
```cpp
vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件单一结果
void backtracking(int n, int k, int startIndex)
void backtracking(int n, int k, int startIndex)
```
* 回溯函数终止条件
* 回溯函数终止条件
什么时候到达所谓的叶子节点了呢？
@@ -150,7 +153,7 @@ path这个数组的大小如果达到k，说明我们找到了一个子集大小
如图红色部分：
![77.组合3](https://img-blog.csdnimg.cn/20201123195407907.png)
![77.组合3](https://code-thinking-1253855093.file.myqcloud.com/pics/20201123195407907.png)
此时用result二维数组，把path保存起来，并终止本层递归。
@@ -163,21 +166,21 @@ if (path.size() == k) {
}
```
* 单层搜索的过程
* 单层搜索的过程
回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。
![77.组合1](https://img-blog.csdnimg.cn/20201123195242899.png)
![77.组合1](https://code-thinking-1253855093.file.myqcloud.com/pics/20201123195242899.png)
如此我们才遍历完图中的这棵树。
for循环每次从startIndex开始遍历，然后用path保存取到的节点i。
for循环每次从startIndex开始遍历，然后用path保存取到的节点i。
代码如下：
```CPP
for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
path.push_back(i); // 处理节点
path.push_back(i); // 处理节点
backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
path.pop_back(); // 回溯，撤销处理的节点
}
@@ -201,7 +204,7 @@ private:
return;
}
for (int i = startIndex; i <= n; i++) {
path.push_back(i); // 处理节点
path.push_back(i); // 处理节点
backtracking(n, k, i + 1); // 递归
path.pop_back(); // 回溯，撤销处理的节点
}
@@ -216,9 +219,10 @@ public:
};
```
还记得我们在[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)中给出的回溯法模板么？
还记得我们在[关于回溯算法，你该了解这些！](https://programmercarl.com/回溯算法理论基础.html)中给出的回溯法模板么？
如下：
```
void backtracking(参数) {
if (终止条件) {
@@ -234,15 +238,15 @@ void backtracking(参数) {
}
```
**对比一下本题的代码，是不是发现有点像！** 所以有了这个模板，就有解题的大体方向，不至于毫无头绪。
**对比一下本题的代码，是不是发现有点像！** 所以有了这个模板，就有解题的大体方向，不至于毫无头绪。
## 总结
## 总结
组合问题是回溯法解决的经典问题，我们开始的时候给大家列举一个很形象的例子，就是n为100，k为50的话，直接想法就需要50层for循环。
从而引出了回溯法就是解决这种k层for循环嵌套的问题。
然后进一步把回溯法的搜索过程抽象为树形结构，可以直观的看出搜索的过程。
然后进一步把回溯法的搜索过程抽象为树形结构，可以直观的看出搜索的过程。
接着用回溯法三部曲，逐步分析了函数参数、终止条件和单层搜索的过程。
@@ -266,7 +270,7 @@ for (int i = startIndex; i <= n; i++) {
这么说有点抽象，如图所示：
![77.组合4](https://img-blog.csdnimg.cn/20210130194335207.png)
![77.组合4](https://code-thinking-1253855093.file.myqcloud.com/pics/20210130194335207-20230310134409532.png)
图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。
@@ -275,6 +279,7 @@ for (int i = startIndex; i <= n; i++) {
**如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了**。
注意代码中i，就是for循环里选择的起始位置。
```
for (int i = startIndex; i <= n; i++) {
```
@@ -342,6 +347,7 @@ public:
### Java：
```java
class Solution {
List<List<Integer>> result = new ArrayList<>();
@@ -370,7 +376,7 @@ class Solution {
}
```
### Python
### Python
```python
class Solution(object):
@@ -417,6 +423,7 @@ class Solution:
```
剪枝：
```python
class Solution:
def combine(self, n: int, k: int) -> List[List[int]]:
@@ -434,7 +441,8 @@ class Solution:
return res
```
### Go
### Go
```Go
var (
path []int
@@ -452,7 +460,7 @@ func dfs(n int, k int, start int) {
tmp := make([]int, k)
copy(tmp, path)
res = append(res, tmp)
return
return
}
for i := start; i <= n; i++ { // 从start开始，不往回走，避免出现重复组合
if n - i + 1 < k - len(path) { // 剪枝
@@ -465,9 +473,10 @@ func dfs(n int, k int, start int) {
}
```
### javascript
### javascript
剪枝：
```javascript
let result = []
let path = []
@@ -536,6 +545,7 @@ impl Solution {
```
剪枝
```Rust
impl Solution {
fn backtracking(result: &mut Vec<Vec<i32>>, path: &mut Vec<i32>, n: i32, k: i32, start_index: i32) {
@@ -561,6 +571,7 @@ impl Solution {
```
### C
```c
int* path;
int pathTop;
@@ -615,6 +626,7 @@ int** combine(int n, int k, int* returnSize, int** returnColumnSizes){
```
剪枝：
```c
int* path;
int pathTop;
@@ -701,13 +713,14 @@ func combine(_ n: Int, _ k: Int) -> [[Int]] {
### Scala
暴力:
```scala
object Solution {
import scala.collection.mutable // 导包
def combine(n: Int, k: Int): List[List[Int]] = {
var result = mutable.ListBuffer[List[Int]]() // 存放结果集
var path = mutable.ListBuffer[Int]() //存放符合条件的结果
def backtracking(n: Int, k: Int, startIndex: Int): Unit = {
if (path.size == k) {
// 如果path的size == k就达到题目要求，添加到结果集，并返回
@@ -720,7 +733,7 @@ object Solution {
path = path.take(path.size - 1) // 回溯完再删除掉刚刚添加的数字
}
}
backtracking(n, k, 1) // 执行回溯
result.toList // 最终返回result的List形式，return关键字可以省略
}
@@ -743,7 +756,7 @@ object Solution {
return
}
// 剪枝优化
for (i <- startIndex to (n - (k - path.size) + 1)) {
for (i <- startIndex to (n - (k - path.size) + 1)) {
path.append(i) // 先把数字添加进去
backtracking(n, k, i + 1) // 进行下一步回溯
path = path.take(path.size - 1) // 回溯完再删除掉刚刚添加的数字