feat: add No.210,785

Author: BaffinLee

201-300/210. Course Schedule II.md

@@ -0,0 +1,103 @@
+# 210. Course Schedule II
+
+- Difficulty: Medium.
+- Related Topics: Depth-First Search, Breadth-First Search, Graph, Topological Sort.
+- Similar Questions: Course Schedule, Alien Dictionary, Minimum Height Trees, Sequence Reconstruction, Course Schedule III, Parallel Courses, Find All Possible Recipes from Given Supplies, Build a Matrix With Conditions, Sort Array by Moving Items to Empty Space.
+
+## Problem
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where `prerequisites[i] = [ai, bi]` indicates that you **must** take course `bi` first if you want to take course `ai`.
+
+
+	
+- For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+
+Return **the ordering of courses you should take to finish all courses**. If there are many valid answers, return **any** of them. If it is impossible to finish all courses, return **an empty array**.
+
+ 
+Example 1:
+
+```
+Input: numCourses = 2, prerequisites = [[1,0]]
+Output: [0,1]
+Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].
+```
+
+Example 2:
+
+```
+Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+Output: [0,2,1,3]
+Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
+So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+```
+
+Example 3:
+
+```
+Input: numCourses = 1, prerequisites = []
+Output: [0]
+```
+
+ 
+**Constraints:**
+
+
+	
+- `1 <= numCourses <= 2000`
+	
+- `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
+	
+- `prerequisites[i].length == 2`
+	
+- `0 <= ai, bi < numCourses`
+	
+- `ai != bi`
+	
+- All the pairs `[ai, bi]` are **distinct**.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+var findOrder = function(numCourses, prerequisites) {
+    var requiredByMap = Array(numCourses).fill(0).map(() => []);
+    var requiringMap = Array(numCourses).fill(0);
+    for (var i = 0; i < prerequisites.length; i++) {
+        requiringMap[prerequisites[i][0]]++;
+        requiredByMap[prerequisites[i][1]].push(prerequisites[i][0]);
+    }
+    var queue = new MinPriorityQueue();
+    for (var j = 0; j < numCourses; j++) {
+        queue.enqueue(j, requiringMap[j]);
+    }
+    var res = [];
+    while (queue.size()) {
+        var item = queue.dequeue();
+        if (requiringMap[item.element] !== item.priority) continue;
+        if (item.priority !== 0) return [];
+        res.push(item.element);
+        for (var k = 0; k < requiredByMap[item.element].length; k++) {
+            requiringMap[requiredByMap[item.element][k]]--;
+            queue.enqueue(requiredByMap[item.element][k], requiringMap[requiredByMap[item.element][k]]);
+        }
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * log(n)).
+* Space complexity : O(n).

701-800/785. Is Graph Bipartite.md

@@ -0,0 +1,100 @@
+# 785. Is Graph Bipartite?
+
+- Difficulty: Medium.
+- Related Topics: Depth-First Search, Breadth-First Search, Union Find, Graph.
+- Similar Questions: Divide Nodes Into the Maximum Number of Groups.
+
+## Problem
+
+There is an **undirected** graph with `n` nodes, where each node is numbered between `0` and `n - 1`. You are given a 2D array `graph`, where `graph[u]` is an array of nodes that node `u` is adjacent to. More formally, for each `v` in `graph[u]`, there is an undirected edge between node `u` and node `v`. The graph has the following properties:
+
+
+	
+- There are no self-edges (`graph[u]` does not contain `u`).
+	
+- There are no parallel edges (`graph[u]` does not contain duplicate values).
+	
+- If `v` is in `graph[u]`, then `u` is in `graph[v]` (the graph is undirected).
+	
+- The graph may not be connected, meaning there may be two nodes `u` and `v` such that there is no path between them.
+
+
+A graph is **bipartite** if the nodes can be partitioned into two independent sets `A` and `B` such that **every** edge in the graph connects a node in set `A` and a node in set `B`.
+
+Return `true`** if and only if it is **bipartite****.
+
+ 
+Example 1:
+
+![](https://assets.leetcode.com/uploads/2020/10/21/bi2.jpg)
+
+```
+Input: graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
+Output: false
+Explanation: There is no way to partition the nodes into two independent sets such that every edge connects a node in one and a node in the other.
+```
+
+Example 2:
+
+![](https://assets.leetcode.com/uploads/2020/10/21/bi1.jpg)
+
+```
+Input: graph = [[1,3],[0,2],[1,3],[0,2]]
+Output: true
+Explanation: We can partition the nodes into two sets: {0, 2} and {1, 3}.
+```
+
+ 
+**Constraints:**
+
+
+	
+- `graph.length == n`
+	
+- `1 <= n <= 100`
+	
+- `0 <= graph[u].length < n`
+	
+- `0 <= graph[u][i] <= n - 1`
+	
+- `graph[u]` does not contain `u`.
+	
+- All the values of `graph[u]` are **unique**.
+	
+- If `graph[u]` contains `v`, then `graph[v]` contains `u`.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} graph
+ * @return {boolean}
+ */
+var isBipartite = function(graph) {
+    var map = {};
+    for (var i = 0; i < graph.length; i++) {
+        if (!dfs(graph, map, i)) return false;
+    }
+    return true;
+};
+
+var dfs = function(graph, map, i, group) {
+    if (map[i]) return !group || group === map[i];
+    map[i] = group || 1;
+    for (var j = 0; j < graph[i].length; j++) {
+        if (!dfs(graph, map, graph[i][j], map[i] === 1 ? 2 : 1)) return false;
+    }
+    return true;
+};
+```
+
+**Explain:**
+
+DFS with memorize.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n).