feat: solve 2642,815

Author: BaffinLee

2601-2700/2642. Design Graph With Shortest Path Calculator.md

@@ -0,0 +1,124 @@
+# 2642. Design Graph With Shortest Path Calculator
+
+- Difficulty: Hard.
+- Related Topics: Graph, Design, Heap (Priority Queue), Shortest Path.
+- Similar Questions: Number of Restricted Paths From First to Last Node, Closest Node to Path in Tree.
+
+## Problem
+
+There is a **directed weighted** graph that consists of `n` nodes numbered from `0` to `n - 1`. The edges of the graph are initially represented by the given array `edges` where `edges[i] = [fromi, toi, edgeCosti]` meaning that there is an edge from `fromi` to `toi` with the cost `edgeCosti`.
+
+Implement the `Graph` class:
+
+
+	
+- `Graph(int n, int[][] edges)` initializes the object with `n` nodes and the given edges.
+	
+- `addEdge(int[] edge)` adds an edge to the list of edges where `edge = [from, to, edgeCost]`. It is guaranteed that there is no edge between the two nodes before adding this one.
+	
+- `int shortestPath(int node1, int node2)` returns the **minimum** cost of a path from `node1` to `node2`. If no path exists, return `-1`. The cost of a path is the sum of the costs of the edges in the path.
+
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2023/01/11/graph3drawio-2.png)
+
+```
+Input
+["Graph", "shortestPath", "shortestPath", "addEdge", "shortestPath"]
+[[4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]], [3, 2], [0, 3], [[1, 3, 4]], [0, 3]]
+Output
+[null, 6, -1, null, 6]
+
+Explanation
+Graph g = new Graph(4, [[0, 2, 5], [0, 1, 2], [1, 2, 1], [3, 0, 3]]);
+g.shortestPath(3, 2); // return 6. The shortest path from 3 to 2 in the first diagram above is 3 -> 0 -> 1 -> 2 with a total cost of 3 + 2 + 1 = 6.
+g.shortestPath(0, 3); // return -1. There is no path from 0 to 3.
+g.addEdge([1, 3, 4]); // We add an edge from node 1 to node 3, and we get the second diagram above.
+g.shortestPath(0, 3); // return 6. The shortest path from 0 to 3 now is 0 -> 1 -> 3 with a total cost of 2 + 4 = 6.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= n <= 100`
+	
+- `0 <= edges.length <= n * (n - 1)`
+	
+- `edges[i].length == edge.length == 3`
+	
+- `0 <= fromi, toi, from, to, node1, node2 <= n - 1`
+	
+- `1 <= edgeCosti, edgeCost <= 106`
+	
+- There are no repeated edges and no self-loops in the graph at any point.
+	
+- At most `100` calls will be made for `addEdge`.
+	
+- At most `100` calls will be made for `shortestPath`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ */
+var Graph = function(n, edges) {
+    var map = Array(n).fill(0).map(() => []);
+    for (var i = 0; i < edges.length; i++) {
+        map[edges[i][0]].push([edges[i][1], edges[i][2]]);
+    }
+    this.map = map;
+};
+
+/** 
+ * @param {number[]} edge
+ * @return {void}
+ */
+Graph.prototype.addEdge = function(edge) {
+    this.map[edge[0]].push([edge[1], edge[2]]);
+};
+
+/** 
+ * @param {number} node1 
+ * @param {number} node2
+ * @return {number}
+ */
+Graph.prototype.shortestPath = function(node1, node2) {
+    var visited = {};
+    var queue = new MinPriorityQueue();
+    queue.enqueue(node1, 0);
+    while (queue.size()) {
+        var { element, priority } = queue.dequeue();
+        if (element === node2) return priority;
+        if (visited[element]) continue;
+        visited[element] = true;
+        this.map[element].forEach(item => {
+            queue.enqueue(item[0], item[1] + priority);
+        });
+    }
+    return -1;
+};
+
+/** 
+ * Your Graph object will be instantiated and called as such:
+ * var obj = new Graph(n, edges)
+ * obj.addEdge(edge)
+ * var param_2 = obj.shortestPath(node1,node2)
+ */
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * log(m)).
+* Space complexity : O(n).

801-900/815. Bus Routes.md

@@ -0,0 +1,123 @@
+# 815. Bus Routes
+
+- Difficulty: Hard.
+- Related Topics: Array, Hash Table, Breadth-First Search.
+- Similar Questions: Minimum Costs Using the Train Line.
+
+## Problem
+
+You are given an array `routes` representing bus routes where `routes[i]` is a bus route that the `ith` bus repeats forever.
+
+
+	
+- For example, if `routes[0] = [1, 5, 7]`, this means that the `0th` bus travels in the sequence `1 -> 5 -> 7 -> 1 -> 5 -> 7 -> 1 -> ...` forever.
+
+
+You will start at the bus stop `source` (You are not on any bus initially), and you want to go to the bus stop `target`. You can travel between bus stops by buses only.
+
+Return **the least number of buses you must take to travel from **`source`** to **`target`. Return `-1` if it is not possible.
+
+ 
+Example 1:
+
+```
+Input: routes = [[1,2,7],[3,6,7]], source = 1, target = 6
+Output: 2
+Explanation: The best strategy is take the first bus to the bus stop 7, then take the second bus to the bus stop 6.
+```
+
+Example 2:
+
+```
+Input: routes = [[7,12],[4,5,15],[6],[15,19],[9,12,13]], source = 15, target = 12
+Output: -1
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= routes.length <= 500`.
+	
+- `1 <= routes[i].length <= 105`
+	
+- All the values of `routes[i]` are **unique**.
+	
+- `sum(routes[i].length) <= 105`
+	
+- `0 <= routes[i][j] < 106`
+	
+- `0 <= source, target < 106`
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} routes
+ * @param {number} source
+ * @param {number} target
+ * @return {number}
+ */
+var numBusesToDestination = function(routes, source, target) {
+    if (source === target) return 0;
+    var stopToBusMap = {};
+    // O(n * m)
+    for (var i = 0 ; i < routes.length; i++) {
+        for (var j = 0; j < routes[i].length; j++) {
+            var stop = routes[i][j];
+            stopToBusMap[stop] = stopToBusMap[stop] || [];
+            stopToBusMap[stop].push(i);
+        }
+    }
+    // O(n * m * n)
+    var busToBusMap = Array(routes.length).fill(0).map(() => []);
+    for (var i = 0 ; i < routes.length; i++) {
+        var busMap = Array(routes.length);
+        for (var j = 0; j < routes[i].length; j++) {
+            var stop = routes[i][j];
+            stopToBusMap[stop].forEach(bus => {
+                bus !== i && !busMap[bus] && busToBusMap[i].push(bus);
+                busMap[bus] = true;
+            });
+        }
+    }
+    if (!stopToBusMap[target] || !stopToBusMap[source]) return -1;
+    var targetBusMap = stopToBusMap[target].reduce((map, bus) => {
+        map[bus] = true;
+        return map;
+    }, {});
+    var visited = Array(routes.length);
+    var queue = stopToBusMap[source];
+    var res = 1;
+    queue.forEach(bus => visited[bus] = true);
+    // O(n)
+    while (queue.length) {
+        var nextQueue = [];
+        for (var i = 0; i < queue.length; i++) {
+            var bus = queue[i];
+            if (targetBusMap[bus]) return res;
+            for (var j = 0; j < busToBusMap[bus].length; j++) {
+                var bus2 = busToBusMap[bus][j];
+                if (visited[bus2]) continue;
+                visited[bus2] = true;
+                nextQueue.push(bus2);
+            }
+        }
+        queue = nextQueue;
+        res += 1;
+    }
+    return -1;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n ^ 2 * m).
+* Space complexity : O(n * m).