Find Minimum Time to Reach Last Room I - Practice Coding Problems

Find Minimum Time to Reach Last Room I - Problem

Array Graph Heap (Priority Queue) Matrix Shortest Path Medium

Time-Locked Dungeon Escape

You find yourself trapped in a mystical n × m dungeon where each room has a magical lock that opens only at a specific time!

🏰 The Challenge: Navigate from the entrance (0, 0) to the exit (n-1, m-1) in minimum time.

📋 Given:
• A 2D array moveTime[i][j] representing when each room becomes accessible
• You start at time t = 0 from room (0, 0)
• Moving between adjacent rooms takes exactly 1 second
• You can move horizontally or vertically to adjacent rooms

🎯 Goal: Find the minimum time to reach the bottom-right corner (n-1, m-1).

Note: If a room opens at time t, you can enter it at time t or later. You might need to wait or take detours if rooms aren't ready yet!

Input & Output

example_1.py — Basic Grid

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

› Output: 6

💡 Note: We start at (0,0) at time 0. Moving right to (0,1) at time 1, then (0,2) at time 2, then down to (1,2) at time 3. But (1,2) opens at time 5, so we wait until time 5 to enter, then it takes 1 more second to reach, arriving at time 6.

example_2.py — Immediate Path

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

› Output: 3

💡 Note: All rooms are immediately accessible. The shortest path is (0,0) → (0,1) → (0,2) → (1,2), taking exactly 3 seconds since each move takes 1 second.

example_3.py — High Wait Times

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

› Output: 1001

💡 Note: We can go (0,0) → (0,1) → (1,1). The room (1,1) opens at time 1000. We arrive at time 2, so we need to wait. Since wait time is 998 (even), we can enter exactly at time 1000, then move to destination at time 1001.

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at intersection (0,0) at time 0 with green light

Check Next Lights

Look at adjacent intersections and their light schedules

Choose Optimal Route

Always head to the intersection you can reach earliest

Handle Red Lights

If light is red, either wait or take a detour path

Reach Destination

Continue until you reach the final intersection

Key Takeaway

🎯 Key Insight: This shortest path problem requires Dijkstra's algorithm with time-dependent edge weights, always processing the earliest reachable cell first!

Time & Space Complexity

Time Complexity

⏱️

O(4^(n*m))

In worst case, we explore 4 directions for each of n*m cells

✓ Linear Growth

Space Complexity

O(n*m)

Recursion depth can go up to n*m in worst case path

⚡ Linearithmic Space

Constraints

2 ≤ n, m ≤ 1000
0 ≤ moveTime[i][j] ≤ 10⁹
moveTime[0][0] = 0 (we can always start)
Each move between adjacent cells takes exactly 1 second
We can only move horizontally or vertically

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22

This problem is solved optimally using Dijkstra's algorithm with a priority queue. The key insight is treating this as a shortest path problem where we always process the cell reachable at the earliest time first. When a room isn't ready, we use a clever back-and-forth movement strategy to handle waiting times efficiently, ensuring we enter exactly when optimal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS All Paths)	O(4^(n*m))	O(n*m)	Explore all possible paths and return the minimum time
Dijkstra's Algorithm (Optimal)	O(nm log(nm))	O(nm)	Use priority queue to always explore the earliest reachable cell first

Brute Force (DFS All Paths) — Algorithm Steps

Start DFS from (0,0) at time 0
For each cell, explore all 4 adjacent directions
Calculate arrival time considering room's open time
If room opens later, wait until it opens
Track minimum time to reach destination
Backtrack and try other paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin at (0,0) with time 0

Explore Paths

Try all 4 directions recursively

Calculate Wait Time

Wait if room isn't ready yet

Backtrack

Return and try other paths

Code -

solution.c — C

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

#define MAX_SIZE 1000

int dfs(int** moveTime, int n, int m, int row, int col, int currentTime, bool visited[MAX_SIZE][MAX_SIZE]) {
    if (row == n - 1 && col == m - 1) {
        return (currentTime > moveTime[row][col]) ? currentTime : moveTime[row][col];
    }
    
    if (visited[row][col]) return INT_MAX;
    
    visited[row][col] = true;
    int minTime = INT_MAX;
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    for (int i = 0; i < 4; i++) {
        int newRow = row + directions[i][0];
        int newCol = col + directions[i][1];
        if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < m) {
            int arrivalTime = currentTime + 1;
            int actualTime = (arrivalTime > moveTime[newRow][newCol]) ? arrivalTime : moveTime[newRow][newCol];
            
            int result = dfs(moveTime, n, m, newRow, newCol, actualTime, visited);
            if (result != INT_MAX && result < minTime) {
                minTime = result;
            }
        }
    }
    
    visited[row][col] = false;
    return minTime;
}

int minimumTimeToReach(int** moveTime, int moveTimeSize, int* moveTimeColSize) {
    int n = moveTimeSize;
    int m = moveTimeColSize[0];
    
    if (moveTime[0][0] > 0) return -1;
    
    bool visited[MAX_SIZE][MAX_SIZE] = {false};
    return dfs(moveTime, n, m, 0, 0, 0, visited);
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(n*m))

In worst case, we explore 4 directions for each of n*m cells

✓ Linear Growth

Space Complexity

O(n*m)

Recursion depth can go up to n*m in worst case path

⚡ Linearithmic Space

Constraints

2 ≤ n, m ≤ 1000
0 ≤ moveTime[i][j] ≤ 10⁹
moveTime[0][0] = 0 (we can always start)
Each move between adjacent cells takes exactly 1 second
We can only move horizontally or vertically

52.0K Views

High Frequency

~25 min Avg. Time

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

Brute Force (DFS All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler