【C++代码】组合123，回溯，剪枝--代码随想录

• 回溯法也可以叫做回溯搜索法，它是一种搜索的方式。回溯是递归的副产品，只要有递归就会有回溯。所以以下讲解中，回溯函数也就是递归函数，指的都是一个函数。因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。
• 回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。

题目：组合

• 在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。函数里一定有两个参数，既然是集合n里面取k个数，那么n和k是两个int型的参数。

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

• 回溯法虽然是暴力搜索，但也有时候可以有点剪枝优化一下的。来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

• 

• 如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

•  for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) { // 优化的地方
       path.push_back(i); // 处理节点
       backtracking(n, k, i + 1);
       path.pop_back(); // 回溯，撤销处理的节点
  }
  

题目：组合总和 III

• 找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：只使用数字1到9；每个数字 最多使用一次 。返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

• lass Solution {
  public:
      vector<vector<int>> res;
      vector<int> path;
      void track(int target,int k,int sum,int start){
          if(sum>target){
              return;
          }
          if(path.size()==k){
              if(sum==target){
                  res.push_back(path);
              }
              return;
          }
          for(int i=start;i<=9-(k-path.size())+1;i++){
              sum += i;
              path.push_back(i);
              track(target,k,sum,i+1);
              sum -= i;
              path.pop_back();
          }
      }
      vector<vector<int>> combinationSum3(int k, int n) {
          track(n,k,0,1);
          return res;
      }
  };
  

题目：电话号码的字母组合

• 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

• 可以使用map或者定义一个二维数组，例如：string letterMap[10]，来做映射。

• 

• 图中可以看出遍历的深度，就是输入"23"的长度，而叶子节点就是我们要收集的结果，输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]。

• class Solution {
  public:
      const string lettermap[10]={
          "",
          "",
          "abc",
          "def",
          "ghi",
          "jkl",
          "mno",
          "pqrs",
          "tuv",
          "wxyz"
      };
      vector<string> res;
      string s;
      void track(const string &digits,int index){
          if(index == digits.size()){
              res.push_back(s);
              return;
          }
          int digit = digits[index]-'0';
          string le = lettermap[digit];
          for(int i=0;i<le.size();i++){
              s.push_back(le[i]);
              track(digits,index+1);
              s.pop_back();
          }
      }
      vector<string> letterCombinations(string digits) {
          s.clear();
          res.clear();
          if(digits.size()==0) return res;
          track(digits,0);
          return res;
      }
  };
  

• 回溯是递归的副产品，只要有递归就会有回溯。回溯法就是暴力搜索，并不是什么高效的算法，最多在剪枝一下。回溯法抽象为树形结构后，其遍历过程就是：for循环横向遍历，递归纵向遍历，回溯不断调整结果集。

题目：组合总和

• 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为 target 的不同组合数少于 150 个。

• class Solution {
  public:
      vector<vector<int>> res;
      vector<int> path;
      void track(int target,vector<int> &con,int sum,int start){
          if(sum==target){
              res.push_back(path);
              return ;
          }
          for(int i=start;i<con.size()&&sum+con[i]<=target;i++){
              sum+=con[i];
              path.push_back(con[i]);
              track(target,con,sum,i);// 不用i+1了，表示可以重复读取当前的数
              sum-=con[i];
              path.pop_back();
          }
      }
      vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
          res.clear();
          path.clear();
          sort(candidates.begin(),candidates.end());
          track(target,candidates,0,0);
          return res;
          
      }
  };
  

• 时间复杂度: $O(n\ast 2^n)$，注意这只是复杂度的上界，因为剪枝的存在，真实的时间复杂度远小于此；空间复杂度: O(target)

• 

题目：组合总和 II

• 给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用 一次 。

• class Solution {
  public:
      vector<vector<int>> res;
      vector<int> path;
      void track(vector<int> &can,int target,int sum,int start){
          if(sum==target){
              res.push_back(path);
              return;
          }
          for(int i= start;i<can.size()&& sum+can[i]<=target;i++){
              if(i>start&&can[i]==can[i-1]){
                  continue;
              }
              sum += can[i];
              path.push_back(can[i]);
              track(can,target,sum,i+1);
              path.pop_back();
              sum-=can[i];
          }
      }
      vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
          sort(candidates.begin(),candidates.end());
          track(candidates,target,0,0);
          return res;
      }
  };
  

ombinationSum2(vector& candidates, int target) {
sort(candidates.begin(),candidates.end());
track(candidates,target,0,0);
return res;
}
};