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.

Constraints

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

Visualization

Tap to expand

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

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

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

Model this as a shortest path problem where each cell is a node. Moving in the arrow's direction has weight 0, while changing direction has weight 1. Use 0-1 BFS (deque-based BFS) for optimal performance.

Brute Force (Try All Combinations)

⏱️ Time: O(4^(m*n)) Space: O(m*n)

Generate all possible grid configurations by trying every combination of arrow directions for each cell, then check if any configuration creates a valid path from start to end.

DFS with Backtracking (Optimized Brute Force)

⏱️ Time: O(4^(m*n)) Space: O(m*n)

Instead of generating all combinations upfront, use depth-first search to explore paths from the starting position, trying both following the current arrow (cost 0) and changing to other directions (cost 1).

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>
#include <string.h>
#include <ctype.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() {
    static char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int m = 0, n = 0;
    static int grid_data[1000][1000];
    static int* grid[1000];
    
    int i = 1; // Skip first '['
    int len = strlen(input);
    
    while (i < len - 1) {
        if (input[i] == '[') {
            i++; // Skip '['
            n = 0;
            char num[20];
            int num_idx = 0;
            
            while (i < len && input[i] != ']') {
                char c = input[i];
                if (c == ',') {
                    if (num_idx > 0) {
                        num[num_idx] = '\0';
                        grid_data[m][n++] = atoi(num);
                        num_idx = 0;
                    }
                } else if (isdigit(c) || c == '-') {
                    num[num_idx++] = c;
                }
                i++;
            }
            
            if (num_idx > 0) {
                num[num_idx] = '\0';
                grid_data[m][n++] = atoi(num);
            }
            
            grid[m] = grid_data[m];
            m++;
            i++; // Skip ']'
        } else {
            i++;
        }
    }
    
    printf("%d\n", minCost(grid, m, n));
    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

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

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

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

Visualization

Code -

Time & Space Complexity

Select Compiler