Minimum Cost to Make at Least One Valid Path in a Grid

Minimum Cost to Make at Least One Valid Path in a Grid - Problem

Array Breadth-First Search Graph Heap (Priority Queue) Matrix Shortest Path Hard

Imagine you're navigating through a maze where each cell has a directional arrow that tells you which direction to move next. Your goal is to find the minimum cost to reach from the top-left corner (0, 0) to the bottom-right corner (m-1, n-1).

Each cell contains one of four directional signs:

1 → Move right (to the next column)
2 → Move left (to the previous column)
3 → Move down (to the next row)
4 → Move up (to the previous row)

The challenge is that some arrows might point in the wrong direction or even outside the grid! You can change any arrow's direction for a cost of 1, but you can only change each arrow once.

Your task is to find the minimum number of arrow changes needed to create at least one valid path from start to finish.

Input & Output

example_1.py — Basic Grid

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

› Output: 3

💡 Note: We need to change 3 arrows to create a valid path. One possible solution: change grid[1][1] from 2→1, grid[2][1] from 1→3, and grid[2][2] from 1→3 to create a path that goes right-right-right-down-down-down-right.

example_2.py — Small Grid

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

› Output: 0

💡 Note: Following the existing arrows creates a valid path: (0,0)→(0,1)→(0,2)→(1,2)→(2,2), so no changes are needed.

example_3.py — Single Cell

$ Input: grid = [[1]]

› Output: 0

💡 Note: We're already at the destination, so no cost is needed.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at top-left intersection with $0 cost

Follow or Fix Signs

Follow correct signs for free, or pay $1 to change wrong ones

Use Smart Search

0-1 BFS ensures we explore cheapest routes first

Reach Destination

First arrival at bottom-right gives minimum cost

Key Takeaway

🎯 Key Insight: This problem is essentially finding the shortest path where following existing arrows costs 0 and changing directions costs 1. The 0-1 BFS approach guarantees optimal solution in O(m×n) time.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is processed at most once, and we examine 4 directions per cell

✓ Linear Growth

Space Complexity

O(m*n)

Space for the deque and distance array

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
1 ≤ grid[i][j] ≤ 4

Asked in

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

The optimal solution uses 0-1 BFS to model this as a shortest path problem. Following existing arrows costs 0, changing directions costs 1. The deque-based approach ensures we process cells in order of increasing cost, guaranteeing the first time we reach the destination gives us the minimum cost in O(m×n) time.

Common Approaches

Approach	Time	Space	Notes
✓ 0-1 BFS / Dijkstra's Algorithm (Optimal)	O(m*n)	O(m*n)	Use 0-1 BFS to find shortest path where following arrow costs 0, changing costs 1
DFS with Backtracking (Optimized Brute Force)	O(4^(m*n))	O(m*n)	Use DFS to explore different paths while keeping track of minimum changes needed
Brute Force (Try All Combinations)	O(4^(m*n))	O(m*n)	Try every possible combination of arrow modifications until finding a valid path

0-1 BFS / Dijkstra's Algorithm (Optimal) — Algorithm Steps

Model each grid cell as a graph node
Edges have weight 0 if following current arrow, weight 1 if changing direction
Use 0-1 BFS with deque: add 0-cost moves to front, 1-cost moves to back
Process cells in order of increasing cost until reaching destination
Return the cost when we first reach the bottom-right cell

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with (0,0) at cost 0, all other cells at infinite cost

Process Queue

Process cells from deque: 0-cost moves from front, 1-cost moves from back

Update Distances

Update neighbor distances and add to appropriate end of deque

Find Minimum

First time we reach destination gives us minimum cost

Code -

solution.c — C

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

typedef struct {
    int i, j, cost;
} State;

typedef struct Node {
    State state;
    struct Node* next;
    struct Node* prev;
} Node;

typedef struct {
    Node* front;
    Node* back;
} Deque;

Deque* createDeque() {
    Deque* dq = malloc(sizeof(Deque));
    dq->front = dq->back = NULL;
    return dq;
}

void pushFront(Deque* dq, State state) {
    Node* node = malloc(sizeof(Node));
    node->state = state;
    node->next = dq->front;
    node->prev = NULL;
    
    if (dq->front) dq->front->prev = node;
    else dq->back = node;
    
    dq->front = node;
}

void pushBack(Deque* dq, State state) {
    Node* node = malloc(sizeof(Node));
    node->state = state;
    node->next = NULL;
    node->prev = dq->back;
    
    if (dq->back) dq->back->next = node;
    else dq->front = node;
    
    dq->back = node;
}

State popFront(Deque* dq) {
    Node* node = dq->front;
    State state = node->state;
    
    dq->front = node->next;
    if (dq->front) dq->front->prev = NULL;
    else dq->back = NULL;
    
    free(node);
    return state;
}

int isEmpty(Deque* dq) {
    return dq->front == NULL;
}

int minCost(int** grid, int m, int n) {
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    int** dist = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        dist[i] = malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            dist[i][j] = INT_MAX;
        }
    }
    dist[0][0] = 0;
    
    Deque* dq = createDeque();
    State start = {0, 0, 0};
    pushBack(dq, start);
    
    while (!isEmpty(dq)) {
        State curr = popFront(dq);
        int i = curr.i, j = curr.j, cost = curr.cost;
        
        if (cost > dist[i][j]) continue;
        
        if (i == m - 1 && j == n - 1) {
            // Cleanup
            for (int k = 0; k < m; k++) free(dist[k]);
            free(dist);
            return cost;
        }
        
        for (int direction = 0; direction < 4; direction++) {
            int ni = i + directions[direction][0];
            int nj = j + directions[direction][1];
            
            if (ni >= 0 && ni < m && nj >= 0 && nj < n) {
                int newCost = (grid[i][j] == direction + 1) ? cost : cost + 1;
                
                if (newCost < dist[ni][nj]) {
                    dist[ni][nj] = newCost;
                    State next = {ni, nj, newCost};
                    
                    if (newCost == cost) {
                        pushFront(dq, next);
                    } else {
                        pushBack(dq, next);
                    }
                }
            }
        }
    }
    
    int result = dist[m-1][n-1];
    // Cleanup
    for (int k = 0; k < m; k++) free(dist[k]);
    free(dist);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is processed at most once, and we examine 4 directions per cell

✓ Linear Growth

Space Complexity

O(m*n)

Space for the deque and distance array

⚡ Linearithmic Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
1 ≤ grid[i][j] ≤ 4

28.4K Views

Medium-High Frequency

~25 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

0-1 BFS / Dijkstra's Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler