LeetCode - 。39、全組成物

所与の非反復要素アレイのcandidatesターゲット番号target、検索candidatesすべての数およびを可能にするtarget組み合わせ。

candidates 選択された数は無制限繰り返すことができます。

説明：

• （を含むすべての数値target）は、正の整数です。
• ソリューションセットは、その重複した組み合わせを含めることはできません。

例1：

输入: candidates = [2,3,6,7], target = 7,
所求解集为:
[
  [7],
  [2,2,3]
]

例2：

输入: candidates = [2,3,5], target = 8,
所求解集为:
[
  [2,2,2,2],
  [2,3,3],
  [3,5]
]

再帰関数

ここでは、3の新しい変数に参加するとき、インデックスに現在の再帰の記録を開始し、溶液から、すべてのソリューションの保存解像度が得られている、新しい再帰関数を呼び出すたびに、ターゲットは、現在の配列を引く必要があります次のように番号、特定のコードを参照してください。

C ++

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> res;
        vector<int> out;
        combinationSumDFS(candidates, target, 0, out, res);
        return res;
    }
    void combinationSumDFS(vector<int>& candidates, int target, int start, vector<int>& out, vector<vector<int>>& res) {
        if (target < 0) return;
        if (target == 0) {res.push_back(out); return;}
        for (int i = start; i < candidates.size(); ++i) {
            out.push_back(candidates[i]);
            combinationSumDFS(candidates, target - candidates[i], i, out, res);
            out.pop_back();
        }
    }
};

再帰的な改善

オーダーを超える行が、ターゲットの後に作ることができないので、我々は数が現在のターゲットよりも大きい場合、その反復は、確かに、ターゲットの組成を説明していない追加機能再帰関数で完了するために、または最初の配列をソートするためには使用できません。直接抜け出します。数が現在のターゲットに正確に等しい場合、現在の番号は、単一の溶液で、次いでRESの配列組成の結果に入れました。

アレイは、次に機能が呼び出され、現在の位置の後に取り出し、ターゲットは、この時点で現在の数を減算し、次に再帰次いで二次元アレイの結果は、現在の数は、フロントアレイのそれぞれに追加され戻さ横切るとことに留意すべきで各アレイは、以下のコードを参照し、結果RESに添加しました。

C ++

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> res;
        sort(candidates.begin(), candidates.end());
        for (int i = 0; i < candidates.size(); ++i) {
            if (candidates[i] > target) break;
            if (candidates[i] == target) {res.push_back({candidates[i]}); break;}
            vector<int> vec = vector<int>(candidates.begin() + i, candidates.end());
            vector<vector<int>> tmp = combinationSum(vec, target - candidates[i]);
            for (auto a : tmp) {
                a.insert(a.begin(), candidates[i]);
                res.push_back(a);
            }
        }
        return res;
    }
};

ジャワ

class Solution {
    
    List<List<Integer>> res = new ArrayList<>();
    
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if (target <= 0) {res.add(new ArrayList<>());}
        //先排序，排序后可以加剪枝
        Arrays.sort(candidates);
        dfs(new ArrayList<>(), candidates, 0, target, 0);
        return res;
    }

    public void dfs(List<Integer> list, int[] candidates, int sum, int target, int start) {
        for (int i = start; i < candidates.length; i++) {
            list.add(candidates[i]);
            if ((sum + candidates[i]) == target) {
                //此时tmpList 满足
                List<Integer> tmpList = new ArrayList<>(list);
                res.add(tmpList);
            } if ((sum + candidates[i]) < target) {
                dfs(list, candidates, sum + candidates[i], target, i);
            } else {
                list.remove(list.size() - 1);
                //(sum+candidates[i]) > target,因为数组有序，后面一定不满足
                break;
            }
            list.remove(list.size() - 1);
        }
    }
}

ダイナミックプログラミング

我们也可以用迭代的解法来做，建立一个三维数组 dp，这里 dp[i] 表示目标数为 i+1 的所有解法集合。这里的i就从1遍历到 target 即可，对于每个i，都新建一个二维数组 cur，然后遍历 candidates 数组，如果遍历到的数字大于i，说明当前及之后的数字都无法组成i，直接 break 掉。否则如果相等，那么把当前数字自己组成一个数组，并且加到 cur 中。否则就遍历 dp[i - candidates[j] - 1] 中的所有数组，如果当前数字大于数组的首元素，则跳过，因为结果要求是要有序的。否则就将当前数字加入数组的开头，并且将数组放入 cur 之中即可，参见代码如下：

c++

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<vector<int>>> dp;
        sort(candidates.begin(), candidates.end());
        for (int i = 1; i <= target; ++i) {
            vector<vector<int>> cur;
            for (int j = 0; j < candidates.size(); ++j) {
                if (candidates[j] > i) break;
                if (candidates[j] == i) {cur.push_back({candidates[j]}); break;}
                for (auto a : dp[i - candidates[j] - 1]) {
                    if (candidates[j] > a[0]) continue;
                    a.insert(a.begin(), candidates[j]);
                    cur.push_back(a);
                }
            }
            dp.push_back(cur);
        }
        return dp[target - 1];
    }
};