Graph

Graph/CourseSchedule.swift

@@ -8,39 +8,32 @@
 
  class CourseSchedule {
     func canFinish(_ numCourses: Int, _ prerequisites: [[Int]]) -> Bool {
-        var inDegrees = Array(repeating: 0, count: numCourses), fromTo = [Int: [Int]]()
-        var coursesCouldTake = [Int](), queue = [Int]()
+        var inDegrees = Array(repeating: 0, count: numCourses), toCourses = [Int: [Int]]()
 
-        // init graph
-        for prerequisite in prerequisites {
-            fromTo[prerequisite[1], default: []].append(prerequisite[0])
-            inDegrees[prerequisite[0]] += 1
+        for courses in prerequisites {
+            inDegrees[courses[0]] += 1
+            toCourses[courses[1], default:[]].append(courses[0])
         }
 
-        // BFS
-        for course in 0..<numCourses {
-            if inDegrees[course] == 0 {
-                queue.append(course)
-            }
-        }
+        var queue = (0..<numCourses).filter { inDegrees[$0] == 0 }, validCourseCount = 0
 
         while !queue.isEmpty {
-            let currentCourse = queue.removeFirst()
-            coursesCouldTake.append(currentCourse)
+            let course = queue.removeFirst()
 
-            guard let toCourses = fromTo[currentCourse] else {
+            validCourseCount += 1
+
+            guard let toCourses = toCourses[course] else {
                 continue
             }
 
-            toCourses.forEach { 
-                inDegrees[$0] -= 1 
-
-                if inDegrees[$0] == 0 {
-                    queue.append($0)
+            for toCourse in toCourses {
+                inDegrees[toCourse] -= 1
+                if inDegrees[toCourse] == 0 {
+                    queue.append(toCourse)
                 }
             }
         }
-
-        return coursesCouldTake.count == numCourses
+        
+        return validCourseCount == numCourses
     }
 }

Graph/CourseScheduleII.swift

@@ -9,20 +9,15 @@
  class CourseScheduleII {
     func findOrder(_ numCourses: Int, _ prerequisites: [[Int]]) -> [Int] {
         var inDegrees = Array(repeating: 0, count: numCourses), fromTo = [Int: [Int]]()
-        var coursesCouldTake = [Int](), queue = [Int]()
+        var coursesCouldTake = [Int]()
 
         // init graph
         for prerequisite in prerequisites {
             fromTo[prerequisite[1], default: []].append(prerequisite[0])
             inDegrees[prerequisite[0]] += 1
         }
 
-        // BFS
-        for course in 0..<numCourses {
-            if inDegrees[course] == 0 {
-                queue.append(course)
-            }
-        }
+        var queue = (0..<numCourses).filter { inDegrees[$0] == 0 }
 
         while !queue.isEmpty {
             let currentCourse = queue.removeFirst()

Graph/EarliestMomentFriends.swift

@@ -0,0 +1,43 @@
+/**
+ * Question Link: https://leetcode.com/problems/the-earliest-moment-when-everyone-become-friends/
+ * Primary idea: Classic Union Find, union every node until the count drops down to 1.
+ * 
+ * Time Complexity: O(nlogn), Space Complexity: O(n)
+ *
+ */
+
+class EarliestMomentFriends {
+    func earliestAcq(_ logs: [[Int]], _ n: Int) -> Int {
+        let logs = logs.sorted { $0[0] < $1[0] }
+
+        var roots = Array(0..<n), count = n
+
+        for log in logs {
+            let time = log[0], friend1 = log[1], friend2 = log[2]
+
+            let root1 = find(friend1, roots)
+            let root2 = find(friend2, roots)
+
+            if root1 != root2 {
+                roots[root1] = root2
+                count -= 1
+            }
+
+            if count == 1 {
+                return time
+            }
+        }
+
+        return -1
+    }
+
+    private func find(_ node: Int, _ roots: [Int]) -> Int {
+        var node = node
+
+        while node != roots[node] {
+            node = roots[node]
+        }
+
+        return node
+    }
+}