Algorithm：组合总和

Algorithm：组合总和

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

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

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

示例 1：

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

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

输入: candidates = [2], target = 1
输出: []
示例 4：

输入: candidates = [1], target = 1
输出: [[1]]
示例 5：

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

提示：

1 <= candidates.length <= 30
1 <= candidates[i] <= 200
candidate 中的每个元素都 互不相同
1 <= target <= 500

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/combination-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    struct combinationData
    {
        int sum;
        map data;
    };

public:
    vector> combinationSum(vector& candidates, int target) {
        vector> result;
        vector record;
        vector> recordM;

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

        for(int i = 0; i < candidates.size(); i++)
        {
            if(candidates[i] < target)
            {
                combinationData comData;
                comData.sum = candidates[i];
                comData.data[candidates[i]] = 1;
                record.push_back(comData);
            }
            else if(candidates[i] == target)
            {
                result.push_back({candidates[i]});
            }
            else
            {
                break;
            }
        }

        for(int i = 0; i < record.size(); )
        {
            for(int j = 0; j < candidates.size(); j++)
            {
                combinationData comData = record[i];
                int sum_ = candidates[j] + comData.sum;

                if(sum_ <= target)
                {
                    if(comData.data.find(candidates[j]) == comData.data.end())
                    {
                        comData.data[candidates[j]] = 1;
                    }
                    else
                    {
                        comData.data[candidates[j]]++;
                    }

                    comData.sum = sum_;

                    if(sum_ == target)
                    {
                        bool isFind = false;
                        for(auto const & obj : recordM)
                        {
                            if(obj == comData.data)
                            {
                                isFind = true;
                                break;
                            }
                        }

                        if(!isFind)
                        {
                            recordM.push_back(comData.data);
                            vector _data;

                            for(auto it = comData.data.begin(); it != comData.data.end(); ++it)
                            {
                                _data.insert(_data.end(), it->second, it->first);
                            }

                            result.push_back(_data);
                        }

                        break;
                    }
                    else
                    {
                        record.push_back(comData);
                    }
                }
            }

            record.erase(record.begin() + i);
        }

        return result;
    }
};

改进一下，后面不要erase。 

class Solution {
    struct combinationData
    {
        int sum;
        map data;
    };

public:
    vector> combinationSum(vector& candidates, int target) {
        vector> result;
        vector record;
        vector> recordM;

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

        for(int i = 0; i < candidates.size(); i++)
        {
            if(candidates[i] < target)
            {
                combinationData comData;
                comData.sum = candidates[i];
                comData.data[candidates[i]] = 1;
                record.push_back(comData);
            }
            else if(candidates[i] == target)
            {
                result.push_back({candidates[i]});
            }
            else
            {
                break;
            }
        }

        for(int i = 0; i < record.size(); i++)
        {
            for(int j = 0; j < candidates.size(); j++)
            {
                combinationData comData = record[i];
                int sum_ = candidates[j] + comData.sum;

                if(sum_ <= target)
                {
                    if(comData.data.find(candidates[j]) == comData.data.end())
                    {
                        comData.data[candidates[j]] = 1;
                    }
                    else
                    {
                        comData.data[candidates[j]]++;
                    }

                    comData.sum = sum_;

                    if(sum_ == target)
                    {
                        bool isFind = false;
                        for(auto const & obj : recordM)
                        {
                            if(obj == comData.data)
                            {
                                isFind = true;
                                break;
                            }
                        }

                        if(!isFind)
                        {
                            recordM.push_back(comData.data);
                            vector _data;

                            for(auto it = comData.data.begin(); it != comData.data.end(); ++it)
                            {
                                _data.insert(_data.end(), it->second, it->first);
                            }

                            result.push_back(_data);
                        }

                        break;
                    }
                    else
                    {
                        record.push_back(comData);
                    }
                }
                else
				{
					break;
				}
            }

            //record.erase(record.begin() + i);
        }

        return result;
    }
};

接下来，用递归试一下。