36 数字组合（Combination Sum）

1 题目

题目：数字组合（Combination Sum）
描述：给定一个候选数字的集合 candidates 和一个目标值 target。 找到 candidates 中所有的和为 target 的组合。在同一个组合中, candidates 中的某个数字出现次数不限。

1. 所有数值 (包括 target ) 都是正整数.
2. 返回的每一个组合内的数字必须是非降序的.
3. 返回的所有组合之间可以是任意顺序.
4. 解集不能包含重复的组合.

lintcode题号——135，难度——medium

样例1：

输入: candidates = [2, 3, 6, 7], target = 7
输出: [[7], [2, 2, 3]]

样例2：

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

2 解决方案

2.1 思路

  首先为了防止结果重复，需要进行去重的步骤，可以先在原序列中去重，因为按照题意，[m,m,m,n]与[m,n]两个序列在题目中是等价的，也可以之后在递归过程中进行去重。
  每次从排好序的序列头取元素，可以对同一元素取多次，直到取出的组合和为目标值，需要遍历所有的可能，这样的操作能够想到使用深度优先搜索来解决问题。代码中注意递归的三要素（定义、拆解、出口）即可。

DFS常用于需要遍历出所有解的场景中，例如求所有子集、得到所有组合、全排列等经典问题。

2.2 图解

candidates = [2, 3, 6, 7], target = 7的情况下，深度优先搜索的图如下：

2.3 时间复杂度

  深度优先搜索的时间复杂度是逻辑图上的节点数（即所有元素的组合数，n个元素，每个元素都有取或不取两种可能，所以是2的n次方）与处理每个节点的耗时（for循环n次）的乘积，该题的算法的时间复杂度为O(2^n * n)。

深度优先搜索的时间复杂度计算没有通用的方式，只能根据具体题目计算，可以理解成看作答案个数与构造每个答案花费的时间的乘积。

2.4 空间复杂度

  使用了vector数据结构保存节点，算法的空间复杂度为O(n)。

3 源码

细节：

1. 去重有两种方式，在原序列中先去重，或者在dfs递归中判断条件跳过重复。
2. dfs过程中去重，该题在dfs内部判断时i != 0与i != startIndex都可行。

• i与0比较的意义是防止i-1越界，防止从原序列中获取的每个元素与上一个元素相同，完全等价于在原序列中去重。
• i与startIndex比较拥有更深的意义，它判断每层的非首元素和原序列前一个元素是否相同，首先是防止i-1越界，它能够防止同一层级中出现相同的元素，但不会禁止各个分支的第一个分叉（即i=startIndex）中出现与原序列前一个元素重复的元素。
• 在该题中使用i != 0更直观，但i != startIndex的情况更加通用，之后的题会用来处理同一层级出现相同元素的情况。

C++版本：

/**
* @param candidates: A list of integers
* @param target: An integer
* @return: A list of lists of integers
*/
vector<vector<int>> combinationSum(vector<int> &candidates, int target) {
    // write your code here
    vector<vector<int>> results;
    if (candidates.empty())
    {
        return results;
    }

    // 因为要求结果是不降序的，所以先对原序列排序
    sort(candidates.begin(), candidates.end());
    // 防止答案中有重复，先把序列中的重复值去除
    //vector<int> newCandidates = removeDuplicate(candidates);

    vector<int> path;
    dfs(candidates, path, 0, target, results);
    return results;
}

void dfs(vector<int> & candidates, vector<int> path, int startIndex, int remainTarget, vector<vector<int>> & results)
{
    if (remainTarget == 0)
    {
        results.push_back(path);
        return;
    }

    for (int i = startIndex; i < candidates.size(); i++)
    {
        // 如果序列中有重复的数，则跳过，防止结果产生重复，i!=0为了防止i-1越界（也可以在原序列中先去重）
        if (i != 0 /*startIndex*/ && candidates.at(i) == candidates.at(i - 1))
        {
            continue;
        }

        // 结果超过目标值，则停止，防止后续的无效搜索
        if (remainTarget < candidates.at(i))
        {
            break;
        }

        path.push_back(candidates.at(i));
        // 可以重复取同一个值，所以递归依然从i开始，而不是i+1
        dfs(candidates, path, i, remainTarget - candidates.at(i), results);
        path.pop_back();
    }
}

//vector<int> removeDuplicate(vector<int> & candidates)
//{
//    int index = 0;
//    for (int i = 1; i < candidates.size(); i++)
//    {
//        if (candidates.at(index) != candidates.at(i))
//        {
//            candidates.at(++index) = candidates.at(i);
//        }
//    }

//    vector<int> result;
//    result.insert(result.end(), candidates.begin(), candidates.begin() + index + 1);
//    return result;
//}