Generate Parentheses

Generate Parentheses - Problem

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

A well-formed parentheses string means:

Every opening parenthesis '(' has a corresponding closing parenthesis ')'
Parentheses are properly nested (no closing before matching opening)
All parentheses are matched

Example: For n = 3, valid combinations include "((()))", "(()())", "(())(), "()(())", "()()()"

Input & Output

Example 1 — Basic Case

$ Input: n = 3

› Output: ["((()))","(()())","(())()","()(())","()()()"]

💡 Note: For n=3, we need 3 opening and 3 closing parentheses. The 5 valid combinations are: ((())), (()()), (())(), ()(())], and ()()().

Example 2 — Minimum Case

$ Input: n = 1

› Output: ["()"]

💡 Note: With only 1 pair of parentheses, there's only one valid combination: ()

Example 3 — Small Case

$ Input: n = 2

› Output: ["(())","()()"]

💡 Note: For n=2, we have 2 valid ways to arrange 2 pairs: nested (()) or sequential ()()

Constraints

1 ≤ n ≤ 8

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is to use backtracking to build valid parentheses strings by tracking open and close counts. Best approach is backtracking which only generates valid combinations. Time: O(4^n / √n), Space: O(4^n / √n)

Common Approaches

✓ Backtracking - Build Valid Strings

⏱️ Time: O(4^n / √n) Space: O(4^n / √n)

Use recursive backtracking to build parentheses strings by adding '(' or ')' only when it maintains validity. Track open and close counts to ensure we never violate balance rules.

Brute Force - Generate All Then Filter

⏱️ Time: O(2^(2n) * n) Space: O(2^(2n) * n)

Create all 2^(2n) possible combinations of parentheses, then check each one for validity by ensuring balanced parentheses rules are followed.

Dynamic Programming with Memoization

⏱️ Time: O(4^n / √n) Space: O(4^n / √n)

Use memoization to cache results for different combinations of remaining open and close parentheses. This optimization helps when there are overlapping subproblems in the recursion tree.

Backtracking - Build Valid Strings — Algorithm Steps

Start with empty string and counters for open/close parentheses
At each step, add '(' if we haven't used all n opening parentheses
Add ')' only if it won't exceed the number of opening parentheses
Backtrack and try other possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Decision Tree

Each node represents a choice: add '(' or ')'

Valid Paths

Only follow paths that maintain balance

Complete Strings

Reach leaves with length 2n

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void backtrack(char result[][20], int* count, char* current, int pos, int openCount, int closeCount, int n) {
    // Base case: we've used all n pairs
    if (pos == 2 * n) {
        strcpy(result[*count], current);
        (*count)++;
        return;
    }
    
    // Add opening parenthesis if we haven't used all n
    if (openCount < n) {
        current[pos] = '(';
        current[pos + 1] = '\0';
        backtrack(result, count, current, pos + 1, openCount + 1, closeCount, n);
    }
    
    // Add closing parenthesis if it won't exceed opens
    if (closeCount < openCount) {
        current[pos] = ')';
        current[pos + 1] = '\0';
        backtrack(result, count, current, pos + 1, openCount, closeCount + 1, n);
    }
}

int solution(int n, char result[][20]) {
    char current[20] = "";
    int count = 0;
    backtrack(result, &count, current, 0, 0, 0, n);
    return count;
}

int main() {
    int n;
    scanf("%d", &n);
    
    char result[1000][20];
    int count = solution(n, result);
    
    printf("[");
    for (int i = 0; i < count; i++) {
        printf("\"%s\"", result[i]);
        if (i < count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^n / √n)

Each valid sequence corresponds to a Catalan number, which grows as 4^n / √n

✓ Linear Growth

Space Complexity

O(4^n / √n)

Recursion depth is O(n), but we store all valid combinations

⚡ Linearithmic Space

52.0K Views

High Frequency

~15 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking - Build Valid Strings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler