力扣39题组合总和

力扣39题组合总和

题目描述

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

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

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

输入输出样式

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

输入: candidates = [2], target = 1
输出: []

解法一，使用回溯算法（while循环较难理解）

        vector<vector<int>>combinationSum(vector<int>&candidates,int target)
        {
            vector<vector<int>>resArray;
            vector<int>combine;
            dfs(candidates,target,resArray,combine,0);
            return resArray;
        }

//从后往前开始执行，不断迭代，直到末尾
        void dfs(vector<int>&candidates,int target,vector<vector<int>>&resArray,vector<int>&combine,int idx)
        {
            if(idx==candidates.size())
            {
                return;
            }
             if(target==0)
             {
                 //emplace_back 在容器的末尾添加一个 新的元素
                 resArray.emplace_back(combine);
                 return;
             }

            //迭代执行
            //idx指代当前迭代的下标
            dfs(candidates,target,resArray,combine,idx+1);

            if(target-candidates[idx]>=0)
            {
                combine.emplace_back(candidates[idx]);
                dfs(candidates,target-candidates[idx],resArray,combine,idx);
                combine.pop_back();
            }

        }

解法2，回溯算法+for循环，时间消耗短

        vector<vector<int>>combinationSum3(vector<int>&candidates,int target)
        {
            vector<vector<int>>resArray;
            vector<int>combine;

            // 对数组进行排序

            sort(candidates.begin(),candidates.end());

            //采用回溯
            backTrack(candidates,target,resArray,combine,0);
            return resArray;
        }

        void backTrack(vector<int>&candidates,int target,vector<vector<int>>&resArray,vector<int>&combine,int start)
        {   
            if(target==0)
            {
                resArray.push_back(combine);
                return;
            }

            for(int i=start;i<candidates.size();i++)
            {
                if(candidates[i]>target)
                {
                    return;
                }

                if(i>0&&candidates[i]==candidates[i-1])
                {
                    //剪枝操作
                    continue;
                }

                combine.push_back(candidates[i]);
                backTrack(candidates,target-candidates[i],resArray,combine,i);
                combine.pop_back();
            }
        }

解法3，动态规划

        vector<vector<int>>combinationSum2(vector<int>&candidates,int target)
        {
            vector<vector<vector<int>>>dp(target+1);

            for(auto &d:candidates)
            {
                for(int i=d;i<=target;i++)
                {
                    auto &cur=dp[i];
                    if(i==d)
                    {
                        cur.push_back({d});
                    }

                    else{
                        auto &pre=dp[i-d];
                        for(auto v:pre)
                        {
                            v.push_back(d);
                            cur.push_back(v);
                        }

                    }
                }
            }
            return dp[target];
        }