Combination Sum系列问题

这系列一共有四个问题

问题一：给出一个没有重复数字的候选集C，给出一个和T，在候选集里面找出所有和为T的组合，C里面的数字可以选择无数次。（里面的所有数字都是正整数）

问题二：给出一个可能有重复数字的候选集C，给出一个和T，在候选集里面找出所有和为T的组合，C里面的数字只可以选择一次。（里面的所有数字都是正整数）

问题三：给出一个数字n，和个数k，找出k个1-9的数的和是n的所有组合

问题四：给出一个没有重复数字的候选集C，给出一个和T，在候选集里面找出所有和为T的组合总数，C里面的数字可以选择无数次。（里面的所有数字都是正整数）

进阶问题，如果候选集里面有负数的话怎么办，会对这个问题产生什么影响，需要在问题加上什么限制条件。关于这个问题，可以看一下

https://discuss.leetcode.com/topic/53553/what-if-negative-numbers-are-allowed-in-the-given-array/7

问题一：直接回溯，只是注意代码里startInd的问题，因为解集要求没有重复的组合，[2, 3, 6, 7]和[3, 2, 6, 7]是一样的组合，递归的时候不会再遍历比上一个加入组合的数字还小的数字。https://discuss.leetcode.com/topic/41090/my-easy-understanding-dp-solution-c/2这里给出用DP的解答，暂时还没怎么看懂。

class Solution {public:    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {        vector<vector<int>> result;        vector<int> singleVec;        backTracking(result, singleVec, 0, target, candidates, 0);        return result;    }private:    void backTracking(vector<vector<int>> &resVec, vector<int> singleVec, int accumulativeSum, int target, vector<int> candidates, int startInd) {        if (accumulativeSum >= target) {            if (accumulativeSum == target) {                resVec.push_back(singleVec);            }            return;        }        for (int i = startInd; i < candidates.size(); i++) {            singleVec.push_back(candidates[i]);            accumulativeSum += candidates[i];            backTracking(resVec, singleVec, accumulativeSum, target, candidates, i);            singleVec.pop_back();            accumulativeSum -= candidates[i];        }    }};

问题二：也是回溯，但是注意候选集里可能存在重复数字的问题，当前迭代加入的数组在下一次迭代不应该再被考虑进去，因为重复的数字会导致产生一样的组合，跟题目要求
解集要求没有重复的组合相矛盾。这一处理见代码line26-28

class Solution {public:    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {        vector<vector<int>> resultVec;        vector<int> singleVec;        sort(candidates.begin(), candidates.end());        backTracking(resultVec, singleVec, 0, target, candidates, 0);        return resultVec;    }private:    void backTracking(vector<vector<int>> &resultVec, vector<int> singleVec, int accumulativeSum, int target, vector<int> candidates, int startInd) {        if (accumulativeSum >= target) {            if (accumulativeSum == target) {                resultVec.push_back(singleVec);            }            return;        }        while (startInd < candidates.size()) {            singleVec.push_back(candidates[startInd]);            accumulativeSum += candidates[startInd];            int iterInd = startInd;            iterInd++;            backTracking(resultVec, singleVec, accumulativeSum, target, candidates, iterInd);            singleVec.pop_back();            accumulativeSum -= candidates[startInd];            while (startInd + 1 < candidates.size() && candidates[startInd + 1] == candidates[startInd]) {                startInd++;            }            startInd++;        }    }};

问题三比问题一多了一个限制条件，个数k，还是用回溯，判断终止条件的时候要多加组合个数的判断。代码见line11-17

class Solution {public:    vector<vector<int>> combinationSum3(int k, int n) {        vector<vector<int>> resultVec;        vector<int> singleVec;        backTracking(resultVec, singleVec, 0, n, k, 1);        return resultVec;    }private:    void backTracking(vector<vector<int>> &resultVec, vector<int> singleVec, int accumulativeSum, int target, int num, int startInd) {        if (singleVec.size() > num || accumulativeSum > target) {            return;        }        if (singleVec.size() == num && accumulativeSum == target) {            resultVec.push_back(singleVec);            return;        }        for (int i = startInd; i <= 9; i++) {            singleVec.push_back(i);            accumulativeSum += i;            backTracking(resultVec, singleVec, accumulativeSum, target, num, i + 1);            singleVec.pop_back();            accumulativeSum -= i;        }    }};

问题四只是求组合有多少个，不要求求出组合，可以用回溯，也可以用DP，但是这里用backtracking感觉有点大材小用了。

简单分析一下，可以得到递归关系table[target] = (table[target - candidates[i]]) ----i=0-n(n是候选集的大小)

然后可以用一个表table，table[i]代表是和为i的组合数，一开始初始化整个table都为0，只有table[0]=1，从数组下标ind=1开始遍历，根据递归公式求出更新table[ind]的值，最后要求的是table[target]的值。

class Solution {public:    int combinationSum4(vector<int>& nums, int target) {        const int tableSize = target + 1;        int table[tableSize];        table[0] = 1;        for (int i = 1; i < tableSize; i++) {            table[i] = 0;        }        int startInd = 1;        while (startInd < tableSize) {            for (int i = 0; i < nums.size(); i++) {                if (startInd - nums[i] >= 0) {                    table[startInd] += table[startInd - nums[i]];                }            }            startInd++;        }        return table[target];    }};