LeetCode 39 组合总和 题解

题目大意

给定一个包含无重复元素的数组candidates和一个目标数target，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。

分析

一个很直接的想法是使用深度优先搜索，因为每一个元素可以放入无限多次，所以我们在进行下一轮搜索的时候需要将当前元素继续考虑进去，而结束当前这个状态搜索的边界条件是target<0或者target=0或者target<candidates[depth]（target表示剩余需要从数组中拼凑的数）。

一种较慢的写法

vector<vector<int>> res;
void dfs(int depth, int target, vector<int> nums, vector<int> candidates) {
    if(target == 0) {
        res.push_back(nums);
        return;
    }
    if(depth >= candidates.size() || target < 0) {
        return;
    }
    for(int i = 0; i * candidates[depth] <= target; i++) {
        for(int j = 0; j < i; j++) {
            nums.push_back(candidates[depth]);
        }
        dfs(depth + 1, target - candidates[depth] * i, nums, candidates);
        for(int j = 0; j < i; j++) {
            nums.pop_back();
        }
    }
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
    vector<int> nums;
    nums.clear();
    res.clear();
    dfs(0, target, nums, candidates);
    return res;
}

我最初采用这个写法来做，在考虑到candidate[depth]将其所有可能出现的情况都通过一个for循环产生，这样写的时间和空间都比较差，但是也能通过，后来参考了一个网上的写法。

较快的写法

vector<int> nums;
vector<vector<int>> res;
void dfs(int i, vector<int> candidates, int target) {
    if(target == 0) {
        res.push_back(nums);
        return;
    }
    for(; i < candidates.size(); i++) {
        if(target >= candidates[i]) {
            nums.push_back(candidates[i]);
            dfs(i, candidates, target - candidates[i]);
            nums.pop_back();
        } else {
            break;
        }
    }
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
    sort(candidates.begin(), candidates.end());
    dfs(0, candidates, target);
    return res;
}

对两种实现的分析

我的想法与这个算法相同，只是他在每一层DFS搜索的时候只会放入一个元素，但是时间和空间占比就会小的很多，本来以为是由于排序的原因，因为排序会将很多大的数字放在后面，这样可以最大化的利用target<candidates[i]这个条件来剪枝，但实际测试差距并不大。

个人猜测是由于我的那种写法对nums的修改是通过for循环一次完成，而这种写法是迭代式的增加的，所以更为节约时间，另外他将nums作为了全局变量，这样在递归调用的时候也会节约一些栈上的空间。

这两种实现，算法本质上是相同的，但是因为一些细节问题，导致时间相差比较大。