LeetCode | Combination Sum & II & III

1、题目描述

A：Combination Sum
https://leetcode.com/problems/combination-sum/description/
B：Combination Sum II
https://leetcode.com/problems/combination-sum-ii/description/
C：Combination Sum III
https://leetcode.com/problems/combination-sum-iii/description/

组合数问题，给定和值target，求组合数的所有情况，其中：
A： 给定候选数组nums（允许元素重复），数值可以复用
B： 给定候选数组nums（允许元素重复），数值不可复用
C： 给定候选数范围1~9（元素不重复），数值不可复用，限定组合长度

2、解题思路

(1) 先保证是有序序列
(2) 写一个递归：每层递归把当前侯选值a逐个加入侯选集ans，同时将剩余候选集送入下层递归（target-a得到新target）；递归的出口target减到负（当前组合fail）或target减到0（当前组合success）
(3) 注意元素重复、数值复用、组合重复的处理

3、代码

A：在数值可复用的前提下，元素重复不起作用，因此跳过重复元素+进下层迭代时要包含上层侯选值a；

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& a, int target) {

        vector<vector<int>> rst;
        vector<int> ans;

        sumIter(a, rst, ans, 0, target);
        return rst;

    }

    void sumIter(vector<int> &a, vector<vector<int>> &rst, vector<int> &ans, int begin, int target){

        if(target < 0)
            return;
        else if(target == 0){
            rst.push_back(ans);
            return;
        }
        else{
            for(int i = begin; i < a.size(); i++){
                if(i > 0 && a[i] == a[i-1])  //跳过重复元素
                    continue;
                ans.push_back(a[i]);
                sumIter(a, rst, ans, i, target-a[i]); //把i包含在下层侯选中实现复用
                ans.pop_back();           
            }
        }
    }
};

B：出现元素重复时，(1)仅保证数值不可复用不能避免同一组合重复出现，(2)野蛮跳过重复元素又漏掉了例如[1,1,3,6]目标8的结果中[1,1,6]这样的情况
因此在每层迭代中第一个元素不做同值判断，从第二元素开始重复才跳过
例如[1(1),1(2),1(3)，6]目标8，得到[1(1),1(2),6]之后，就要跳过[1(1),1(3)..]、[1(2)..]、[1(3)]的情况

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& a, int target) {

        vector<vector<int>> rst;
        vector<int> ans;
        sort(a.begin(), a.end());
        sumIter(a, rst, ans, 0, target);
        return rst;
    }

    void sumIter(vector<int> &a, vector<vector<int>> &rst, vector<int> &ans, int begin, int target){

        if(target < 0)
            return;
        else if(target == 0){
            rst.push_back(ans);
            return;
        }
        else{
            for(int i = begin; i < a.size(); i++){
                if(i > begin && a[i]==a[i-1])  //本层第2个元素起才进行重复判断   
                    continue;                

                ans.push_back(a[i]);
                sumIter(a, rst, ans, i+1, target-a[i]);  //i不送进下层，关闭复用
                ans.pop_back();
            }
        }
    }
};

C：

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {

        vector<vector<int>> rst;
        vector<int> ans;
        int a[9] = {1,2,3,4,5,6,7,8,9}; //构造候选集数组

        sumIter(a, rst, ans, 0, n, k);
        return rst;
    }

    void sumIter(int *a, vector<vector<int>> &rst, vector<int> &ans, int begin, int target, int k){

        if(target < 0)
            return;
        else if(target == 0 && ans.size()==k){  //满足组合长度才输出
            rst.push_back(ans);
            return;
        }
        else{
            for(int i = begin; i < 9; i++){
                ans.push_back(a[i]);
                sumIter(a, rst, ans, i+1, target-a[i], k);
                ans.pop_back();
            }
        }
    }
};

改进，不构造候选集数组：

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {

        vector<vector<int>> rst;
        vector<int> ans;

        sumIter(rst, ans, n, k);
        return rst;
    }

    void sumIter(vector<vector<int>> &rst, vector<int> &ans, int target, int k){

        if(target < 0)
            return;
        else if(target == 0 && ans.size()==k){
            rst.push_back(ans);
            return;
        }
        else{

            for(int i = ans.empty()?1:ans.back()+1; i <=9; i++){ //这里
                ans.push_back(i);
                sumIter(rst, ans, target-i, k);
                ans.pop_back();
            }
        }
    }
};