Combination Sum求和为给定值的所有序列的解题思路

因为数字可以重复，毫无疑问，这道题要用回溯来解。写出代码不难如下：

class Solution {public:    vector<vector<int> > rec_combinationSum(vector<int> &candidates, int target) {        vector<vector<int>> res;        if(target==0){        res.push_back(vector<int>());        return res;        }                int tar = target;        for(auto c:candidates){            target -=c;            if(target<0){target +=c;continue;}            auto vv = rec_combinationSum(candidates,target);            for(auto vec:vv){                if(accumulate(vec.begin(),vec.end(),c) == tar) {                    vec.push_back(c);                    sort(vec.begin(),vec.end());                    res.push_back(vec);                }            }            target +=c;        }        return res;    }    vector<vector<int> > combinationSum(vector<int> &candidates, int target){    vector<vector<int>> res;    if(candidates.size()==0) return res;    sort(candidates.begin(),candidates.end());    res = rec_combinationSum(candidates,target);    sort(res.begin(),res.end());        auto it=unique(res.begin(),res.end());        res.resize(distance(res.begin(),it));            return res;    }};

但是，有一个问题就是运行速度很慢，在Leetcode168个测试用例上出现了TLE，这是回溯需要解决的问题。如果先不考虑剪枝，是不是因为代码中大量的排序导致变慢呢？每次计算得到一个结果都要排序，而且还有不少重复的。如果用set或者unordered_set来存储是否可以搞定呢？要为unordered_set<vector<int>>写一个hash函数类，因为vector<int>不是基本基本类型，代码如下：

class MyHash{public:    size_t operator()(const vector<int> &v) const    {        size_t x = 0;        for (auto &i : v)            x ^= std::hash<int>()(i);        return x;    }};class Solution {public:    unordered_set<vector<int>,MyHash > rec_combinationSum(vector<int> &candidates, int target) {        unordered_set<vector<int>,MyHash> res;        if(target==0){        res.insert(vector<int>());        return res;        }                int tar = target;        for(auto c:candidates){            target -=c;            if(target<0){target +=c;continue;}            auto vv = rec_combinationSum(candidates,target);            for(auto vec:vv){                if(accumulate(vec.begin(),vec.end(),c) == tar) {                    vec.push_back(c);                    sort(vec.begin(),vec.end());                    res.insert(vec);                }            }            target +=c;        }        return res;    }    vector<vector<int> > combinationSum(vector<int> &candidates, int target){    unordered_set<vector<int>,MyHash> tmp;    vector<vector<int> > res;    if(candidates.size()==0) return res;    sort(candidates.begin(),candidates.end());    tmp = rec_combinationSum(candidates,target);        for(auto vec:tmp)    res.push_back(vec);            return res;    }};

结果发现仍然是TLE，这里虽然省去了排序，去重，理论上插入还是线性，但仍然不行。看来数据结构上的优化无法帮助解决本TLE问题。
下面只能考虑剪枝了。怎么剪？这个问题有什么特点？
正常情况下，当选定一个数字之后，下面仍然要把每个数字都再考虑一遍；有没有一种方法，某个数字的情况考虑完之后就不再考虑该数字出现的情况？存在不存在？答案是存在，那就是要对数列进行排序，排序之后，我们发现如果某个数字考虑过，则包含该数字的所有情况，包括重复的情况都在回溯的过程中考虑了。所以之后，就不必再考虑该种情况了，此处可剪枝。

class Solution {public:    vector<vector<int>> rec_combinationSum(vector<int> &candidates, int target,int idx) {        vector<vector<int>> res;        if(target==0){        res.push_back(vector<int>());        return res;        }                int tar = target;        for(int i=idx;i<candidates.size();++i){            target -=candidates[i];            if(target<0){target +=candidates[i];continue;}            auto vv = rec_combinationSum(candidates,target,i);            for(auto vec:vv){                if(accumulate(vec.begin(),vec.end(),candidates[i]) == tar) {                    vec.push_back(candidates[i]);                    sort(vec.begin(),vec.end());                    res.push_back(vec);                }            }            target +=candidates[i];        }        return res;    }    vector<vector<int> > combinationSum(vector<int> &candidates, int target){    vector<vector<int> > res;    if(candidates.size()==0) return res;    sort(candidates.begin(),candidates.end());    res = rec_combinationSum(candidates,target,0);            return res;    }};

增加了一个参数，该参数保存当前访问的数值，考虑完之后不再考虑之前的所有元素而是从下一个开始，达到了剪枝的目的。速度大概是108ms，仍然不佳。