【代码随想录】回溯问题之组合

前言

更详细的在大佬的代码随想录 (programmercarl.com)

本系列仅是简洁版笔记，为了之后方便观看

解决的类型问题

组合无序，排列有序

1. 组合
2. 切割
3. 子集
4. 排列（强调元素的顺序）
5. 棋牌问题（n皇后，数独）

回溯法的三个步骤 

1. 递归函数参数/返回值
2.  终止条件
3. 单层递归逻辑

去重词汇 

1. 树层去重
2. 树枝去重

模版

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (遍历结点) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

组合

 77. 组合 - 力扣（LeetCode）

class Solution {
    private:
    vector<vector<int>> result;
    vector<int>path;
    void backtracking(int n,int k,int a)//a表示递归的层数
    {
      if(path.size()==k)
      {
        result.push_back(path);
        return;
      }
      for(int i=a;i<=n;i++)
      {
            path.push_back(i); 
            backtracking(n, k, i + 1); 
            path.pop_back(); 
      }
    }
public:
    vector<vector<int>> combine(int n, int k) {
      backtracking(n,k,1);
      return result;
    }
};

 剪枝思路：从for循环开始的起始位置之后选择的元素个数不足需要的元素个数时，无需继续搜索

for (int i = a; i <= n - (k - path.size()) + 1; i++)

组合总和III

 和上一题整体模版是一样的，主要是多了sum的处理和sum的回溯 

216. 组合总和 III - 力扣（LeetCode）

class Solution {
private:
    vector<vector<int>>result;
    vector<int>path;
   void backtracking(int target,int k,int sum,int startIndex)
  {
    if(sum>target)
    {
        return;
    }
    if(path.size()==k)
    {
        if(sum==target)
        result.push_back(path);
        return ;
    }
    for(int i=startIndex;i<=9-(k-path.size())+1;i++)
    {
            sum += i; // 处理
            path.push_back(i); // 处理
            backtracking(target, k, sum, i + 1); // 注意i+1调整startIndex
            sum -= i; // 回溯
            path.pop_back(); // 回溯
    }
  }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear(); // 可以不加
        path.clear();   // 可以不加
        backtracking(n, k, 0, 1);
        return result;
    }
};

电话号码的字母组合

17. 电话号码的字母组合 - 力扣（LeetCode）

1.用二维数组来做一个映射

2.对比发现隐藏的回溯

for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            
            backtracking(digits, index + 1);    
            s.pop_back();                      
        }

for (int i = 0; i < letters.size(); i++) {
            getCombinations(digits, index + 1, s + letters[i]);  
// void getCombinations(const string& digits, int index, const string& s)
        }

第二个是进入到下一层计算了，但是s没有变化，所以就相当于回溯了

class Solution {
private:
    const string letterMap[10]={
        //逐个映射
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz"//9
    };
public:
    vector<string>result;
    string s;
    void backtracking(const string&digits,int index)
    {
       if (index == digits.size()) {
            result.push_back(s);
            return;
        }
        int digit=digits[index] - '0';//依次遍历数字
        string letters = letterMap[digit]; //寻找该位置对应的字符串     
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);            
            backtracking(digits, index + 1);    
            s.pop_back();                       
        }

    }
    vector<string> letterCombinations(string digits) {
        s.clear();
        result.clear();
        if (digits.size() == 0) {
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

组合总和

39. 组合总和 - 力扣（LeetCode）

1.和之前的组合总和最大的差别就是已经选取过的元素还可以再选取 

2.startIndex的作用是：每一次遍历开始的位置，使求出来的组合没有重复元素，例如组合23和组合32

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum == target) {
            result.push_back(path);
            return;
        } 
  for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
          sum += candidates[i];
          path.push_back(candidates[i]);
          backtracking(candidates, target, sum, i);//这儿不用i+1的原因是因为可以重复使用某个数字
          sum -= candidates[i];//回溯
          path.pop_back();

        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(), candidates.end()); //从小到大排序，如果组合和大于所要求的值，则后面的数必定大于所要求的值
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

 组合总和II

原数组有重复元素但结果不能有重复的组合（进行去重操作）

40. 组合总和 II - 力扣（LeetCode）

1.排序的原因：把相邻元素放在一起

2.本题去重关键：

树层去重，如果该层已经取过1了，那么它的同一层就不需要再取了，因为前面的1已经包含了1的所有组合（目的：没有重复的元素组合）

原数组有重复元素

树枝去重是没有必要的，因为一条链上本来就可以取得组合中的所有元素，也包括重复的元素（比如果该集合中有两个1，就可以同时取两个1）

3.相比上一题就是多了个used数组来记录该元素是否被使用过

4.used[i - 1] == false 表示，在同一树层上取的 candidates[i] 是从 candidates[i - 1] 回溯而来的，如果 used[i - 1] == true，就说明是进入下一层递归，去下一个数，就进行树枝上的深入

used[i - 1] == true，说明同一树枝candidates[i - 1]使用过（说明同一条链被用过）
used[i - 1] == false，说明同一树层candidates[i - 1]使用过

5.重点回溯代码

if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
                continue;
            }