[Retroceso] B032_La cadena con el orden k más pequeño de lexicografía entre las cadenas felices de longitud n (retroceso)

1. Título Descripción

Una cadena feliz es una cadena que:

consiste solo en letras del conjunto ['a', 'b', 'c'].
s [i]! = s [i + 1] para todos los valores de i de 1 a s.length - 1 (la cadena está indexada en 1).
Por ejemplo, las cadenas “abc”, “ac”, “b” y “abcbabcbcb” son cadenas felices y las cadenas “aa”, “baa” y “ababbc” no son cadenas felices.

Dados dos enteros n y k, considere una lista de todas las cadenas felices de longitud n ordenadas en orden lexicográfico.

Devuelva la cadena k de esta lista o devuelva una cadena vacía si hay menos de k cadenas felices de longitud n.

Input: n = 3, k = 9
Output: "cab"
Explanation: There are 12 different happy string of length 3 
["aba", "abc", "aca", "acb", "bab", "bac", "bca", "bcb", "cab", "cac", "cba", "cbc"]. 
You will find the 9th string = "cab"

En segundo lugar, la solución

Método 1: retroceso

• aba
  abc
  aca
  ...

Antes de cada recursión, determine si el carácter disponible actualmente es igual al último carácter:

• Si no son lo mismo, se pueden agregar al final de la cadena.
• De lo contrario, omita y continúe enumerando el siguiente carácter.

En esencia, es una gama completa de aplicaciones ampliadas ...

Error desconocido: no sé qué está mal, el número de cadenas encontradas siempre es menor que k.

int n;
List<String> list;
StringBuilder sb;
private void dfs(char pre) {
    if (sb.length() == n) {
        System.out.println(sb.toString());
        list.add(new String(sb.toString()));
        return;
    }
    for (char c = 'a'; c <= 'c'; c++) {
        if (c == pre && sb.length() > 0)
            continue;
        sb.append(c);
        dfs(c);
        sb.deleteCharAt(sb.length()-1);
    }
}
public String getHappyString(int n, int k) {	//返回所有长度为n的第k个happy字符
    this.n = n;
    list = new ArrayList<>();
    sb = new StringBuilder("a");
    dfs('a');
    if (list.size() < k)
        return "";
    //Collections.sort(list);
    return list.get(k-1);
}

Arregla el código ...

List<String> l;
private void dfs(int n, String s) {
    if (n == 0) {
        l.add(s);
        return;
    }
    for (char c = 'a'; c <= 'c'; c++) {
        if (s.length() > 0 && s.charAt(s.length()-1) == c) {
            continue;
        }
        dfs(n-1, s+c);
    }
}
public String getHappyString(int n, int k) {
    l = new ArrayList<>();
    dfs(n, "");
    if (l.size() < k)
        return "";
    return l.get(k-1);
}

Análisis de complejidad.

• Complejidad del tiempo: $O (2 ^ n)$，
• Complejidad espacial: $O (2 ^ n)$，

---

Método 2: optimización

• Debido a que las cadenas se ordenan de vuelta, por lo que la utilizamos String respara grabar cuando idx == kuna cadena de cuando pueda.