update

CongLinDev · CongLinDev · commit 2bdb0f4600c5 · 2019-07-30T17:11:50.000+08:00
diff --git a/0207-课程表.md b/0207-课程表.md
@@ -0,0 +1,58 @@
+# 课程表
+
+## 题目描述
+
+现在你总共有 n 门课需要选，记为 0 到 n-1。
+
+在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
+
+给定课程总量以及它们的先决条件，判断是否可能完成所有课程的学习？
+
+```
+输入: 2, [[1,0]] 
+输出: true
+解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
+
+输入: 2, [[1,0],[0,1]]
+输出: false
+解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成​课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。
+```
+
+你可以假定输入的先决条件中没有重复的边。
+
+## 分析
+
+使用一个队列保存入度为0的结点。然后将队列元素弹出，遍历给定数组，找到由该元素可到达的另一个元素。判断到达元素入度是否为0，若是，将其进入队列。
+
+## 算法
+
+```java
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] inDegree = new int[numCourses];
+        for (int i = 0; i < prerequisites.length; i++) {
+            inDegree[prerequisites[i][0]]++;
+        }
+        
+        Queue<Integer> queue = new LinkedList<>();
+        for(int i = 0; i < inDegree.length; i++){
+            if(inDegree[i] == 0)
+                queue.offer(i);
+        }
+        
+        int count = 0;
+        while(!queue.isEmpty()){
+            int num = queue.poll();
+            count++;
+            for (int[] p : prerequisites) {
+                if (p[1] == num) {
+                    inDegree[p[0]]--;
+                    if (inDegree[p[0]] == 0)
+                        queue.offer(p[0]);
+                }
+            }
+        }
+        return count == numCourses;
+    }
+}
+```
diff --git a/0210-课程表 II.md b/0210-课程表 II.md
@@ -0,0 +1,64 @@
+# 课程表 II
+
+## 题目描述
+
+现在你总共有 n 门课需要选，记为 0 到 n-1。
+
+在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
+
+给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
+
+可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
+
+```
+输入: 2, [[1,0]] 
+输出: [0,1]
+解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
+
+输入: 4, [[1,0],[2,0],[3,1],[3,2]]
+输出: [0,1,2,3] or [0,2,1,3]
+解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
+     因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
+```
+
+你可以假定输入的先决条件中没有重复的边
+
+## 分析
+
+使用一个队列保存入度为0的结点。然后将队列元素弹出，遍历给定数组，找到由该元素可到达的另一个元素。判断到达元素入度是否为0，若是，将其进入队列。
+
+在出队列的时候，保存结果即可。
+
+## 算法
+
+```java
+class Solution {
+    public int[] findOrder(int numCourses, int[][] prerequisites) {
+        int[] inDegree = new int[numCourses];
+        for (int i = 0; i < prerequisites.length; i++) {
+            inDegree[prerequisites[i][0]]++;
+        }
+
+        Queue<Integer> queue = new LinkedList<>();
+        for(int i = 0; i < inDegree.length; i++){
+            if(inDegree[i] == 0)
+                queue.offer(i);
+        }
+        int[] result = new int[numCourses];
+        int count = 0;
+        while(!queue.isEmpty()){
+            int num = queue.poll();
+            result[count++] = num;
+            for (int[] p : prerequisites) {
+                if (p[1] == num) {
+                    inDegree[p[0]]--;
+                    if (inDegree[p[0]] == 0)
+                        queue.offer(p[0]);
+                }
+            }
+        }
+        return count == numCourses ? result : new int[0];
+    }
+}
+
+```
diff --git a/0399-除法求值.md b/0399-除法求值.md
@@ -0,0 +1,102 @@
+# 除法求值
+
+## 题目描述
+
+给出方程式 `A / B = k`, 其中 `A` 和 `B` 均为代表字符串的变量， `k` 是一个浮点型数字。根据已知方程式求解问题，并返回计算结果。如果结果不存在，则返回 `-1.0`。
+
+示例 :
+给定 `a / b = 2.0,` `b / c = 3.0`
+问题:  `a / c = ?`, `b / a = ?`, `a / e = ?`, `a / a = ?`, `x / x = ?`
+返回 `[6.0, 0.5, -1.0, 1.0, -1.0 ]`
+
+基于上述例子，输入如下
+
+```
+equations(方程式) = [ ["a", "b"], ["b", "c"] ],
+values(方程式结果) = [2.0, 3.0],
+queries(问题方程式) = [ ["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"] ].
+```
+
+输入总是有效的。你可以假设除法运算中不会出现除数为0的情况，且不存在任何矛盾的结果
+
+## 分析
+
+并查集。
+
+详解请见 [详解](https://www.bilibili.com/video/av40929397?from=search&seid=5462235911348002192) 。
+
+## 算法
+
+```java
+
+class Solution {
+    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
+        Map<String, Node> map = new HashMap<>();
+
+        for(int i = 0; i < values.length; i++){
+            List<String> list = equations.get(i);
+
+            Node node1 = null, node2 = null;
+            if((node1 = map.get(list.get(0))) == null){
+                node1 = new Node(values[i]);
+                map.put(list.get(0), node1);
+            }
+
+            if((node2 = map.get(list.get(1))) == null){
+                node2 = new Node();
+                map.put(list.get(1), node2);
+            }
+
+            Node.union(node1, node2, values[i], map);
+        }
+
+        double[] result = new double[queries.size()];
+
+        for(int i = 0; i < result.length; i++){
+            List<String> list = queries.get(i);
+
+            Node node1, node2;
+            if((node1 = map.get(list.get(0))) != null && (node2 = map.get(list.get(1))) != null && Node.find(node1) == Node.find(node2)){
+                result[i] = node1.value / node2.value;
+            }else{
+                result[i] = -1.0;
+            }
+        }
+        return result;
+    }
+}
+
+class Node{
+    public double value;
+    public Node parent;
+    
+    public Node(){
+        this(1.0);
+    }
+    
+    public Node(double v){
+        value = v;
+        parent = this;
+    }
+    
+    public static Node find(Node node){
+        while(node != node.parent){
+            node = node.parent;
+        }
+        return node;
+    }
+    
+    public static void union(Node a, Node b, double num, Map<String, Node> map){
+        Node f1 = find(a);
+        Node f2 = find(b);
+        
+        double ratio = b.value * num / a.value;
+        
+        for(Node node : map.values()){
+            if(find(node) == f1)
+                node.value *= ratio;
+        }
+        f1.parent = f2;
+    }
+}
+```
diff --git a/0841-钥匙和房间.md b/0841-钥匙和房间.md
@@ -0,0 +1,61 @@
+# 钥匙和房间
+
+## 题目描述
+
+有 `N` 个房间，开始时你位于 `0` 号房间。每个房间有不同的号码：`0，1，2，...，N-1`，并且房间里可能有一些钥匙能使你进入下一个房间。
+
+在形式上，对于每个房间 `i` 都有一个钥匙列表 `rooms[i]`，每个钥匙 `rooms[i][j]` 由 `[0,1，...，N-1]` 中的一个整数表示，其中 `N = rooms.length`。 钥匙 `rooms[i][j] = v` 可以打开编号为 `v` 的房间。
+
+最初，除 `0` 号房间外的其余所有房间都被锁住。
+
+你可以自由地在房间之间来回走动。
+
+如果能进入每个房间返回 `true`，否则返回 `false`。
+
+```
+输入: [[1],[2],[3],[]]
+输出: true
+解释:  
+我们从 0 号房间开始，拿到钥匙 1。
+之后我们去 1 号房间，拿到钥匙 2。
+然后我们去 2 号房间，拿到钥匙 3。
+最后我们去了 3 号房间。
+由于我们能够进入每个房间，我们返回 true。
+
+输入：[[1,3],[3,0,1],[2],[0]]
+输出：false
+解释：我们不能进入 2 号房间。
+```
+
+1. 1 <= rooms.length <= 1000
+2. 0 <= rooms[i].length <= 1000
+3. 所有房间中的钥匙数量总计不超过 3000。
+
+## 分析
+
+广度优先搜索。使用一个队列保存每个房间的钥匙，然后依次去开房间，直到队列为空为止。
+
+## 算法
+
+```java
+class Solution {
+    public boolean canVisitAllRooms(List<List<Integer>> rooms) {
+        boolean[] visited = new boolean[rooms.size()];
+        int count = 1;
+        visited[0] = true;
+        Queue<Integer> queue = new LinkedList<>(rooms.get(0));
+
+        while(!queue.isEmpty()){
+            int room = queue.poll();
+            if(!visited[room]){
+                for(Integer i : rooms.get(room)){
+                    queue.offer(i);
+                }
+                count++;
+                visited[room] = true;
+            }
+        }
+        return count == rooms.size();
+    }
+}
+```
