Análisis del problema de la clase combinada de leetcode

Análisis del problema de la clase combinada de leetcode

LC 39. Suma combinada

Dada una matriz de duplicados sin elementos duplicados y un objetivo de número objetivo, descubra todas las combinaciones que pueden hacer la suma de los números en los objetivos.

Los números en los candidatos se pueden seleccionar repetidamente sin restricción.

Descripción:

Todos los números (incluido el objetivo) son enteros positivos.
El conjunto de soluciones no puede contener combinaciones duplicadas.
Ejemplo 1:

Entrada: candidatos = [2,3,6,7], objetivo = 7,
el conjunto resuelto es:
[
[7],
[2,2,3]
]
Ejemplo 2:

Entrada: candidatos = [2,3,5], objetivo = 8,
el conjunto resuelto es:
[
[2,2,2,2],
[2,3,3],
[3,5]
]

class Solution {
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        vector<vector<int>> ans;
        vector<int> path;
        backTrack(path, 0, target, ans, candidates);
        return ans;
    }

    void backTrack(vector<int>& path, int beginIndex, int target, vector<vector<int>>& ans, vector<int>& candidates){
        if(target==0){
            ans.push_back(path);
            return;
        }else if(target<0){
            return;
        }else{
            for(int i=beginIndex; i<candidates.size(); ++i){
                path.push_back(candidates[i]);
                backTrack(path, i, target-candidates[i], ans, candidates);
                path.pop_back();
            }
        }
    }
};

LC 40. Suma combinada II

Dada una variedad de candidatos y un objetivo de número objetivo, encuentre todas las combinaciones en los candidatos que puedan hacer que el objetivo sea la suma de números.

Cada número de candidatos solo se puede usar una vez en cada combinación.

Descripción:

Todos los números (incluido el número objetivo) son enteros positivos.
El conjunto de soluciones no puede contener combinaciones duplicadas.
Ejemplo 1:

Entrada: candidatos = [10,1,2,7,6,1,5], objetivo = 8,
el conjunto resuelto es:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
Ejemplo 2:

Entrada: candidatos = [2,5,2,1,2], objetivo = 5,
el conjunto resuelto es:
[
[1,2,2],
[5]
]

class Solution {
public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        std::sort(candidates.begin(), candidates.end());
        vector<vector<int>> ans;
        vector<int> path;
        backTrack(path, 0, target, ans, candidates);
        return ans;
    }

    void backTrack(vector<int>& path, int beginIndex, int target, vector<vector<int>>& ans, vector<int>& candidates){
        if(target==0){
            ans.push_back(path);
            return;
        }else if(target<0){
            return;
        }else{
            for(int i=beginIndex; i<candidates.size(); ++i){
                if(i>beginIndex && candidates[i]==candidates[i-1]){
                    continue;
                }
                path.push_back(candidates[i]);
                backTrack(path, i+1, target-candidates[i], ans, candidates);
                path.pop_back();
            }
        }
    }
};

LC 216. Suma combinada III

Encuentra todas las combinaciones de k números cuya suma es n. Solo se permiten enteros positivos del 1 al 9 en la combinación, y no hay números duplicados en cada combinación.

Descripción:

Todos los números son enteros positivos.
El conjunto de soluciones no puede contener combinaciones duplicadas.
Ejemplo 1:

Entrada: k = 3, n = 7
Salida: [[1,2,4]]
Ejemplo 2:

Entrada: k = 3, n = 9
Salida: [[1,2,6], [1,3,5], [2,3,4]]

Fuente: LeetCode (LeetCode)
Enlace: https://leetcode-cn.com/problems/combination-sum-iii Los
derechos de autor pertenecen a la red de deducción. Comuníquese con la autorización oficial para la reimpresión comercial e indique la fuente de la reimpresión no comercial.

class Solution {
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        int target = n;
        int pathLen = k;
        vector<int> candidates = {1,2,3,4,5,6,7,8,9};
        vector<vector<int>> ans;
        vector<int> path;
        backTrack(path, pathLen, 0, target, ans, candidates);
        return ans;
    }

    void backTrack(vector<int>& path, int pathLen, int beginIndex, int target, vector<vector<int>>& ans, vector<int>& candidates){
        if(target==0 && path.size()==pathLen){
            ans.push_back(path);
            return;
        }else if(target<0 || path.size()>=pathLen){
            return;
        }else{
            for(int i=beginIndex; i<candidates.size(); ++i){
                path.push_back(candidates[i]);
                backTrack(path, pathLen, i+1, target-candidates[i], ans, candidates);
                path.pop_back();
            }
        }
    }
};

LC 377. Suma combinada IV

Dada una matriz de enteros positivos y sin números duplicados, encuentre el número de combinaciones de enteros positivos para el objetivo dado.

Ejemplo:

nums = [1, 2, 3]
target = 4

Todas las combinaciones posibles son:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1 )

Tenga en cuenta que las secuencias en diferentes órdenes se consideran combinaciones diferentes.

Entonces la salida es 7.

https://leetcode-cn.com/problems/combination-sum-iv/solution/dong-tai-gui-hua-python-dai-ma-by-liweiwei1419/

Necesito usar programación dinámica

dptable[i] += dptable[i-nums[j]];

class Solution {
public:
    long long combinationSum4(vector<int>& nums, int target) {
        vector<long long> dptable(target+1, 0);
        dptable[0] = 1;
        for(int i=1; i<=target; ++i){
            for(int j=0; j<nums.size(); ++j){
                if(nums[j]<=i){
                    if(dptable[i]>(INT_MAX-dptable[i-nums[j]])){
                        dptable[i] = INT_MAX;
                    }else{
                        dptable[i] += dptable[i-nums[j]];
                    }
                }
            }
        }
        return dptable[target];
    }
};

El método de retroceso se agotará.

class Solution {
public:
    int combinationSum4(vector<int>& candidates, int target) {
        //vector<vector<int>> ans;
        int ans = 0;
        vector<int> path;
        backTrack(path, target, ans, candidates);
        return ans;
    }

    void backTrack(vector<int>& path, int target, int& ans, vector<int>& candidates){
        if(target==0){
            //ans.push_back(path);
            ++ans;
            return;
        }else if(target<0){
            return;
        }else{
            for(int i=0; i<candidates.size(); ++i){
                path.push_back(candidates[i]);
                backTrack(path, target-candidates[i], ans, candidates);
                path.pop_back();
            }
        }
    }
};

LC 77. Combinación

Dados dos enteros n y k, devuelve todas las combinaciones posibles de k en 1 ... n.

Ejemplo:

Entrada: n = 4, k = 2
Salida:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/combinations Los
derechos de autor pertenecen a la red de deducción. Comuníquese con la autorización oficial para la reimpresión comercial e indique la fuente de la reimpresión no comercial.

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        int pathLen = k;
        int candidates = n;
        vector<vector<int>> ans;
        vector<int> path;
        backTrack(path, pathLen, 1, ans, candidates);
        return ans;
    }

    void backTrack(vector<int>& path, int pathLen, int beginIndex, vector<vector<int>>& ans, int candidates){
        if(path.size()==pathLen){
            ans.push_back(path);
            return;
        }else if(path.size()>=pathLen){
            return;
        }else{
            for(int i=beginIndex; i<=candidates; ++i){
                path.push_back(i);
                backTrack(path, pathLen, i+1, ans, candidates);
                path.pop_back();
            }
        }
    }
};