Find Minimum Time to Reach Last Room I - 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 after which the room opens and can be moved to.

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

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 Grid

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

› Output: 3

💡 Note: Start at (0,0) at time 0 → move to (0,1) at time 1 → move to (1,1) at time 3 (wait until room opens). Total time: 3 seconds.

Example 2 — Blocked Path

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

› Output: 5

💡 Note: Path: (0,0) t=0 → (1,0) t=1 → (1,1) t=2 → (0,1) t=3 (wait) → (1,1) t=5. Need to alternate to reach time 2 for (0,1).

Example 3 — Simple Path

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

› Output: 3

💡 Note: Direct path: (0,0) t=0 → (0,1) t=1 → (1,1) t=3 (wait for room to open at time 3). Total: 3 seconds.

Constraints

2 ≤ n, m ≤ 750
n == moveTime.length
m == moveTime[i].length
0 ≤ moveTime[i][j] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Meta 8 Apple 6

The key insight is that this is a shortest path problem where we may need to wait at cells. If we arrive early, we must wait until the room opens, and if the wait time has wrong parity, we need one extra second. Dijkstra's algorithm efficiently finds the minimum time path. Time: O(n×m×log(n×m)), Space: O(n×m).

Common Approaches

✓ Optimized

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

Memoization

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

Brute Force DFS

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

Use recursive DFS to explore every possible path from start to destination, keeping track of the minimum time needed. For each room, wait if we arrive before its opening time.

Dijkstra's Algorithm

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

Apply Dijkstra's shortest path algorithm using a priority queue. Always process the cell with minimum time first, ensuring we find the optimal path without exploring all possibilities.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_STATES 1000000

typedef struct {
    int remaining;
    long long powerSum;
    long long result;
} State;

State memoTable[MAX_STATES];
int memoSize = 0;

int countSetBits(long long x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

long long findMemo(int remaining, long long powerSum) {
    for (int i = 0; i < memoSize; i++) {
        if (memoTable[i].remaining == remaining && 
            memoTable[i].powerSum == powerSum) {
            return memoTable[i].result;
        }
    }
    return -1;
}

void addMemo(int remaining, long long powerSum, long long result) {
    if (memoSize < MAX_STATES) {
        memoTable[memoSize].remaining = remaining;
        memoTable[memoSize].powerSum = powerSum;
        memoTable[memoSize].result = result;
        memoSize++;
    }
}

long long solve(int* nums, int numsSize, int remaining, long long powerSum, int k) {
    if (remaining == 0) {
        return countSetBits(powerSum) == k ? 1 : 0;
    }
    
    long long cached = findMemo(remaining, powerSum);
    if (cached != -1) {
        return cached;
    }
    
    long long result = 0;
    for (int i = 0; i < numsSize; i++) {
        long long newSum = powerSum + (1LL << i);
        result = (result + (long long)nums[i] * solve(nums, numsSize, remaining - 1, newSum, k)) % MOD;
    }
    
    addMemo(remaining, powerSum, result);
    return result;
}

int solution(int* nums, int numsSize, int m, int k) {
    memoSize = 0;
    return (int)solve(nums, numsSize, m, 0, k);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int m, k;
    scanf("%d", &m);
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, m, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 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