Combination Sum系列问题

组合求和问题解析

最新推荐文章于 2021-06-28 17:26:07 发布

原创最新推荐文章于 2021-06-28 17:26:07 发布 · 433 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #backtracking #DP

算法刷题专栏收录该内容

69 篇文章

订阅专栏

本文详细探讨了四种不同类型的组合求和问题，包括无重复数字的候选集组合、含有重复数字的候选集组合、限定数量的数字组合以及求组合总数等问题，并提供了相应的代码实现。

这系列一共有四个问题

问题一：给出一个没有重复数字的候选集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];
    }
};