Generate All Valid Parentheses - Backtracking / Additional States

I appreciate the rewritten Backtracking section. It’s much more clear! As I’m just getting used to learning the templates for the types of problems, I prefer the solution that uses the for loop. My brain looks for patterns, and I find jumping to the solution with the ifs is actually more jarring and may cause me to not imprint the template in my memory. However, the code snippet that uses the for loop and is shown in the “Footnote” doesn’t account for the step of reverting the additional states. I used the following:
* inside the for loop…
# Update additional states, call dfs(…), then revert the additional states
if parenthsis == ‘(’:
open_count +=1
dfs(path, open_count, close_count, res)
open_count -= 1
close_count += 1
dfs(path, open_count, close_count, res)
close_count -= 1

I realize this causes us to repeat the same line in two places, which can be a no-no, but it seems like a better first pass for a novice. The solution with the ifs could be offered up as a refactor.

My apologies, the lines of code didn’t appear in my comment how I typed them. Is there a trick to force a carriage return in these comments?

I think I have a pretty clean solution

def generate_parentheses(n: int) -> List[str]:
    ret = []
    def backtrack(n, openParen, curr):
        if n == 0 and openParen == 0:
        if n > 0:
            backtrack(n - 1, openParen + 1, curr + '(')
        if openParen > 0:
            backtrack(n, openParen - 1, curr + ')')
    backtrack(n, 0, '')
    return ret

thanks, you are right; we updated the code :wink:

Here’s a neat and efficient way to do this in Python:

from typing import List, Generator

def generate_valid_parens(current_str: str, n: int, open_budget: int, non_closed_parens: int) -> Generator[str, None, None]:
    if len(current_str) == 2 * n:
        yield current_str

    if open_budget > 0:
        yield from generate_valid_parens(current_str + '(', n, open_budget - 1, non_closed_parens + 1)

    if non_closed_parens > 0:
        yield from generate_valid_parens(current_str + ')', n, open_budget, non_closed_parens - 1)

def generate_parentheses(n: int) -> List[str]:
    return [result for result in generate_valid_parens('', n, n, 0)]

Looks like ‘start_index’ was not useful here. What type of problems within backtracking would need a start_index?

I’m looking at the C++ version of the solution. I didn’t see any use for the startIndex parameter. Better remove it.

def generate_parentheses(n: int) → List[str]:
def getParenteses(n, validParenteses, path, count):
if count[‘(’] > n or count[‘)’] > count.get(‘(’):
if len(path) == n * 2:

    for char in ['(', ')']:
        count[char] += 1
        getParenteses(n, validParenteses, path, count)
        count[char] -= 1


if n == 0:
    return []
validParenteses = []
count = {'(': 0, ')': 0}
getParenteses(n, validParenteses, [], count)

return validParenteses

THis is my solution as well, the only additional state you need is the number of opening brackets

startIndex is used to track the current level of the state-space tree. it’s not always needed for every problem but we keep it in the template to make it consistent. you will see it used in the next few problems

keep on reading, it’ll show up in the next few articles.

My solution, using pruning rather than states, I guess…

def is_valid(s: str, n:int) -> bool:
    for each closing paren, check for preceding open paren 
    open_count, closed_count = 0, 0
    for i in range(len(s)):
        if s[i] == '(':
            open_count += 1
        elif s[i] == ')':
            closed_count += 1
        if closed_count > open_count:
            return False 
        if open_count > n:
            return False
    return True 
def generate_parentheses(n: int) -> List[str]:
    edges = ['(', ')']
    index = 0
    path = ''
    paths = []
    def dfs(index, path):
        nonlocal paths 
        if index == n*2:
        for edge in edges:
            if not is_valid(path + edge, n):
            path += edge 
            dfs(index + 1, path)
            path = path[:-1]
    dfs(index, path)
    return paths 

My solution that almost closely follows the template:

def generate_valid_parentheses(n: int) → List[str]:
output = []
open_param = ‘(’
close_param = ‘)’
paren_to_count_map = {open_param: 0, close_param: 0}

def is_leaf(idx):
    return idx >= 2 * n

def is_valid(edge, state):
    if edge == open_param:
        return state[edge] < n
    elif edge == close_param:
        return state[edge] < state[open_param]
        return False

def get_edges():
    edges = (open_param, close_param)
    return edges

def dfs(idx, path, state):

    if is_leaf(idx):

    for edge in get_edges():

        if not is_valid(edge, state):

        state[edge] += 1

        dfs(idx+len(edge), path, state)


        state[edge] -= 1

dfs(0, [], paren_to_count_map)

return output

I guess you can’t expect everyone to read through everything lol

It looks to me like startIndex in the Java version isn’t used. I made a simplified version, in which dfs() takes four parameters instead of six.

import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.ArrayList;

class Solution {
    private static void dfs(String path, int pCount, List<String> result, int n) {
        if (path.length() == n * 2) {
            if (pCount == 0) result.add(path);
        if (pCount < n)
            dfs(path + '(', pCount + 1, result, n);
        if (pCount > 0)
            dfs(path + ')', pCount - 1, result, n);
    public static List<String> generateParentheses(int n) {
        List<String> result = new ArrayList<>();
        dfs("", 0, result, n);
        return result;

This kind of step can often be combined:

dfs(start_index + 1, path, open_count + 1, close_count, res)


dfs(start_index + 1, path+['('], open_count + 1, close_count, res)

The append and pop steps are taken care of in the function call.



even needed in the solution?

My solution. I think just pruning alone will do the trick.

from typing import List
from collections import Counter

def valid(path, n):
    counts = Counter(path)
    if counts['('] > n or counts[')'] > n or counts[')'] > counts['(']:
        return False
    return True

def generate_parentheses(n: int) -> List[str]:

    res = []
    def traverse(state, path):
        if state == 2*n:
        for bracket in ['(', ')']:
            if valid(path,n):
                traverse(state+1, path)
    traverse(0, [])       
    return res
def generate_parentheses(n: int) -> List[str]:

    rst = []
    def dfs(cur_path, left_count, right_count):
        if left_count == right_count == n:
        for i, parentness in enumerate(['(', ')']):
            if parentness == ')' and left_count <= right_count:
            if left_count > n or right_count > n:

            if i == 0:
                dfs(cur_path, left_count + 1, right_count)
                dfs(cur_path, left_count, right_count + 1)
    dfs([], 0, 0)
    return rst