Merge pull request neetcode-gh#633 from Samuel-Hinchliffe/main

(JS) Create 743. Network Delay Time & 778. Swim in Rising Water

Author: Ahmad-A0

javascript/743-Network-Delay-Time.js

@@ -0,0 +1,44 @@
+/**
+ * @param {number[][]} times
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+var networkDelayTime = function (times, n, k) {
+
+	let   time_taken     = 0;
+	const visited_set    = new Set();
+	const min_heap       = new MinPriorityQueue();
+	const node_edge_cost = new Map();
+
+	for (const [node, edge, cost] of times) {
+		let edges = [];
+		if (node_edge_cost.has(node)) {
+			edges = node_edge_cost.get(node);
+		}
+		edges.push([edge, cost]);
+		node_edge_cost.set(node, edges);
+	}
+
+	min_heap.enqueue([k, 0], 0);
+
+	while (min_heap.size()) {
+        
+		const [node, cost] = min_heap.dequeue().element;
+
+		if (visited_set.has(node)) continue;
+		visited_set.add(node);
+
+		time_taken = Math.max(cost, time_taken);
+
+		const node_edges = node_edge_cost.get(node) || [];
+
+		for (const [edge_node, edge_cost] of node_edges) {
+			if (!visited_set.has(edge_node)) {
+				min_heap.enqueue([edge_node, edge_cost + cost], edge_cost + cost);
+			}
+		}
+	}
+
+	return visited_set.size === n ? time_taken : -1;
+};

javascript/778-Swim-in-Rising-Water.js

@@ -0,0 +1,42 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var swimInWater = function (grid) {
+    
+    let   time_passed = 0;
+    const visit_set   = new Set();
+    const min_heap    = new MinPriorityQueue();
+
+    const max_rows   = grid.length - 1;
+    const max_cols   = grid[0].length - 1;
+    const directions = [
+        [1, 0],
+        [-1, 0],
+        [0, 1],
+        [0, -1],
+    ];
+
+    min_heap.enqueue([0, 0], grid[0][0]);
+
+    while (min_heap.size()) {
+
+        const node   = min_heap.dequeue();
+        const cost   = node.priority;
+        const [x, y] = node.element;
+
+        visit_set.add(grid[x][y]);
+        time_passed = Math.max(cost, time_passed);
+
+        if (x === max_rows && y === max_cols) return time_passed;
+
+        for (const direction of directions) {
+            let [new_x, new_y]  = direction;
+            new_x          += x;
+            new_y          += y;
+
+            if (new_x > max_rows || new_y > max_cols || new_x < 0 || new_y < 0 || visit_set.has(grid[new_x][new_y])) continue;
+            min_heap.enqueue([new_x, new_y], grid[new_x][new_y]);
+        }
+    }
+};