solve #207

Author: aylei

src/lib.rs

@@ -174,3 +174,4 @@ mod n0203_remove_linked_list_elements;
 mod n0204_count_primes;
 mod n0205_isomorphic_strings;
 mod n0206_reverse_linked_list;
+mod n0207_course_schedule;

src/n0025_reverse_nodes_in_k_group.rs

@@ -29,24 +29,6 @@ use super::util::linked_list::{ListNode, to_list};
 
 // submission codes start here
 
-// Definition for singly-linked list.
-// #[derive(PartialEq, Eq, Debug)]
-// pub struct ListNode {
-//   pub val: i32,
-//   pub next: Option<Box<ListNode>>
-// }
-// 
-// impl ListNode {
-//   #[inline]
-//   fn new(val: i32) -> Self {
-//     ListNode {
-//       next: None,
-//       val
-//     }
-//   }
-// }
-
-// TODO: kind of verbose, try to simplify
 impl Solution {
     pub fn reverse_k_group(head: Option<Box<ListNode>>, k: i32) -> Option<Box<ListNode>> {
         let mut dummy_head = Some(Box::new(ListNode{val: 0, next: head}));

src/n0207_course_schedule.rs

@@ -0,0 +1,92 @@
+/**
+ * [207] Course Schedule
+ *
+ * There are a total of n courses you have to take, labeled from 0 to n-1.
+ * 
+ * Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]
+ * 
+ * Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: 2, [[1,0]] 
+ * Output: true
+ * Explanation: There are a total of 2 courses to take. 
+ *              To take course 1 you should have finished course 0. So it is possible.
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: 2, [[1,0],[0,1]]
+ * Output: false
+ * Explanation: There are a total of 2 courses to take. 
+ *              To take course 1 you should have finished course 0, and to take course 0 you should
+ *              also have finished course 1. So it is impossible.
+ * 
+ * 
+ * Note:
+ * 
+ * <ol>
+ * 	The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about <a href="https://www.khanacademy.org/computing/computer-science/algorithms/graph-representation/a/representing-graphs" target="_blank">how a graph is represented</a>.
+ * 	You may assume that there are no duplicate edges in the input prerequisites.
+ * </ol>
+ * 
+ */
+pub struct Solution {}
+
+// submission codes start here
+
+// topology sort, BFS
+use std::collections::VecDeque;
+impl Solution {
+    pub fn can_finish(num_courses: i32, prerequisites: Vec<Vec<i32>>) -> bool {
+        let num = num_courses as usize;
+        let mut matrix = vec![vec![false; num]; num];
+        let mut in_degree = vec![0; num];
+        // collects node in degree
+        for pre in prerequisites.iter() {
+            if !matrix[pre[1] as usize][pre[0] as usize] {
+                in_degree[pre[0] as usize] += 1;
+            }
+            matrix[pre[1] as usize][pre[0] as usize] = true;
+        }
+        let mut deq = VecDeque::new();
+        // BFS starts with nodes with 0 in degree
+        for (node, &v) in in_degree.iter().enumerate() {
+            if v == 0 {
+                deq.push_back(node);
+            }
+        }
+        let mut cnt = 0;
+        while let Some(node) = deq.pop_front() {
+            cnt += 1;
+            for (i, &connect) in matrix[node].iter().enumerate() {
+                if connect {
+                    in_degree[i] -= 1;
+                    if in_degree[i] == 0 {
+                        deq.push_back(i);
+                    }
+                }
+            }
+        }
+        cnt == num_courses
+    }
+}
+
+// submission codes end
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_207() {
+         assert_eq!(Solution::can_finish(2, vec![vec![1,0]]), true);
+         assert_eq!(Solution::can_finish(2, vec![vec![1,0],vec![0,1]]), false);
+        assert_eq!(Solution::can_finish(
+            8,
+            vec![vec![1,0],vec![2,6],vec![1,7],vec![6,4],vec![7,0],vec![0,5]]),
+                   true);
+    }
+}