Check if There Is a Valid Parentheses String Path

Check if There Is a Valid Parentheses String Path - Problem

A parentheses string is a non-empty string consisting only of '(' and ')'. It is valid if any of the following conditions is true:

It is ()
It can be written as AB (A concatenated with B), where A and B are valid parentheses strings
It can be written as (A), where A is a valid parentheses string

You are given an m x n matrix of parentheses grid. A valid parentheses string path in the grid is a path satisfying all of the following conditions:

The path starts from the upper left cell (0, 0)
The path ends at the bottom-right cell (m - 1, n - 1)
The path only ever moves down or right
The resulting parentheses string formed by the path is valid

Return true if there exists a valid parentheses string path in the grid. Otherwise, return false.

Input & Output

Example 1 — Valid Path Exists

$ Input: grid = [["(",")"],["(",")"]]

› Output: false

💡 Note: There are two possible paths: (0,0)→(0,1)→(1,1) gives "())" which is invalid (balance becomes -1), and (0,0)→(1,0)→(1,1) gives "(()" which is invalid (final balance is 1, not 0). No valid path exists.

Example 2 — No Valid Path

$ Input: grid = [[")","("],["(",")"]]

› Output: false

💡 Note: All paths start with ")" which immediately makes the balance negative, so no valid parentheses string can be formed.

Example 3 — Larger Grid

$ Input: grid = [["(","(",")"],[")",")","("],["(",")",")"]]

› Output: true

💡 Note: There exists at least one path that forms a valid parentheses string by carefully choosing down/right moves.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
grid[i][j] is either '(' or ')'

Visualization

Tap to expand

Asked in

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

The key insight is to track the balance of parentheses (count of '(' minus count of ')') at each position, ensuring it never goes negative. The optimal approach uses dynamic programming to maintain sets of possible balance values at each cell. Time: O(m*n*k), Space: O(m*n*k) where k is the maximum possible balance.

Common Approaches

✓ Brute Force DFS

⏱️ Time: O(2^(m+n)) Space: O(m+n)

Use recursive DFS to explore every possible path that moves only down or right. For each complete path, check if the resulting string is a valid parentheses sequence.

DFS with Memoization

⏱️ Time: O(m*n*k) Space: O(m*n*k)

Enhance the DFS approach by caching results for (row, col, balance) states. This prevents redundant calculations when the same position is reached with the same parentheses balance.

Dynamic Programming with Set

⏱️ Time: O(m*n*k) Space: O(m*n*k)

For each cell, maintain a set of all possible parentheses balance values that can be achieved when reaching that cell. Build the solution bottom-up by propagating valid balance states.

Brute Force DFS — Algorithm Steps

Start DFS from (0,0)
For each cell, try moving right and down
Build path string and check validity at the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at (0,0) and explore all paths

Path Building

Build string by concatenating characters along path

Validate

Check if final string is valid parentheses

Code -

solution.c — C

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

#define MAX_SIZE 200
#define MAX_BALANCE 400

bool hasValidPath(char grid[][MAX_SIZE], int m, int n) {
    // dp[i][j][balance] indicates if balance is possible at (i,j)
    static bool dp[MAX_SIZE][MAX_SIZE][MAX_BALANCE];
    
    // Initialize DP table
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < MAX_BALANCE; k++) {
                dp[i][j][k] = false;
            }
        }
    }
    
    // Initialize starting position
    if (grid[0][0] == '(') {
        dp[0][0][1] = true;
    } else {
        return false; // Can't start with ')'
    }
    
    // Fill DP table
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0) continue;
            
            // Check all possible previous balances
            for (int prevBalance = 0; prevBalance < MAX_BALANCE; prevBalance++) {
                bool canReach = false;
                
                // From top
                if (i > 0 && dp[i-1][j][prevBalance]) {
                    canReach = true;
                }
                
                // From left
                if (j > 0 && dp[i][j-1][prevBalance]) {
                    canReach = true;
                }
                
                if (canReach) {
                    int newBalance;
                    if (grid[i][j] == '(') {
                        newBalance = prevBalance + 1;
                    } else {
                        newBalance = prevBalance - 1;
                    }
                    
                    if (newBalance >= 0 && newBalance < MAX_BALANCE) {
                        dp[i][j][newBalance] = true;
                    }
                }
            }
        }
    }
    
    return dp[m-1][n-1][0];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    static char grid[MAX_SIZE][MAX_SIZE];
    int m = 0, n = 0;
    int currentCol = 0;
    
    // Parse the input format [["(",")"],["(",")"]]
    for (int i = 0; i < strlen(line); i++) {
        if (line[i] == '"' && i + 1 < strlen(line) && (line[i+1] == '(' || line[i+1] == ')')) {
            // Found start of character
            grid[m][currentCol] = line[i+1];
            currentCol++;
            i++; // Skip the character
        } else if (line[i] == ']' && i + 1 < strlen(line) && line[i+1] == ',') {
            // End of row
            if (currentCol > 0) {
                if (n == 0) n = currentCol; // Set n from first row
                m++;
                currentCol = 0;
            }
        }
    }
    
    // Handle last row
    if (currentCol > 0) {
        if (n == 0) n = currentCol;
        m++;
    }
    
    printf(hasValidPath(grid, m, n) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

Each cell has 2 choices (right/down), with m+n-2 decisions total

✓ Linear Growth

Space Complexity

O(m+n)

Recursion stack depth is m+n-1 for the longest path

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~35 min Avg. Time

892 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

Brute Force DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler