LeetCode Brush Questions T46 Arreglo completo (mediano)

Hola a todos, esta vez vamos a explicar el tema de la matriz completa T46 de LeetCode (medio), no hay mucho que decir, la pregunta anterior:

ideas de resolución de problemas:
este problema necesita usar el algoritmo de retroceso , y resolver todos los problemas de retroceso, En realidad, es un problema de árbol de decisión . Si no lo entiende, déjeme darle un ejemplo:
podemos mirar la imagen primero:

De la imagen vemos: [1,2,3] hace nuestro conjunto de soluciones, sígueme para analizar:
1 : El primer 1 seleccionado.
2: Luego puede elegir 1, 2, 3, elegimos 1, pero se ha seleccionado 1 (una matriz sin números repetidos), por lo que solo podemos volver atrás, es decir, 1-> 1 es una cruz
3: Entonces podemos Elija 1-> 2
4: elegimos 1-> 2, luego podemos elegir 1, 2, 3, si elegimos 1, es 1-> 2-> 1, pero se ha seleccionado 1, tenemos que volver , Vea si puede 1-> 2-> 2, pero se ha seleccionado 2, veamos si podemos elegir 3, 1-> 2-> 3, sí.
Después del análisis anterior, surge lo que se llama backtracking, de hecho, es esencialmente un árbol de decisiones, las ramas del árbol representan tu elección (decisión), es decir, retrocedemos y volvemos al paso anterior.
Entonces, ¿cómo diseñamos el algoritmo?
Sigo tomando las

ideas de diseño del algoritmo de imagen anterior :
1: Definir una pista, que representa la ruta, y usar la pista para registrar nuestra ruta. Cuando el grado de la pista es igual a la longitud de nums, significa que esta es una de las permutaciones.
2: Debido a que los números en la matriz de números no se pueden repetir, los números que han aparecido en la pista representan que no necesitamos bifurcar a los números que han existido en la pista. Por ejemplo, como arriba, 1-> 1, no funcionará, porque la pista [1 ] Hay 1. La figura anterior simplemente usa una operación ternaria para mostrarlo, si existe, luego retroceder, si no existe, agregarlo a la pista, indicando que actualmente somos un componente del arreglo final.
3: De acuerdo con la descripción anterior y la figura anterior, podemos obtener la idea de diseño de nuestro algoritmo, esto es solo una parte de la figura, por lo que adoptamos el método recursivo.
Siguiente en el código:

class Solution {
    //返回结果
    List<List<Integer>> res = new  LinkedList<List<Integer>>(); //表示结果

    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track=new LinkedList<>(); //表示当前的路径
        backtrack(nums,track);  //数组和当前的走过的路径放进去 递归函数
        return res;
    }

    // 递归函数
    public void backtrack(int[] nums,LinkedList<Integer> track){
        //递归的结束条件，track的长度和数组长度相等，则说明当前track为一次排列
        if(track.size()==nums.length){
            res.add(track);
            return;
        }

        //判断条当前决策是否能添加进track 
        for(int i=0;i<nums.length;i++){
            if(track.contains(nums[i])){ //因为数组无重复数字，说明此数字已经用过，此路不通 
                continue;  
            }
            track.add(nums[i]); //添加进当前的路径
            backtrack(nums,track);//保存当前的看路径继续递归
            track.removeLast();  //取消track的最后一个，也就是返回上一次的决策。
        }
    }
}

Esta pregunta es más difícil, debe combinar imágenes cuidadosamente y comprender los conceptos de recursividad, toma de decisiones y retroceso para comprender mejor.

¡Jaja es un poco horrible! Si tiene una mejor idea, deje un mensaje a continuación. ¡Espero ayudar a todos! ¡Gracias!