Find Minimum Time to Reach Last Room II - Problem

Array Graph Heap (Priority Queue) Matrix Shortest Path Medium

There is a dungeon with n x m rooms arranged as a grid. You are given a 2D array moveTime of size n x m, where moveTime[i][j] represents the minimum time in seconds when you can start moving to that room.

You start from the room (0, 0) at time t = 0 and can move to an adjacent room. Moving between adjacent rooms takes one second for one move and two seconds for the next, alternating between the two.

Return the minimum time to reach the room (n - 1, m - 1).

Two rooms are adjacent if they share a common wall, either horizontally or vertically.

Input & Output

Example 1 — Basic 2x2 Grid

$ Input: moveTime = [[0,1],[2,3]]

› Output: 3

💡 Note: Start at (0,0) at time 0. Move right to (0,1) with cost 1 second (first move), arriving at time max(0+1, 1) = 1. Then move down to (1,1) with cost 2 seconds (second move), arriving at time max(1+2, 3) = 3. Total time is 3 seconds.

Example 2 — Larger Grid

$ Input: moveTime = [[0,0,0],[0,0,0],[0,0,0]]

› Output: 6

💡 Note: In a 3x3 grid with no time restrictions, the shortest path from (0,0) to (2,2) requires 4 moves. With alternating costs of 1,2,1,2 seconds per move, the total time is 1+2+1+2 = 6 seconds.

Example 3 — High Time Constraints

$ Input: moveTime = [[0,5],[10,15]]

› Output: 15

💡 Note: Must wait until time 5 to enter (0,1), then wait until time 15 to enter (1,1). The alternating movement costs don't matter much here due to high time constraints.

Constraints

1 ≤ n, m ≤ 750
0 ≤ moveTime[i][j] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

This problem combines shortest path finding with time constraints and alternating movement costs. The key insight is to use Dijkstra's algorithm with a priority queue, where movement costs alternate between 1 and 2 seconds. We must also respect the minimum time constraints for entering each room. The optimal approach uses modified Dijkstra's with state tracking. Time: O(n×m×log(n×m)), Space: O(n×m).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

DFS with All Paths

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

Explore all possible paths from (0,0) to (n-1,m-1) using recursive DFS, respecting time constraints and alternating movement costs. Track minimum time among all valid paths.

Dijkstra's Algorithm with Priority Queue

⏱️ Time: O(n×m×log(n×m)) Space: O(n×m)

Apply Dijkstra's shortest path algorithm with a priority queue, where edge weights depend on the number of moves made (alternating between 1 and 2 seconds). Track the minimum time to reach each cell.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 750
#define MAX_HEAP 750*750

typedef struct {
    int time;
    int row;
    int col;
    int moves;
} State;

static int moveTime[MAX_N][MAX_N];
static int dist[MAX_N][MAX_N];
static State heap[MAX_HEAP];
static int heapSize;

void heapPush(State s) {
    heap[heapSize] = s;
    int i = heapSize++;
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (heap[parent].time <= heap[i].time) break;
        State temp = heap[parent];
        heap[parent] = heap[i];
        heap[i] = temp;
        i = parent;
    }
}

State heapPop() {
    State result = heap[0];
    heap[0] = heap[--heapSize];
    int i = 0;
    while (2 * i + 1 < heapSize) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int smallest = left;
        if (right < heapSize && heap[right].time < heap[left].time) {
            smallest = right;
        }
        if (heap[i].time <= heap[smallest].time) break;
        State temp = heap[i];
        heap[i] = heap[smallest];
        heap[smallest] = temp;
        i = smallest;
    }
    return result;
}

int isEmpty() {
    return heapSize == 0;
}

int minTimeToReach(int n, int m) {
    if (n == 1 && m == 1) return 0;
    
    // Initialize distances
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            dist[i][j] = INT_MAX;
        }
    }
    
    heapSize = 0;
    State start = {0, 0, 0, 0};
    heapPush(start);
    dist[0][0] = 0;
    
    int dx[] = {-1, 1, 0, 0};
    int dy[] = {0, 0, -1, 1};
    
    while (!isEmpty()) {
        State current = heapPop();
        
        if (current.row == n-1 && current.col == m-1) {
            return current.time;
        }
        
        if (current.time > dist[current.row][current.col]) continue;
        
        for (int d = 0; d < 4; d++) {
            int newRow = current.row + dx[d];
            int newCol = current.col + dy[d];
            
            if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < m) {
                int moveCost = (current.moves % 2 == 0) ? 1 : 2;
                int newTime = current.time + moveCost;
                
                // Must wait if room has time constraint
                if (newTime < moveTime[newRow][newCol]) {
                    newTime = moveTime[newRow][newCol];
                }
                
                if (newTime < dist[newRow][newCol]) {
                    dist[newRow][newCol] = newTime;
                    State newState = {newTime, newRow, newCol, current.moves + 1};
                    heapPush(newState);
                }
            }
        }
    }
    
    return dist[n-1][m-1];
}

void parse2DArray(const char* str, int* n, int* m) {
    *n = 0;
    *m = 0;
    
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    int row = 0;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '[') {
            p++; // Skip opening bracket of row
            int col = 0;
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']' || *p == '\0') break;
                
                char* endptr;
                moveTime[row][col] = (int)strtol(p, &endptr, 10);
                p = endptr;
                col++;
            }
            if (*m == 0) *m = col;
            if (*p == ']') p++; // Skip closing bracket of row
            row++;
        } else {
            // Skip any other characters
            p++;
        }
    }
    *n = row;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    int n, m;
    parse2DArray(line, &n, &m);
    
    int result = minTimeToReach(n, m);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~35 min Avg. Time

890 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