Algoritmo: generar recursivamente paréntesis 22. Generar paréntesis

22. Genera paréntesis

Dados n pares de paréntesis, escribe una función para generar todas las combinaciones de paréntesis bien formados.

Ejemplo 1:

Input: n = 3
Output: ["((()))","(()())","(())()","()(())","()()()"]

Ejemplo 2:

Input: n = 1
Output: ["()"]

Restricciones:

• 1 <= norte <= 8

Solución recursiva de profundidad primero, usando contadores izquierdo y derecho

1. La idea es agregar ')' solo después de válido '('
2. Usamos dos variables enteras izquierda y derecha para ver cuántos '(' & ')' hay en la cadena actual
3. Si se deja < n, podemos agregar '(' a la cadena actual
4. Si derecha < izquierda, podemos agregar ')' a la cadena actual
   

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        res = []
        res_len = n * 2
        def dfs(s, left, right):
            if len(s) == res_len:
                res.append(s)
                return
            if left < n:
                dfs(s+'(', left+1, right)
            
            if left > right:
                dfs(s+')', left, right+1)
        
        dfs('', 0, 0)
        return res
            

La complejidad temporal del código dado es O(2^N), donde N es el valor de n.

El código genera todas las combinaciones de paréntesis válidas mediante un método de búsqueda en profundidad (DFS). Explora recursivamente todas las opciones posibles en cada posición hasta que se forma una combinación de paréntesis válida.

En la función dfs, el caso base se alcanza cuando la longitud de la cadena s es igual a res_len, donde res_len es igual a n * 2. Esto indica que se formó una combinación de paréntesis válida y se agregó a la lista res.

Las llamadas recursivas en la función dfs se basan en dos condiciones:

1.  如果左括号的数量（left）小于 n，则递归调用 dfs(s+'(', left+1, right)。这表示选择将左括号 '(' 添加到字符串 s 中，并递增 left 计数。
   

2.  如果 left 计数大于 right 计数，则递归调用 dfs(s+')', left, right+1)。这表示选择将右括号 ')' 添加到字符串 s 中，并递增 right 计数。
   

Estas dos llamadas recursivas continúan la exploración de todas las opciones posibles siguiendo el enfoque DFS.
Dado que cada posición en la cadena resultante tiene dos opciones (paréntesis de apertura o cierre), el número total de llamadas recursivas será 2^N, donde N es el valor de n.
Por lo tanto, la complejidad temporal del código es O(2^N), porque el número de llamadas recursivas y el tamaño de la lista de resultados aumentan exponencialmente a medida que crece n.