Check if There is a Valid Path in a Grid - Practice Coding Problems

Check if There is a Valid Path in a Grid - Problem

Imagine navigating through a city where each block has specific street connections that you must follow! You are given an m x n grid where each cell represents a street with predetermined connections:

1: Horizontal street (left ↔ right)
2: Vertical street (up ↔ down)
3: L-shaped street (left ↔ down)
4: J-shaped street (right ↔ down)
5: Γ-shaped street (left ↔ up)
6: r-shaped street (right ↔ up)

Your mission is to determine if there's a valid path from the top-left corner (0,0) to the bottom-right corner (m-1, n-1). You can only move between adjacent cells if their street connections are compatible - meaning one cell's connection direction must align with the neighboring cell's connection direction.

Goal: Return true if a valid path exists, false otherwise.

Input & Output

example_1.py — Basic Valid Path

$ Input: grid = [[2,4,3],[6,5,2]]

› Output: true

💡 Note: Starting at (0,0) with street type 2 (vertical), we can go down to (1,0) which has street type 6 (connects up and right). From there we can go right to (1,1) with type 5 (connects left and up), then up to (0,1) with type 4 (connects right and down), then right to (0,2) with type 3 (connects left and down), and finally down to (1,2) - our destination!

example_2.py — No Valid Path

$ Input: grid = [[1,2,1],[1,2,1]]

› Output: false

💡 Note: Starting at (0,0) with street type 1 (horizontal), we can only move horizontally. But the cell to the right (0,1) has street type 2 (vertical), which cannot connect to a horizontal street. There's no valid path to reach the bottom-right corner.

example_3.py — Single Cell Grid

$ Input: grid = [[1,1,2]]

› Output: false

💡 Note: We start at (0,0) and need to reach (0,2). From (0,0) with type 1, we can go right to (0,1) also with type 1. But from (0,1) we need to reach (0,2) with type 2 (vertical). Since type 1 only allows horizontal movement and type 2 only allows vertical movement, they cannot connect.

Visualization

Tap to expand

Understanding the Visualization

Map the Streets

Each cell has a specific street pattern: horizontal (1), vertical (2), or various L-shaped patterns (3-6)

Check Connections

Before moving to an adjacent cell, verify that both cells' street patterns allow the connection

Explore Systematically

Use DFS or BFS to explore all valid paths from start to destination

Track Visited Cells

Maintain a visited set to avoid cycles and infinite loops

Key Takeaway

🎯 Key Insight: Success depends on systematically checking connection compatibility between adjacent cells while using efficient graph traversal (DFS/BFS) to explore all possible paths.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is visited at most once, so linear in grid size

✓ Linear Growth

Space Complexity

O(m*n)

Space for queue and visited array

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 300
1 ≤ grid[i][j] ≤ 6
Grid cells represent street types 1-6 with specific connection patterns

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

This problem requires graph traversal with connection validation. The optimal approach uses DFS or BFS to explore paths while checking if adjacent cells have compatible street connections. Key insight: two cells connect only if one cell's direction matches the reverse direction of its neighbor (e.g., 'right' connects to 'left').

Common Approaches

Approach	Time	Space	Notes
✓ BFS Iterative Exploration	O(m*n)	O(m*n)	Use breadth-first search to systematically explore all possible paths level by level

BFS Iterative Exploration — Algorithm Steps

Initialize queue with starting position (0,0)
Mark starting position as visited
While queue is not empty, dequeue current position
Check if current position is the target
For each direction the current street allows, check valid neighbors
Add unvisited valid neighbors to queue and mark as visited

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with (0,0) in queue and mark as visited

Process Current Level

Dequeue all cells at current level and check their neighbors

Add Valid Neighbors

Add unvisited valid neighbors to queue for next level

Continue Until Found

Repeat until target is found or queue is empty

Code -

solution.c — C

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

typedef struct {
    int row, col;
} Point;

typedef struct {
    Point* data;
    int front, rear, size;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->data = (Point*)malloc(capacity * sizeof(Point));
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    return q;
}

void enqueue(Queue* q, Point p) {
    q->rear++;
    q->data[q->rear] = p;
    q->size++;
}

Point dequeue(Queue* q) {
    Point p = q->data[q->front];
    q->front++;
    q->size--;
    return p;
}

bool isEmpty(Queue* q) {
    return q->size == 0;
}

int directions[7][2][2] = {
    {{0, 0}, {0, 0}},
    {{0, -1}, {0, 1}},
    {{-1, 0}, {1, 0}},
    {{0, -1}, {1, 0}},
    {{0, 1}, {1, 0}},
    {{0, -1}, {-1, 0}},
    {{0, 1}, {-1, 0}}
};

bool hasConnection(int street, int dr, int dc) {
    for (int i = 0; i < 2; i++) {
        if (directions[street][i][0] == dr && directions[street][i][1] == dc) {
            return true;
        }
    }
    return false;
}

bool hasValidPath(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return false;
    
    int m = gridSize, n = gridColSize[0];
    bool** visited = (bool**)malloc(m * sizeof(bool*));
    for (int i = 0; i < m; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    Queue* q = createQueue(m * n);
    Point start = {0, 0};
    enqueue(q, start);
    visited[0][0] = true;
    
    while (!isEmpty(q)) {
        Point curr = dequeue(q);
        int row = curr.row, col = curr.col;
        
        if (row == m - 1 && col == n - 1) {
            free(q->data);
            free(q);
            for (int i = 0; i < m; i++) free(visited[i]);
            free(visited);
            return true;
        }
        
        int street = grid[row][col];
        
        for (int i = 0; i < 2; i++) {
            int newRow = row + directions[street][i][0];
            int newCol = col + directions[street][i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n &&
                !visited[newRow][newCol]) {
                
                int nextStreet = grid[newRow][newCol];
                if (hasConnection(nextStreet, -directions[street][i][0], -directions[street][i][1])) {
                    visited[newRow][newCol] = true;
                    Point next = {newRow, newCol};
                    enqueue(q, next);
                }
            }
        }
    }
    
    free(q->data);
    free(q);
    for (int i = 0; i < m; i++) free(visited[i]);
    free(visited);
    return false;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is visited at most once, so linear in grid size

✓ Linear Growth

Space Complexity

O(m*n)

Space for queue and visited array

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 300
1 ≤ grid[i][j] ≤ 6
Grid cells represent street types 1-6 with specific connection patterns

36.2K Views

Medium Frequency

~25 min Avg. Time

1.6K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS Iterative Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler