[Leetcode] 39. Combination Sum 解题报告

最新推荐文章于 2023-09-14 01:03:05 发布

魔豆Magicbean

最新推荐文章于 2023-09-14 01:03:05 发布

阅读量414

点赞数

CC 4.0 BY-SA版权

分类专栏： IT公司面试习题文章标签： Leetcode Combination Sum 解题报告 Array Backtracking

本文链接：https://blog.youkuaiyun.com/magicbean2/article/details/53974598

IT公司面试习题专栏收录该内容

736 篇文章

订阅专栏

本文介绍了一种经典的回溯算法应用——组合求和问题。针对给定的候选数集合及目标值，寻找所有可能的组合使得这些数相加等于目标值。文章提供了两种实现方案并对比了它们的性能差异。

题目：

Given a set of candidate numbers (C) (without duplicates) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

All numbers (including target) will be positive integers.
The solution set must not contain duplicate combinations.

For example, given candidate set [2, 3, 6, 7] and target 7,
A solution set is:

[
  [7],
  [2, 2, 3]
]

思路：

凡是需要返回所有可行解的题目，99%都是需要用到回溯法的。但是回溯方式的不同可能造成运行效率的巨大差异。一般而言，对于计算的中间结果（例如本题目中的vector<int>类型的变量line），如果能用引用就尽量用引用，这样效率可以大大提高。

代码：

1、采用引用的方式实现（12ms）：

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) 
    {
        vector<vector<int>> ret;
        vector<int> line;
        sort(candidates.begin(), candidates.end());
        combination(candidates, target, ret, line);
        return ret;
    }
private:
    void combination(vector<int>& candidates, int target, 
        vector<vector<int>>& ret, vector<int>& line)
    {
        if(target == 0)
        {
            ret.push_back(line);
            return;     //  we should return for the back-tracking
        }
        
        for(int i = 0; i < candidates.size(); ++i)
        {
            if(candidates[i] > target)
                break;
                
            // make sure no smaller integers are added later
            if(line.size() > 0 && candidates[i] < line[line.size() - 1])
                continue;
                
            line.push_back(candidates[i]);
            combination(candidates, target - candidates[i], ret, line);
            line.pop_back();
        }
    }
};

2、采用非引用的方式实现（52ms）：

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ret;
        vector<int> line;
        combination(candidates, target, ret, line, 0);
        return ret;
    }
private:
    void combination(vector<int>& candidates, int target, vector<vector<int>> &ret,
        vector<int> line, int index)
    {
        if(target == 0)
            ret.push_back(line);
        if(index >= candidates.size() || target <= 0)
            return;
        combination(candidates, target, ret, line, index + 1);      // include 0 candidates[index]
        for(int i = 1; target - i * candidates[index] >= 0; ++i)    // include i candidates[index]
        {
            line.push_back(candidates[index]);
            combination(candidates, target - i * candidates[index], ret, line, index + 1);
        }
    }
};