LeetCode -. 39 общий состав

Учитывая , а неповторяющиеся элементы массива candidatesи целевое числа target, найти candidatesвсе номера и позволяет targetкомбинацию.

candidates Выбранный номер может повторяться неограниченное.

Описание:

• Все цифры ( в том числе target) являются положительными целыми числами.
• Решение Set не может содержать их дубликаты комбинаций.

Пример 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]
]

Рекурсивная функция

Вот когда мы объединим три новых переменных, начать запись текущей рекурсию к индексу, из раствора, Рез экономят все решения были получены, каждый вызов новой рекурсивной функции, то цель должна вычесть текущий массив номер, см код, специфичный следующим образом:

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();
        }
    }
};

Рекурсивный улучшение

Мы не можем использовать дополнительную функцию для завершения в рекурсивной функции, или для сортировки массива, а затем итерация, если число больше, чем текущая цель, конечно, не объясняет состав мишени, так как ряд по порядку, не может сделать после цели непосредственно вспыхнуть. Если число в точности равна текущей цели, текущий номер является единственным решением, а затем помещают в композиции приводит массив в разрешении.

Массив затем вынимают после текущей позиции, функция вызывается, цель следует отметить, что в это время вычитания текущего номера, а затем рекурсивно пересекают двумерные результаты массива возвращается, текущее число добавляется к каждой из передней решетки, а затем каждый массив был добавлен в результирующий Рез см следующего кода:

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];
    }
};