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

Find Minimum Time to Reach Last Room II - Problem

Array Graph Heap (Priority Queue) Matrix Shortest Path Medium

Escape the Time-Locked Dungeon!

You find yourself trapped in a mysterious n x m dungeon where each room has a magical time lock. You're given a 2D array moveTime[i][j] that represents the earliest time you can enter room (i, j).

The Challenge: Starting from room (0, 0) at time t = 0, reach the exit at room (n-1, m-1) in minimum time.

Movement Rules:

You can only move to adjacent rooms (up, down, left, right)
Movement time alternates: 1 second for odd-numbered moves, 2 seconds for even-numbered moves
You cannot enter a room before its moveTime[i][j]

Return the minimum time needed to reach the final room. If a room's time lock hasn't expired, you must wait or find alternative paths!

Input & Output

example_1.py — Basic 2x2 Grid

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

› Output: 3

💡 Note: Start at (0,0) at time 0. Move to (0,1) at time 1 (cost 1). Move to (1,1): arrival time 1+2=3, which equals moveTime[1][1]=3, so final time is 3.

example_2.py — Waiting Required

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

› Output: 6

💡 Note: Optimal path: (0,0)→(1,0)→(1,1)→(1,2). Times: 0→2(wait)→4→6. The direct path through (0,1) is blocked by high moveTime.

example_3.py — Single Cell

$ Input: moveTime = [[5]]

› Output: 5

💡 Note: Already at destination (0,0). Need to wait until time 5 when the room unlocks.

Constraints

1 ≤ n, m ≤ 750
0 ≤ moveTime[i][j] ≤ 10⁹
moveTime[0][0] = 0 (can always start immediately)
The grid is connected (solution always exists)

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at entrance with your time-alternating pass

Check Room Access

Each room requires waiting until its unlock time

Calculate Movement

Movement cost alternates: 1 unit for odd moves, 2 for even

Priority Decision

Always choose the path that gets you anywhere fastest

Handle Waiting

If you arrive early, wait until the room opens

Reach Destination

First arrival at exit is guaranteed optimal

Key Takeaway

🎯 Key Insight: This is a shortest path problem with variable edge weights. Dijkstra's algorithm naturally handles both the alternating movement costs and waiting times by always processing the most promising path first.

Asked in

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

The optimal solution uses Dijkstra's algorithm with a priority queue to find the shortest path while handling alternating movement costs (1→2→1→2...) and waiting times. Key insight: track both position and move parity to handle the alternating cost pattern. Time complexity: O(nm log nm).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS with Memoization)	O(4^(n*m))	O(n*m)	Explore all possible paths using recursive DFS with memoization
Dijkstra's Algorithm with Priority Queue (Optimal)	O(nm log(nm))	O(nm)	Use Dijkstra's shortest path algorithm with priority queue to find optimal path

Brute Force (DFS with Memoization) — Algorithm Steps

Start DFS from (0,0) with time=0 and move_count=0
For each cell, try moving to all 4 adjacent cells
Calculate arrival time considering alternating move costs
If arrival time < moveTime[i][j], wait until moveTime[i][j]
Use memoization to store minimum time to reach each state
Return minimum time to reach (n-1, m-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Exploration

Begin DFS from (0,0) at time 0

Branch Out

Explore all 4 directions from current cell

Calculate Time

Add movement cost and waiting time

Memoize

Store result to avoid recalculation

Code -

solution.c — C

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

#define MAX_KEY 1000

typedef struct {
    char key[100];
    int value;
} MemoEntry;

MemoEntry memo[MAX_KEY];
int memoCount = 0;

int findMemo(const char* key) {
    for (int i = 0; i < memoCount; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(const char* key, int value) {
    if (memoCount < MAX_KEY) {
        strcpy(memo[memoCount].key, key);
        memo[memoCount].value = value;
        memoCount++;
    }
}

int dfs(int** moveTime, int n, int m, int i, int j, int time, int moves) {
    if (i == n-1 && j == m-1) {
        int waitTime = moveTime[i][j] - time > 0 ? moveTime[i][j] - time : 0;
        return time + waitTime;
    }
    
    char key[100];
    sprintf(key, "%d,%d,%d,%d", i, j, time, moves);
    int cached = findMemo(key);
    if (cached != -1) return cached;
    
    if (i < 0 || i >= n || j < 0 || j >= m) return INT_MAX;
    
    int waitTime = moveTime[i][j] - time > 0 ? moveTime[i][j] - time : 0;
    int currentTime = time + waitTime;
    
    int minTime = INT_MAX;
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    for (int d = 0; d < 4; d++) {
        int ni = i + directions[d][0], nj = j + directions[d][1];
        if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
            int moveCost = moves % 2 == 0 ? 1 : 2;
            int nextTime = currentTime + moveCost;
            int result = dfs(moveTime, n, m, ni, nj, nextTime, moves + 1);
            if (result != INT_MAX && result < minTime) {
                minTime = result;
            }
        }
    }
    
    addMemo(key, minTime);
    return minTime;
}

int minTimeToReach(int** moveTime, int n, int m) {
    memoCount = 0;
    return dfs(moveTime, n, m, 0, 0, 0, 0);
}

int main() {
    int n = 2, m = 2;
    int** moveTime = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        moveTime[i] = malloc(m * sizeof(int));
    }
    moveTime[0][0] = 0; moveTime[0][1] = 1;
    moveTime[1][0] = 2; moveTime[1][1] = 3;
    
    printf("%d\n", minTimeToReach(moveTime, n, m));
    
    for (int i = 0; i < n; i++) {
        free(moveTime[i]);
    }
    free(moveTime);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(n*m))

In worst case, we explore 4 directions from each of n*m cells, leading to exponential growth

✓ Linear Growth

Space Complexity

O(n*m)

Memoization table stores results for each cell, plus recursion stack space

⚡ Linearithmic Space

23.7K Views

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (DFS with Memoization) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler