【LeetCode从零单刷】Combinations & Combination Sum 系列

题目：

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

解答：

排列组合类型的问题，一般都是利用回溯法。关于回溯法的要点，在这篇文章里面说的已经很清楚了：传送门

1. 每次只递归一步，绝不多一步。这个和递归法是相同的道理； 
2. 只有最底层负责存入结果，存入一个脱离于函数的全局内存； 
3. 层与层之间，不再传递数据（因为回溯的答案不止一个，每层处理去重没必要，交给最底层存入）。但是每层必须有 return 返回上层，否则函数无法终止），return 一个空值

class Solution {
public:
    vector<vector<int>> ans;
    
    void insert(int start, int end, int bit, vector<int> cur)
    {
        if(bit == 0)
        {
            ans.push_back(cur);
            return;
        }
        
        for(int i=start; i<= end - bit + 1; i++)
        {
            vector<int> tmp(cur);
            tmp.push_back(i);
            insert(i+1, end, bit-1, tmp);
        }
        return;
    }
    
    vector<vector<int>> combine(int n, int k) {
        vector<int> tmp;
        insert(1, n, k, tmp);
        return ans;
    }
};

另外还有三道类似的题目：Combination Sum，Combination Sum II，Combination Sum III

套路都是一样的。不过需要先排序，第一题可以选择重复元素，这样回溯的起点还是当前起点；第二题不可以选择重复元素，回溯起点就是当前起点下一个；第三题还有多出来的位数限制。

Combination Sum I：

class Solution {
public:
    vector<vector<int>> ans;
        
    void combination(vector<int> cur, int target, vector<int> candidates, int start)
    {
        int cursize = cur.size();
        int size = candidates.size();
        int cursum = 0;
        for(int i=0; i<cursize; i++)   cursum += cur[i];
        
        for(int i = start; i < size; i++)
        {
            vector<int> tmp = cur;
            if(cursum + candidates[i] == target)
            {
                tmp.push_back(candidates[i]);
                ans.push_back(tmp);
                break;
            }
            else if(cursum + candidates[i] < target)
            {
                tmp.push_back(candidates[i]);
                combination(tmp, target, candidates, i);
            }
            else break;
        }
        return;
    }
    
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<int> cur;
        sort(candidates.begin(), candidates.end());
        combination(cur, target, candidates, 0);
        return ans;
    }
};

Combination Sum II：

class Solution {
public:
    set<vector<int>> tmpans;
        
    void combination(vector<int> cur, int target, vector<int> candidates, int start)
    {
        int cursize = cur.size();
        int size = candidates.size();
        int cursum = 0;
        for(int i=0; i<cursize; i++)   cursum += cur[i];
        
        for(int i = start; i < size; i++)
        {
            vector<int> tmp = cur;
            if(cursum + candidates[i] == target)
            {
                tmp.push_back(candidates[i]);
                tmpans.insert(tmp);
                break;
            }
            else if(cursum + candidates[i] < target)
            {
                tmp.push_back(candidates[i]);
                combination(tmp, target, candidates, i+1);
            }
            else break;
        }
        return;
    }
    
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<int> cur;
        sort(candidates.begin(), candidates.end());
        combination(cur, target, candidates, 0);
        
        vector<vector<int>> ans(tmpans.begin(), tmpans.end());
        return ans;
    }
};

Combination Sum III：

class Solution {
public:
    vector<vector<int>> ans;
    
    void combination(int k, int n, vector<int> cur, int start, int bit)
    {
        if(k < bit) return;
        
        int cursize = cur.size();
        int cursum = 0;
        for(int i=0; i<cursize; i++) cursum += cur[i];
        
        vector<int> tmp;
        for(int i = start + 1; i <= 9; i++)
        {
            if (cursum + i == n && k == bit + 1)
            {
                tmp = cur;
                tmp.push_back(i);
                ans.push_back(tmp);
                break;
            }
            else if (cursum + i < n && k > bit)
            {
                tmp = cur;
                tmp.push_back(i);
                combination(k, n, tmp, i, bit + 1);
            }
            else break;
        }
        return;
    }
    
    vector<vector<int>> combinationSum3(int k, int n) {
        vector<int> cur;
        combination(k, n, cur, 0, 0);
        return ans;
    }
};