Network Delay Time

Network Delay Time - Problem

You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (u_i, v_i, w_i), where u_i is the source node, v_i is the target node, and w_i is the time it takes for a signal to travel from source to target.

We will send a signal from a given node k. Return the minimum time it takes for all the n nodes to receive the signal. If it is impossible for all the n nodes to receive the signal, return -1.

Input & Output

Example 1 — Basic Network

$ Input: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2

› Output: 2

💡 Note: From node 2: reaches node 1 in time 1, node 3 in time 1, and node 4 in time 2. All nodes receive the signal by time 2.

Example 2 — Unreachable Node

$ Input: times = [[1,2,1]], n = 2, k = 2

› Output: -1

💡 Note: Starting from node 2, we cannot reach node 1 (edge only goes from 1→2). Return -1.

Example 3 — Single Node

$ Input: times = [], n = 1, k = 1

› Output: 0

💡 Note: Only one node exists and it's the source. Signal reaches immediately at time 0.

Constraints

1 ≤ k ≤ n ≤ 100
1 ≤ times.length ≤ 6000
times[i].length == 3
1 ≤ u_i, v_i ≤ n
u_i ≠ v_i
0 ≤ w_i ≤ 100
All the pairs (u_i, v_i) are unique

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to find the longest shortest path from source to any node. Dijkstra's algorithm efficiently computes shortest paths, and the maximum distance represents when the last node receives the signal. Time: O((V + E) × log V), Space: O(V + E)

Common Approaches

✓ Brute Force - DFS All Paths

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

Use DFS to explore all possible paths from source k to every other node, keeping track of the minimum time to reach each node. The answer is the maximum of all minimum times.

Dijkstra's Algorithm

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

Apply Dijkstra's algorithm to find the shortest path from source k to all other nodes. The answer is the maximum of all shortest distances, representing when the last node receives the signal.

Brute Force - DFS All Paths — Algorithm Steps

Build adjacency list from edges
DFS from source k to find min time to each node
Return max of all min times, or -1 if any unreachable

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from edges

DFS Exploration

Explore all paths from source k

Find Maximum

Return max of minimum times to all nodes

Code -

solution.c — C

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

#define MAX_NODES 101
#define MAX_EDGES 1000
#define MAX_HEAP 10000

typedef struct {
    int to;
    int weight;
} Edge;

typedef struct {
    int distance;
    int node;
} HeapItem;

typedef struct {
    HeapItem items[MAX_HEAP];
    int size;
} MinHeap;

Edge graph[MAX_NODES][MAX_EDGES];
int graphSize[MAX_NODES];
int dist[MAX_NODES];

void heapSwap(MinHeap* h, int i, int j) {
    HeapItem temp = h->items[i];
    h->items[i] = h->items[j];
    h->items[j] = temp;
}

void heapPush(MinHeap* h, int distance, int node) {
    h->items[h->size].distance = distance;
    h->items[h->size].node = node;
    int current = h->size;
    h->size++;
    
    while (current > 0) {
        int parent = (current - 1) / 2;
        if (h->items[parent].distance <= h->items[current].distance) break;
        heapSwap(h, parent, current);
        current = parent;
    }
}

HeapItem heapPop(MinHeap* h) {
    HeapItem result = h->items[0];
    h->size--;
    if (h->size > 0) {
        h->items[0] = h->items[h->size];
        int current = 0;
        while (2 * current + 1 < h->size) {
            int minChild = 2 * current + 1;
            if (2 * current + 2 < h->size && 
                h->items[2 * current + 2].distance < h->items[minChild].distance) {
                minChild = 2 * current + 2;
            }
            if (h->items[current].distance <= h->items[minChild].distance) break;
            heapSwap(h, current, minChild);
            current = minChild;
        }
    }
    return result;
}

int solution(int times[][3], int timesSize, int n, int k) {
    // Initialize graph
    memset(graphSize, 0, sizeof(graphSize));
    
    // Build adjacency list
    for (int i = 0; i < timesSize; i++) {
        int u = times[i][0];
        int v = times[i][1];
        int w = times[i][2];
        
        graph[u][graphSize[u]].to = v;
        graph[u][graphSize[u]].weight = w;
        graphSize[u]++;
    }
    
    // Dijkstra's algorithm
    for (int i = 1; i <= n; i++) {
        dist[i] = INT_MAX;
    }
    dist[k] = 0;
    
    MinHeap pq = {0};
    heapPush(&pq, 0, k);
    
    while (pq.size > 0) {
        HeapItem current = heapPop(&pq);
        int current_dist = current.distance;
        int node = current.node;
        
        // Skip if we've already found a better path
        if (current_dist > dist[node]) {
            continue;
        }
        
        // Explore neighbors
        for (int i = 0; i < graphSize[node]; i++) {
            Edge edge = graph[node][i];
            int neighbor = edge.to;
            int weight = edge.weight;
            int new_dist = current_dist + weight;
            if (new_dist < dist[neighbor]) {
                dist[neighbor] = new_dist;
                heapPush(&pq, new_dist, neighbor);
            }
        }
    }
    
    // Check if all nodes are reachable and find max time
    int max_time = 0;
    for (int i = 1; i <= n; i++) {
        if (dist[i] == INT_MAX) {
            return -1;
        }
        if (dist[i] > max_time) {
            max_time = dist[i];
        }
    }
    
    return max_time;
}

void parseArray(const char* str, int arr[][3], int* size) {
    *size = 0;
    const char* p = str;
    
    if (strcmp(str, "[]") == 0) {
        return;
    }
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']' && *size < MAX_EDGES) {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '[') {
            p++;
            for (int j = 0; j < 3; j++) {
                while (*p == ' ') p++;
                arr[*size][j] = (int)strtol(p, (char**)&p, 10);
                while (*p == ' ' || *p == ',') p++;
            }
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            (*size)++;
        } else {
            break;
        }
        while (*p == ' ' || *p == ',') p++;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse times array
    int times[MAX_EDGES][3];
    int timesSize = 0;
    
    parseArray(line, times, &timesSize);
    
    int n, k;
    scanf("%d", &n);
    scanf("%d", &k);
    
    printf("%d\n", solution(times, timesSize, n, k));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^n)

DFS explores all possible paths, which can be exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and adjacency list storage

⚡ Linearithmic Space

185.0K Views

Medium Frequency

~25 min Avg. Time

4.2K 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 All Paths — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler