Network Delay Time

Problem statement

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] = (ui, vi, wi), where ui is the source node, vi is the target node, and wi 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 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.

Example 1:

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

Example 2:

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

Example 3:

Input: times = [[1,2,1]], n = 2, k = 2Output: -1

Constraints:

• 1 <= k <= n <= 100
• 1 <= times.length <= 6000
• times[i].length == 3
• 1 <= ui, vi <= n
• ui != vi
• 0 <= wi <= 100
• All the pairs (ui, vi) are unique. (i.e., no multiple edges.)

My solution

/**
 * @param {number[][]} times
 * @param {number} n
 * @param {number} k
 * @return {number}
 */
var networkDelayTime = function(times, n, k) {
    const distance = Array.from({
        length: n + 1
    }, () => Number.MAX_SAFE_INTEGER)
    
    distance[0] = 0;
    distance[k] = 0;
    
    const travel = Array.from({
        length: n + 1
    }, () => []);
    
    times.forEach(([currentNode, targetNode, time]) => {
        travel[currentNode].push([targetNode, time])
    })
    
    const queue = [k];
    const queueCost = [0];
    
    while (queue.length) {
        // console.log(queue, queueCost)
        const topNode = queue.shift();
        const topCost = queueCost.shift();
        
        // travel[topNode].forEach(([target, time]) => {
        //     // console.log(topCost + time, time, topCost)
        //     if (topCost + time < distance[target]) {
        //         distance[target] = topCost + time;
        //         queue.push(target);
        //         queueCost.push(distance[target])
        //     }
        // })
        
        travel[topNode].forEach(([target, time]) => {
            if (distance[topNode] + time < distance[target]) {
                distance[target] = distance[topNode] + time;
                queue.push(target)
            }
        })
    }
    
    const max = Math.max(...distance)
    
    if (max === Number.MAX_SAFE_INTEGER) {
        return -1
    }
    return max
};