【随想录】-【8 回溯算法】【组合问题】77 组合

重点：

（1）组合问题：N个数里面挑出满足条件的k个数；

（2）回溯法解决问题：组合问题，切割问题，子集问题，排列问题，棋盘问题；

（3）for循环分布：背包内物品外组合，背包外物品内排列；

（4）注意判断递归深度和宽度各代表什么。对于此问题，每次从startIndex开始，到n结束；

（5）注意剪枝：当n-startIndex不够k-path.size时，可以提前停止；

77. 组合

难度中等1091

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

• 1 <= n <= 20
• 1 <= k <= n

解析：

比较经典的组合问题，从N个不同的数里面挑出k个，也没有额外的限制条件。

根据我们的分析，树的宽度为集合中元素个数，即n；深度为递归层数，就是k。

当n=100，k=20时，20层for循环，每个for循环有100种选择。

我们可以将问题抽象为以下这个图：

 用回溯法三部曲解决此题：

（1）确定函数参数及返回值

采用res二维数组记录所有可能的组合结果，采用path一维数组来保存每一次的结果；

vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果

返回值void，参数边写边加；

（2）终止条件：

找到k个数即可，那么就是集合path的长度等于k；

（3）单层递归逻辑

for的次数为100次，因为是不重复，所以每次要有开始startIndex，从这个开始，到最后一个结束，然后加入path，然后撤销回溯pop_back()。

代码：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
public:
    vector<vector<int>> combine(int n, int k) {
        backtracking(k,n,1);
        return res;
    }
    void backtracking(int k,int n,int start){
        if(path.size()==k){
            res.push_back(path);
            return;
        }
        for(int i=start;i<=n;i++){
            path.push_back(i);
            backtracking(k,n,i+1);
            path.pop_back();
        }
    }
};

进行剪枝时，要是判断剩下的n-startIndex元素个数不足k-path.size了，就说明这个可以提前停止：

class Solution {
private:
    vector<int> path;//普遍定义两个vector
    vector<vector<int>> res;
public:
    vector<vector<int>> combine(int n, int k) {
        backtracking(k,n,1);
        return res;
    }
    void backtracking(int k,int n,int start){//参数需要边写边加
        if(path.size()==k){//终止条件清楚判断
            res.push_back(path);
            return;
        }
        //理解每次for循环的开始和结尾
        for(int i=start;i<=n-k+path.size()+1;i++){//剪枝条件发生处
            path.push_back(i);
            backtracking(k,n,i+1);
            path.pop_back();//一定需要回溯
        }
    }
};