2021.8.4 力扣-组合总和

题目描述：

给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。

candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。 

对于给定的输入，保证和为 target 的唯一组合数少于 150 个。

方法一：

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> mycan;
    int mytar , n;
    void DFS(int index , int sum , vector<int> combine)
    {
        if(index == n)
        {
            return;
        }
        if(sum==mytar)
        {
            ans.push_back(combine);
            return;
        }
        DFS(index+1 , sum , combine);       //跳过第index个数
        if(sum+mycan[index] > mytar)
        {
            return ;
        }
        combine.push_back(mycan[index]);
        DFS(index , sum+mycan[index] , combine);    //选择第index个数
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin() , candidates.end());
        mycan = candidates;
        mytar = target;
        n = candidates.size();
        vector<int> combine;        //记录过程中选择的数字
        DFS(0 , 0 , combine);
        return ans;
    }
};

自己写回溯实在写不出来，看了看官方的题解做法。 

正如官方题解所说“对于这类寻找所有可行解的问题，我们都可以使用‘搜索回溯’的方法来解决”。

但速度实在有点慢，需要112ms

方法二： 

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> mycan;
    int mytar , n;
    void DFS(int index , int sum , vector<int>& combine)
    {
        if(index == n)
        {
            return;
        }
        if(sum==mytar)
        {
            ans.push_back(combine);
            return;
        }
        for(int i=index ; i<n ; i++)
        //这里i初始值为index，说明同一个数字可以被选中多次，如果初始值为index+1，就说明不能有重复数字
        {
            if(sum+mycan[i] <= mytar)
            {
                combine.push_back(mycan[i]);
                sum+=mycan[i];
                DFS(i , sum , combine);
                combine.pop_back();
                sum-=mycan[i];
            }
            else
            {break;}    //因为mycan数组是升序的，i不符合，则后续的也不符合
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin() , candidates.end());
        mycan = candidates;
        mytar = target;
        n = candidates.size();
        vector<int> combine;        //记录过程中选择的数字
        DFS(0 , 0 , combine);
        return ans;
    }
};

 对比方法一，用for循环将是否选中下标为index元素的两种情况整合到一起，这样比方法一更快，时间为12ms

方法二的改良：

class Solution {
public:
    void DFS(int index , int sum , vector<int>& combine ,vector<vector<int>>& ans , vector<int>& mycan , int mytar , int n)
    {
        if(index == n)
        {
            return;
        }
        if(sum==mytar)
        {
            ans.push_back(combine);
            return;
        }
        for(int i=index ; i<n ; i++)
        //这里i初始值为index，说明同一个数字可以被选中多次，如果初始值为index+1，就说明不能有重复数字
        {
            if(sum+mycan[i] <= mytar)
            {
                combine.push_back(mycan[i]);
                sum+=mycan[i];
                DFS(i , sum , combine , ans , mycan , mytar , n);
                combine.pop_back();
                sum-=mycan[i];
            }
            else
            {break;}    //因为mycan数组是升序的，i不符合，则后续的也不符合
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        //vector<int> mycan;
        //int mytar , n;
        sort(candidates.begin() , candidates.end());
        //mycan = candidates;
        //mytar = target;
        int n = candidates.size();
        vector<int> combine;        //记录过程中选择的数字
        DFS(0 , 0 , combine , ans , candidates , target , n);
        return ans;
    }
};

对比了一下别人的解法，发现对于ans、mycan、mytar、n这样的量，将其直接作为参数传递会进一步提高速度，这时只需用4ms即可