Network Delay Time - Practice Coding Problems

Network Delay Time - Problem

Network Signal Propagation Problem

Imagine you're managing a network communication system where signals need to reach all nodes. You have a directed network of n nodes labeled from 1 to n. The network connections are defined by times, where each entry times[i] = [u, v, w] represents a directed edge from node u to node v with a signal travel time of w.

Your mission: Send a signal from a source node k and determine the minimum time required for all nodes in the network to receive the signal. If any node cannot be reached, return -1.

Key Insights:
• This is a classic shortest path problem
• We need to find the longest of all shortest paths (bottleneck)
• The answer is the time when the last node receives the signal

Example: If we have nodes [1,2,3] with edges [[2,1,1],[2,3,1],[3,4,1]] and source k=2, the signal reaches node 1 in 1 unit, node 3 in 1 unit, but node 4 takes 2 units total (2→3→4).

Input & Output

example_1.py — Basic Network

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

› Output: 2

💡 Note: Signal starts at node 2. It reaches node 1 in 1 unit and node 3 in 1 unit. From node 3, it takes another 1 unit to reach node 4. So the total time is max(1, 1, 2) = 2 units.

example_2.py — Single Node

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

› Output: 0

💡 Note: Since there's only one node and we start from it, the signal reaches all nodes (just itself) in 0 time.

example_3.py — Unreachable Node

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

› Output: -1

💡 Note: Starting from node 2, there's no path to reach node 1, so it's impossible for all nodes to receive the signal.

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 (no duplicate edges)

Visualization

Tap to expand

Understanding the Visualization

Start Broadcasting

Begin signal transmission from source node K

Spread to Neighbors

Signal propagates to directly connected nodes

Continue Propagation

Newly reached nodes relay signal to their neighbors

Find Bottleneck

The last node to receive signal determines total time

Key Takeaway

🎯 Key Insight: The network delay time is determined by the node that takes the longest to reach from the source - this is why we need the maximum of all shortest path distances.

Asked in

G Google 45 a Amazon 38 f Facebook 25 ⊞ Microsoft 22 Apple 15

The optimal solution uses Dijkstra's algorithm with a priority queue to find shortest paths from the source node to all other nodes. The answer is the maximum shortest distance, representing when the last node receives the signal. Time complexity: O((V + E) log V), Space: O(V + E).

Common Approaches

Approach	Time	Space	Notes
✓ Dijkstra's Algorithm (Optimal)	O((V + E) log V)	O(V + E)	Use priority queue to find shortest paths from source node efficiently
Floyd-Warshall (All Pairs Shortest Path)	O(n³)	O(n²)	Find shortest paths between all pairs of nodes, then check distances from source

Dijkstra's Algorithm (Optimal) — Algorithm Steps

Build adjacency list representation of the graph
Initialize distances array with infinity, set source distance to 0
Use min-heap priority queue, starting with source node
While queue not empty: pop closest node, update neighbors' distances
Return maximum distance, or -1 if any node unreachable

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set source distance to 0, all others to infinity

Process Closest

Always pick the unvisited node with minimum distance

Update Neighbors

Relax distances to all neighbors through current node

Find Maximum

The answer is the maximum of all shortest distances

Code -

solution.c — C

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

#define MAX_N 100
#define MAX_EDGES 6000
#define INF INT_MAX

typedef struct {
    int to, weight;
} Edge;

typedef struct {
    Edge edges[MAX_EDGES];
    int count;
} AdjList;

int networkDelayTime(int** times, int timesSize, int* timesColSize, int n, int k) {
    // Build adjacency list
    AdjList graph[MAX_N + 1];
    for (int i = 0; i <= n; i++) {
        graph[i].count = 0;
    }
    
    for (int i = 0; i < timesSize; i++) {
        int u = times[i][0], v = times[i][1], w = times[i][2];
        graph[u].edges[graph[u].count++] = (Edge){v, w};
    }
    
    // Simple Dijkstra implementation using array
    int distances[MAX_N + 1];
    int visited[MAX_N + 1];
    
    for (int i = 1; i <= n; i++) {
        distances[i] = INF;
        visited[i] = 0;
    }
    distances[k] = 0;
    
    for (int count = 0; count < n; count++) {
        // Find minimum distance unvisited node
        int minDist = INF, u = -1;
        for (int i = 1; i <= n; i++) {
            if (!visited[i] && distances[i] < minDist) {
                minDist = distances[i];
                u = i;
            }
        }
        
        if (u == -1) break;
        visited[u] = 1;
        
        // Update distances to neighbors
        for (int i = 0; i < graph[u].count; i++) {
            int v = graph[u].edges[i].to;
            int weight = graph[u].edges[i].weight;
            
            if (distances[u] != INF && distances[u] + weight < distances[v]) {
                distances[v] = distances[u] + weight;
            }
        }
    }
    
    // Find maximum time
    int maxTime = 0;
    for (int i = 1; i <= n; i++) {
        if (distances[i] == INF) return -1;
        if (distances[i] > maxTime) maxTime = distances[i];
    }
    
    return maxTime;
}

Time & Space Complexity

Time Complexity

⏱️

O((V + E) log V)

Each vertex is processed once, each edge relaxed once, with log V for priority queue operations

⚡ Linearithmic

Space Complexity

O(V + E)

Adjacency list storage plus distances array and priority queue

✓ Linear Space

78.0K 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

Dijkstra's Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler