Permutaciones y combinaciones sin cadenas de caracteres repetidas. Escribe un método para calcular todas las permutaciones y combinaciones de una cadena, cada carácter de la cadena es diferente.
Ejemplo 1: Entrada: S = “qwe” Salida: [“qwe”, “qew”, “wqe”, “weq”, “ewq”, “eqw”]
Ejemplo 2: Entrada: S = “ab” Salida: [ Indicación "Ab", "ba"]
: los caracteres son todos letras inglesas; la longitud de la cadena está entre [1, 9]
Solución 1: Retroceso
Para comprender la idea de retroceso: siga las posibles subrutas hasta llegar al final y vuelva al estado de vanguardia, luego cambie otra posible ruta y repita hasta llegar al final. camino.
Plantilla DFS: primero defina la condición de terminación, y luego el bucle for, para recorrer todas las rutas posibles y volver al estado anterior sin completar una.
ArrayList<String> list = new ArrayList<>();
public String[] permutation(String S) {
char[] cs = S.toCharArray();
DFS(new StringBuilder(), cs, new HashSet<>(), S.length());
String[] strings = new String[list.size()];
for (int i = 0; i < list.size(); i++) {
strings[i] = list.get(i);
}
return strings;
}
public void DFS(StringBuilder s, char[] cs, HashSet<Character> set, int n) {
if (s.length() == n) {
list.add(s.toString());
} else {
for (int i = 0; i < n; i++) {
if (!set.contains(cs[i])) {
set.add(cs[i]);
s.append(cs[i]);
DFS(s, cs, set, n);
set.remove(cs[i]);
s.deleteCharAt(s.length() - 1);
}
}
}
}
Solución 2: bit de bandera La
idea básica es similar a retroceder.
class Solution {
ArrayList<String> res = new ArrayList<String>();
public String[] permutation(String S) {
char[] chs = S.toCharArray();
DFS("", chs, new boolean[chs.length]);
String[] strs = new String[res.size()];
for (int i = 0; i < res.size(); i++) {
strs[i] = res.get(i);
}
return strs;
}
public void DFS(String cur, char[] chs, boolean[] flag) {
if (cur.length() == chs.length) {
res.add(cur);
} else {
for (int i = 0; i < chs.length; i++) {
if (flag[i] == true)
continue;
flag[i] = true;
DFS(cur + chs[i], chs, flag);
flag[i] = false;
}
}
}
}
fin.