Add solution #1129

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,144 LeetCode solutions in JavaScript
+# 1,145 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -890,6 +890,7 @@
 1124|[Longest Well-Performing Interval](./solutions/1124-longest-well-performing-interval.js)|Medium|
 1125|[Smallest Sufficient Team](./solutions/1125-smallest-sufficient-team.js)|Hard|
 1128|[Number of Equivalent Domino Pairs](./solutions/1128-number-of-equivalent-domino-pairs.js)|Easy|
+1129|[Shortest Path with Alternating Colors](./solutions/1129-shortest-path-with-alternating-colors.js)|Medium|
 1137|[N-th Tribonacci Number](./solutions/1137-n-th-tribonacci-number.js)|Easy|
 1143|[Longest Common Subsequence](./solutions/1143-longest-common-subsequence.js)|Medium|
 1161|[Maximum Level Sum of a Binary Tree](./solutions/1161-maximum-level-sum-of-a-binary-tree.js)|Medium|

solutions/1129-shortest-path-with-alternating-colors.js

@@ -0,0 +1,55 @@
+/**
+ * 1129. Shortest Path with Alternating Colors
+ * https://leetcode.com/problems/shortest-path-with-alternating-colors/
+ * Difficulty: Medium
+ *
+ * You are given an integer n, the number of nodes in a directed graph where the nodes are
+ * labeled from 0 to n - 1. Each edge is red or blue in this graph, and there could be
+ * self-edges and parallel edges.
+ *
+ * You are given two arrays redEdges and blueEdges where:
+ * - redEdges[i] = [ai, bi] indicates that there is a directed red edge from node ai
+ *   to node bi in the graph, and
+ * - blueEdges[j] = [uj, vj] indicates that there is a directed blue edge from node uj
+ *   to node vj in the graph.
+ *
+ * Return an array answer of length n, where each answer[x] is the length of the shortest
+ * path from node 0 to node x such that the edge colors alternate along the path, or -1
+ * if such a path does not exist.
+ */
+
+/**
+ * @param {number} n
+ * @param {number[][]} redEdges
+ * @param {number[][]} blueEdges
+ * @return {number[]}
+ */
+var shortestAlternatingPaths = function(n, redEdges, blueEdges) {
+  const redGraph = Array(n).fill().map(() => new Set());
+  const blueGraph = Array(n).fill().map(() => new Set());
+
+  for (const [from, to] of redEdges) redGraph[from].add(to);
+  for (const [from, to] of blueEdges) blueGraph[from].add(to);
+
+  const distances = Array(n).fill().map(() => [Infinity, Infinity]);
+  const queue = [[0, 0], [0, 1]];
+  distances[0] = [0, 0];
+
+  while (queue.length) {
+    const [node, color] = queue.shift();
+    const nextGraph = color ? redGraph : blueGraph;
+    const nextColor = 1 - color;
+
+    for (const nextNode of nextGraph[node]) {
+      if (distances[nextNode][nextColor] === Infinity) {
+        distances[nextNode][nextColor] = distances[node][color] + 1;
+        queue.push([nextNode, nextColor]);
+      }
+    }
+  }
+
+  return distances.map(([red, blue]) => {
+    const min = Math.min(red, blue);
+    return min === Infinity ? -1 : min;
+  });
+};