Minimum Time to Visit Disappearing Nodes

Minimum Time to Visit Disappearing Nodes - Problem

There is an undirected graph of n nodes. You are given a 2D array edges, where edges[i] = [u_i, v_i, length_i] describes an edge between node u_i and node v_i with a traversal time of length_i units.

Additionally, you are given an array disappear, where disappear[i] denotes the time when the node i disappears from the graph and you won't be able to visit it.

Note: The graph might be disconnected and might contain multiple edges. Return the array answer, with answer[i] denoting the minimum units of time required to reach node i from node 0. If node i is unreachable from node 0 then answer[i] is -1.

Input & Output

Example 1 — Basic Graph with Disappearing Nodes

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

› Output: [0,-1,4]

💡 Note: Start at node 0 (time 0). Node 1 is unreachable because the path 0→1 takes 2 time units but node 1 disappears at time 1. Node 2 can be reached directly via 0→2 in 4 time units, arriving before it disappears at time 5. The path 0→1→2 is not possible since node 1 is unreachable.

Example 2 — Early Disappearing Node

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

› Output: [0,2,3]

💡 Note: Node 0 disappears at time 1, but we start there at time 0 so it's reachable. Node 1 can be reached via 0→1 in 2 time units (before time 3). Node 2 is reachable via 0→1→2 in 3 time units (before time 5).

Example 3 — Unreachable Node

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

› Output: [0,-1]

💡 Note: Node 1 disappears at time 1, but it takes 10 time units to reach it from node 0. Since 10 > 1, node 1 is unreachable, so return -1.

Constraints

1 ≤ n ≤ 5 × 10⁴
0 ≤ edges.length ≤ 10⁵
edges[i] = [u_i, v_i, length_i]
0 ≤ u_i, v_i ≤ n - 1
1 ≤ length_i ≤ 10⁴
1 ≤ disappear[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Meta 15 ⊞ Microsoft 12

The key insight is to use Dijkstra's shortest path algorithm with an additional time constraint: only visit nodes if we can reach them before their disappear time. The optimal approach uses a priority queue to explore paths in order of increasing distance, ensuring we find the shortest valid path to each reachable node. Time: O((V + E) log V), Space: O(V + E)

Common Approaches

✓ DFS All Paths

⏱️ Time: O(2^n) Space: O(n)

Use depth-first search to explore all possible paths from node 0 to every other node. For each path, check if we can reach the destination before it disappears and track the minimum time.

Dijkstra with Time Constraints

⏱️ Time: O((V + E) log V) Space: O(V + E)

Use Dijkstra's shortest path algorithm with a priority queue, but add a constraint to only visit nodes if we can reach them before their disappear time. This ensures we find the shortest valid path to each reachable node.

DFS All Paths — Algorithm Steps

Build adjacency list from edges
For each node, run DFS from node 0
Track minimum time while ensuring arrival before disappear time

Visualization

Tap to expand

Step-by-Step Walkthrough

Start DFS

Begin from node 0 with time 0

Explore Paths

Try all neighbors, backtrack when necessary

Check Constraints

Only visit nodes before they disappear

Code -

solution.c — C

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

#define MAX_NODES 1000
#define MAX_EDGES 2000

struct Edge {
    int to;
    int weight;
    struct Edge* next;
};

struct HeapItem {
    int time;
    int node;
};

struct MinHeap {
    struct HeapItem items[MAX_NODES * MAX_EDGES];
    int size;
};

void heapPush(struct MinHeap* heap, int time, int node) {
    int index = heap->size++;
    heap->items[index].time = time;
    heap->items[index].node = node;
    
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->items[parent].time <= heap->items[index].time) break;
        struct HeapItem temp = heap->items[parent];
        heap->items[parent] = heap->items[index];
        heap->items[index] = temp;
        index = parent;
    }
}

struct HeapItem heapPop(struct MinHeap* heap) {
    struct HeapItem result = heap->items[0];
    heap->items[0] = heap->items[--heap->size];
    
    int index = 0;
    while (1) {
        int minIndex = index;
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        
        if (leftChild < heap->size && heap->items[leftChild].time < heap->items[minIndex].time) {
            minIndex = leftChild;
        }
        if (rightChild < heap->size && heap->items[rightChild].time < heap->items[minIndex].time) {
            minIndex = rightChild;
        }
        
        if (minIndex == index) break;
        struct HeapItem temp = heap->items[minIndex];
        heap->items[minIndex] = heap->items[index];
        heap->items[index] = temp;
        index = minIndex;
    }
    
    return result;
}

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);
    }
}

void parseEdges(const char* str, int edges[][3], int* edge_count) {
    *edge_count = 0;
    const char* p = str;
    
    while (*p) {
        // Find start of an edge [x,y,z]
        while (*p && *p != '[') p++;
        if (!*p) break;
        
        // Check if this is the outer bracket or an edge bracket
        const char* temp = p + 1;
        while (*temp == ' ') temp++;
        if (*temp == '[') {
            // This is the outer bracket, skip it
            p++;
            continue;
        }
        
        // Parse the three numbers in this edge
        p++; // skip '['
        int nums[3];
        int num_count = 0;
        
        while (*p && *p != ']' && num_count < 3) {
            while (*p == ' ' || *p == ',') p++;
            if (*p == ']' || *p == '\0') break;
            
            nums[num_count++] = (int)strtol(p, (char**)&p, 10);
        }
        
        if (num_count == 3) {
            edges[*edge_count][0] = nums[0];
            edges[*edge_count][1] = nums[1];
            edges[*edge_count][2] = nums[2];
            (*edge_count)++;
        }
        
        // Skip to end of this bracket
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
    }
}

void solution(int n, int edges[][3], int edge_count, int disappear[], int result[]) {
    static struct Edge* graph[MAX_NODES];
    static int dist[MAX_NODES];
    
    // Initialize
    for (int i = 0; i < n; i++) {
        graph[i] = NULL;
        dist[i] = INT_MAX;
    }
    
    // Build graph
    for (int i = 0; i < edge_count; i++) {
        int u = edges[i][0];
        int v = edges[i][1];
        int w = edges[i][2];
        
        struct Edge* edge1 = malloc(sizeof(struct Edge));
        edge1->to = v;
        edge1->weight = w;
        edge1->next = graph[u];
        graph[u] = edge1;
        
        struct Edge* edge2 = malloc(sizeof(struct Edge));
        edge2->to = u;
        edge2->weight = w;
        edge2->next = graph[v];
        graph[v] = edge2;
    }
    
    // Dijkstra's algorithm
    dist[0] = 0;
    struct MinHeap heap = {.size = 0};
    heapPush(&heap, 0, 0);
    
    while (heap.size > 0) {
        struct HeapItem current = heapPop(&heap);
        int time = current.time;
        int node = current.node;
        
        if (time > dist[node]) {
            continue;
        }
        
        if (time >= disappear[node]) {
            continue;
        }
        
        struct Edge* neighbor = graph[node];
        while (neighbor) {
            int neighborNode = neighbor->to;
            int weight = neighbor->weight;
            int newTime = time + weight;
            
            if (newTime < disappear[neighborNode] && newTime < dist[neighborNode]) {
                dist[neighborNode] = newTime;
                heapPush(&heap, newTime, neighborNode);
            }
            neighbor = neighbor->next;
        }
    }
    
    // Build result
    for (int i = 0; i < n; i++) {
        if (dist[i] == INT_MAX) {
            result[i] = -1;
        } else {
            result[i] = dist[i];
        }
    }
    
    // Clean up
    for (int i = 0; i < n; i++) {
        struct Edge* edge = graph[i];
        while (edge) {
            struct Edge* next = edge->next;
            free(edge);
            edge = next;
        }
    }
}

int main() {
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    int n = atoi(line);
    
    fgets(line, sizeof(line), stdin);
    int edges[MAX_EDGES][3];
    int edge_count;
    parseEdges(line, edges, &edge_count);
    
    fgets(line, sizeof(line), stdin);
    int disappear[MAX_NODES];
    int disappear_size;
    parseArray(line, disappear, &disappear_size);
    
    int result[MAX_NODES];
    solution(n, edges, edge_count, disappear, result);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, explores all possible paths which can be exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and adjacency list storage

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

DFS All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler