一：题目

二：上码

// class Solution {
// public:

//     vector<vector<int> > res;
//     vector<int> path;

//     void backtracking(int n,int k,int index){
        
//         if(path.size() == k){
//             res.push_back(path);
//             return;
//         }

//         for(int i = index; i <= n ; i++){

//             path.push_back(i);
//             backtracking(n,k,i+1);//每次往下递归的时候使不断缩小范围的
//             path.pop_back();//这里是处理每次递归到叶节点是时候 这时已经处理好一种可行解，那么就要为下一种
//                           // 可行解提供空间
//         }


//     }
//     vector<vector<int>> combine(int n, int k) {

//         /**
//         思路：1.经典回溯算法题，我们正常来思考这道题的时候 如果 k = 2,我们可能会用两层for循环来解决
//              但如果 k 一直往上增加 那么就要套k层循环 如此的话，是不合理的所以要用到递归回溯
//             2.这里选择的解的空间依然是 排列树 因为逐层往下的分支树木减少 
//                     （第一层 1 2 3 4） 
//                     （第二层 2 3 4）
//                     （第三层3 4）
//                     （第四层 4）
//             3.在这里我们选取for循环来遍历给定的容器里的元素，纵向是backstacking()递归寻求结果 到达叶
//                     节点 这里也就是递归结束的时候将结果存在另一个容器当中。
//             4.具体写码
//                 1>:递归函数的返回值和参数
//                     返回值:vector<vector<int> > res :用来存最后的结果
//                     vector<int> path ：用来存每次的求取的结果 
//                     backtracking(n,k,index):这里的 n 和 k就是题目中给出的参数
//                     需要注意的是 这里的 index 是需要记录我们每次的都是在不断缩小范围的      
//                 2>:回溯终止条件 
//                     当path.size() == k的时候这时容器中的元素已经装满了这是就是递归终止的条件
//                 3>:单层的搜索过层 即 for循环来遍历给定的容器里的元素，
//                     纵向是backstacking()递归寻求结果 到达叶节点  
//                  */
//               backtracking(n,k,1);
//               return res;
//     }
// };


class Solution {
public:
    vector<vector<int> >ans;
    vector<int> path;

    //这里参数 index 目的是逐渐缩小范围
    void backstracking(int n,int k,int index) {
        if(path.size() == k) {
            ans.push_back(path);
            return;
        }

        for(int i = index; i <= n; i++) {
            path.push_back(i);
            backstracking(n,k,i+1);
            path.pop_back();//这里体现回溯 我们遍历完一条路径 这时回溯去除刚装进去的结点 
                            //准备装入新的结点。
        }
    }

    vector<vector<int>> combine(int n, int k) {

        backstracking(n,k,1);
        return ans;       
    }
};

标签：index,leetcode77,组合,int,back,递归,vector,path
来源： https://blog.csdn.net/qq_48508278/article/details/122724573