Minimum Time to Visit Disappearing Nodes - Practice Coding Problems

Minimum Time to Visit Disappearing Nodes - Problem

You're navigating through a time-sensitive network where nodes can vanish at specific moments! Given an undirected graph with n nodes, you need to find the shortest path from node 0 to every other node before they disappear.

The graph is described by:

edges[i] = [u_i, v_i, length_i]: An edge between nodes u_i and v_i with traversal time of length_i units
disappear[i]: The time when node i vanishes from the graph (you cannot visit it after this time)

Important: The graph might be disconnected and can contain multiple edges between the same pair of nodes.

Goal: Return an array where answer[i] is the minimum time to reach node i from node 0. If node i is unreachable or disappears before you can reach it, return -1.

Input & Output

example_1.py — Basic Connected Graph

$ Input: n = 3, edges = [[0,1,2],[1,2,1],[0,2,4]], disappear = [1,1,5]

› Output: [0, -1, 4]

💡 Note: Node 0 is the starting point (time 0). Node 1 disappears at time 1, but the shortest path takes time 2, so it's unreachable (-1). Node 2 can be reached via path 0→2 in time 4, which is before its disappear time of 5.

example_2.py — Multiple Paths Available

$ Input: n = 4, edges = [[0,1,5],[0,2,3],[1,3,2],[2,3,4]], disappear = [10,8,8,10]

› Output: [0, 5, 3, 7]

💡 Note: All nodes are reachable: Node 1 via 0→1 (time 5), Node 2 via 0→2 (time 3), Node 3 via 0→1→3 (time 7, shorter than 0→2→3 which takes time 7).

example_3.py — Disconnected Graph Edge Case

$ Input: n = 3, edges = [[0,1,2]], disappear = [10,10,10]

› Output: [0, 2, -1]

💡 Note: Node 2 is completely disconnected from the component containing nodes 0 and 1, so it's unreachable regardless of its disappear time.

Constraints

1 ≤ n ≤ 5 × 10⁴
0 ≤ edges.length ≤ 2 × 10⁵
edges[i].length == 3
0 ≤ u_i, v_i ≤ n - 1
0 ≤ length_i ≤ 10⁴
disappear.length == n
1 ≤ disappear[i] ≤ 10⁴
The graph may contain multiple edges and self-loops

Visualization

Tap to expand

Understanding the Visualization

Setup Network

Build the rescue network with weighted paths and closure times for each station

Start from HQ

Begin from headquarters (node 0) at time 0, using a priority queue to explore nearest stations first

Check Time Constraints

For each path, verify we can reach the destination before its closure time

Find Optimal Routes

Use Dijkstra's algorithm to find shortest valid paths to all reachable stations

Key Takeaway

🎯 Key Insight: Dijkstra's algorithm naturally finds the shortest paths, and by checking disappear times during edge relaxation, we ensure all returned paths are valid and optimal.

Asked in

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

This problem is a shortest path problem with time constraints. The optimal approach uses Dijkstra's algorithm with a priority queue, modified to check if we can reach each node before its disappear time. Key insight: when relaxing an edge (u,v), only update if dist[u] + weight < disappear[v] and dist[u] + weight < dist[v].

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS/BFS All Paths)	O(V^V)	O(V)	Explore all possible paths to each node using DFS/BFS
Dijkstra's Algorithm (Optimal)	O((V + E) log V)	O(V + E)	Use Dijkstra's shortest path algorithm with disappear time constraints

Brute Force (DFS/BFS All Paths) — Algorithm Steps

Build adjacency list from edges
For each target node, use DFS to find all paths from node 0
Track the minimum time to reach each node
Check if arrival time is before the node's disappear time
Return -1 for unreachable or expired nodes

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS from node 0

Begin exploring all paths from the starting node

Explore neighbors recursively

For each unvisited neighbor, recursively explore its paths

Check time constraints

Verify if we can reach the target before it disappears

Track minimum time

Keep track of the shortest time found for each destination

Code -

solution.c — C

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

typedef struct {
    int node, weight;
} Edge;

typedef struct {
    Edge* edges;
    int count, capacity;
} AdjList;

int dfs(AdjList* graph, int node, int target, int currentTime, 
        bool* visited, int* disappear, int n) {
    if (node == target) {
        return currentTime < disappear[target] ? currentTime : INT_MAX;
    }
    
    if (currentTime >= disappear[node]) {
        return INT_MAX;
    }
    
    int minTime = INT_MAX;
    visited[node] = true;
    
    for (int i = 0; i < graph[node].count; i++) {
        int neighbor = graph[node].edges[i].node;
        int weight = graph[node].edges[i].weight;
        
        if (!visited[neighbor]) {
            int time = dfs(graph, neighbor, target, currentTime + weight, visited, disappear, n);
            if (time < minTime) {
                minTime = time;
            }
        }
    }
    
    visited[node] = false;
    return minTime;
}

int* minimumTime(int n, int** edges, int edgesSize, int* edgesColSize, 
                int* disappear, int disappearSize, int* returnSize) {
    *returnSize = n;
    int* result = (int*)malloc(n * sizeof(int));
    
    // Initialize adjacency list
    AdjList* graph = (AdjList*)calloc(n, sizeof(AdjList));
    
    // Build graph
    for (int i = 0; i < edgesSize; i++) {
        int u = edges[i][0], v = edges[i][1], w = edges[i][2];
        
        // Add edge u -> v
        if (graph[u].count == graph[u].capacity) {
            graph[u].capacity = graph[u].capacity == 0 ? 1 : graph[u].capacity * 2;
            graph[u].edges = (Edge*)realloc(graph[u].edges, graph[u].capacity * sizeof(Edge));
        }
        graph[u].edges[graph[u].count++] = (Edge){v, w};
        
        // Add edge v -> u
        if (graph[v].count == graph[v].capacity) {
            graph[v].capacity = graph[v].capacity == 0 ? 1 : graph[v].capacity * 2;
            graph[v].edges = (Edge*)realloc(graph[v].edges, graph[v].capacity * sizeof(Edge));
        }
        graph[v].edges[graph[v].count++] = (Edge){u, w};
    }
    
    // Initialize result
    for (int i = 0; i < n; i++) {
        result[i] = -1;
    }
    result[0] = 0;
    
    // Find shortest path to each node
    bool* visited = (bool*)calloc(n, sizeof(bool));
    for (int i = 1; i < n; i++) {
        int minTime = dfs(graph, 0, i, 0, visited, disappear, n);
        if (minTime != INT_MAX) {
            result[i] = minTime;
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) {
        free(graph[i].edges);
    }
    free(graph);
    free(visited);
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V^V)

In worst case, we explore all possible paths which can be exponential

✓ Linear Growth

Space Complexity

O(V)

Space for recursion stack and visited array

✓ Linear Space

42.3K Views

High Frequency

~25 min Avg. Time

1.9K 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/BFS All Paths) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler