[LeetCode] 47. Permutaciones II Permutaciones II (C ++)

---

Fuente del tema: https://leetcode-cn.com/problems/permutations-ii/

Descripción del Título

Dada una secuencia numérica que puede contener números repetidos, devuelve todas las permutaciones no repetidas en cualquier orden.

Ejemplo 1:
Entrada: nums = [1,1,2]
Salida:
[[1,1,2],
[1,2,1],
[2,1,1]]
Ejemplo 2:
Entrada: nums = [1 , 2,3]
Resultado: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3 , 2,1]]

提示 ：
1 <= nums.length <=
8-10 <= nums [i] <= 10

Idea general

• Esta pregunta es similar a https://leetcode-cn.com/problems/permutations/ . El método de resolución de problemas es el método de retroceso, pero esta pregunta requiere una operación de poda en el método de retroceso
• Por ejemplo 1, si se puede repetir todo el arreglo, habrá 3! Situaciones, pero debido a que hay un elemento repetido 1, el elemento repetido se excluye del arreglo, si el elemento actual nums [i] es el mismo que el nums de elemento anterior [i-1] se repite, y el elemento anterior ya está en la disposición (usado [i-1] == verdadero), por lo que la pila recursiva de este elemento se devuelve al nodo padre del elemento actual ( nodo) para ser arreglado, y luego La pila recursiva principal realiza un bucle i ++, y luego toma en consideración los siguientes elementos

Introducción al retroceso

• El retroceso es una idea algorítmica y la recursividad es un método de programación. El retroceso se puede implementar mediante recursividad.
• La idea general del método de retroceso es: busque en cada camino, y cada retroceso es para un camino específico. Para buscar en el área inexplorada bajo la ruta de búsqueda actual, puede haber dos situaciones:

class Solution {
    
    
public:
    vector<vector<int>> ret;
    vector<int> ans;
    vector<bool> used;
    int n;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
    
    
        n = nums.size();
        used.assign(n, false);
        sort(nums.begin(), nums.end());
        dfs(nums, 0);
        return ret;
    }
    void dfs(vector<int>& nums, int depth){
    
    
        if(depth == n){
    
    
            ret.push_back(ans);
            return;
        }
        for(int i = 0 ; i < n ; ++i){
    
    
            if(!used[i]){
    
    
                if(!ans.empty() && i - 1 >= 0 && nums[i - 1] == nums[i] && used[i - 1] == true)
                    return;
                used[i] = true;
                ans.push_back(nums[i]);
                dfs(nums, depth + 1);
                used[i] = false;
                ans.pop_back();
            }

        }
    }
};

Análisis de complejidad

• Complejidad del tiempo: O (n * 2 ^ n). n es la longitud de la matriz, hay 2 ^ n casos en total, y se necesita O (n) tiempo para crear
• Complejidad espacial: O (n). El espacio de pila recursivo es (n)