enlace de tema
Niuke.com online oj question - la disposición de las cuerdas
Tema Descripción
Ingrese una cadena de longitud n, imprima todas las permutaciones de los caracteres en la cadena, puede devolver esta matriz de cadenas en cualquier orden.
Por ejemplo, ingrese la cadena ABC, luego emita todas las cadenas ABC, ACB, BAC, BCA, CBA y CAB que se pueden organizar con los caracteres A, B y C.
Rango de datos: n<10
Requisitos: complejidad espacial O(n!), complejidad temporal O(n!)
Descripción de entrada:
ingrese una cadena, la longitud no excede 10 y los caracteres solo incluyen letras mayúsculas y minúsculas.
Ejemplo de tema
Ejemplo 1
Introduzca:
"ab"
Valor de retorno:
["ab", "ba"]
Explicación:
Devolver ["ba", "ab"] también es correcto
Ejemplo 2
Ingrese:
"ab"
Valor de retorno:
["aab", "aba", "baa"]
Ejemplo 3
Ingrese:
"abc"
Valor devuelto:
["abc", "acb", "bac", "bca", "taxi", "cba"]
Ejemplo 4
Introduzca:
""
valor de retorno:
[""]
ideas para resolver problemas
Esta pregunta puede usar la búsqueda primero en profundidad y el rastreo hacia atrás para enumerar todos los casos y luego agregar el conjunto de procesos calificados al conjunto de resultados.
Primero defina el resultado de ArrayList<String> como el conjunto de resultados devuelto por última vez.
Define una ruta Stack<Character>, como el conjunto de procedimientos generados durante la recursividad.
Define boolean[] isUsed para determinar si se ha utilizado la ubicación actual
Implemente la función recursiva de profundidad PermutationDFS(char[] chars, int depth, Stack<Character> path, boolean[] isUsed, ArrayList result), los parámetros son respectivamente la matriz de caracteres correspondiente a str, la profundidad de profundidad de recursión, la ruta del conjunto de procesos , y si la bandera ha sido atravesada La matriz isUsed, el resultado del conjunto de resultados
La condición de terminación de la recursión es: cuando la profundidad de la recursión es igual a la longitud de los caracteres, constrúyala como una cadena, agréguela al resultado del conjunto de resultados para crear
un bucle, desde 0 hasta la longitud de los caracteres - 1, que representa la posición inicial del arreglo, si la posición actual se usa (isUsed[i] == true), luego continúe
agregando el elemento actual chars[i] al conjunto de procesos, marque la posición como atravesada (isUsed[i] = true), y luego continúe recursivamente, deje que la profundidad de recurrencia agregue uno
Cuando la recursividad regrese a la posición actual, debe volver al estado donde la recursividad no ha comenzado, establezca isUsed[i] = false y elimine el elemento actual del proceso colocar
Finalmente, cree un HashSet y agregue todos los elementos del resultado al HashSet para evitar agregar secuencias duplicadas.
código completo
import java.util.*;
public class Solution {
public ArrayList<String> Permutation(String str) {
ArrayList<String> result = new ArrayList<>();
if(str != null && str.length() > 0){
Stack<Character> path = new Stack<>();
boolean[] isUsed = new boolean[str.length()];
PermutationDFS(str.toCharArray(), 0, path, isUsed, result);
HashSet<String> hashSet = new HashSet<>();
for (int i = 0; i < result.size(); i++){
hashSet.add(result.get(i));
}
ArrayList<String> newResult = new ArrayList<>(hashSet);
Collections.sort(newResult);
return newResult;
}
return result;
}
private void PermutationDFS(char[] chars, int depth, Stack<Character> path, boolean[] isUsed, ArrayList<String> result) {
if(depth == chars.length){
ArrayList<Character> tmp = new ArrayList<>(path);
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < tmp.size(); i++){
stringBuilder.append(tmp.get(i));
}
result.add(stringBuilder.toString());
return;
}
for (int i = 0; i < chars.length; i++){
if(isUsed[i]){
continue;
}
path.add(chars[i]);
isUsed[i] = true;
PermutationDFS(chars, depth + 1, path, isUsed, result);
isUsed[i] = false;
path.pop();
}
}
}