Improved tasks 84, 207

Author: javadev

src/main/scala/g0001_0100/s0084_largest_rectangle_in_histogram/Solution.scala

@@ -1,7 +1,9 @@
 package g0001_0100.s0084_largest_rectangle_in_histogram
 
 // #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Stack #Monotonic_Stack
-// #Big_O_Time_O(n_log_n)_Space_O(log_n) #2023_11_02_Time_904_ms_(71.43%)_Space_77.5_MB_(35.71%)
+// #Big_O_Time_O(n_log_n)_Space_O(log_n) #2024_06_02_Time_1092_ms_(71.43%)_Space_76.1_MB_(64.29%)
+
+import scala.util.control.Breaks.{break, breakable}
 
 object Solution {
     def largestRectangleArea(heights: Array[Int]): Int = {
@@ -54,12 +56,16 @@ object Solution {
     }
 
     private def checkIfSorted(a: Array[Int], start: Int, limit: Int): Boolean = {
-        for (i <- start + 1 until limit) {
-            if (a(i) < a(i - 1)) {
-                return false
+        var sorted = true
+        breakable {
+            for (i <- start + 1 until limit) {
+                if (a(i) < a(i - 1)) {
+                    sorted = false
+                    break
+                }
             }
         }
-        true
+        sorted
     }
 
     private def maxOfThreeNums(a: Int, b: Int, c: Int): Int = {

src/main/scala/g0201_0300/s0207_course_schedule/Solution.scala

@@ -2,42 +2,32 @@ package g0201_0300.s0207_course_schedule
 
 // #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Depth_First_Search
 // #Breadth_First_Search #Graph #Topological_Sort #Big_O_Time_O(N)_Space_O(N)
-// #2023_11_05_Time_548_ms_(87.81%)_Space_60_MB_(12.20%)
-
-import scala.collection.mutable.ArrayBuffer
+// #2024_06_02_Time_720_ms_(91.11%)_Space_61.7_MB_(75.56%)
 
 object Solution {
-    val WHITE = 0
-    val GRAY = 1
-    val BLACK = 2
-
     def canFinish(numCourses: Int, prerequisites: Array[Array[Int]]): Boolean = {
-        val adj = Array.fill(numCourses)(new ArrayBuffer[Int]())
-        prerequisites.foreach { pre =>
-            adj(pre(1)).append(pre(0))
-        }
-
-        val colors = Array.fill(numCourses)(WHITE)
-        (0 until numCourses).forall { i =>
-            if (colors(i) == WHITE && adj(i).nonEmpty && hasCycle(adj, i, colors)) {
-                false
-            } else {
-                true
-            }
+        import scala.collection.mutable.{Queue, ListBuffer}
+        val indegree = Array.fill(numCourses)(0)
+        val graph = Array.fill(numCourses)(new ListBuffer[Int])
+        for (data <- prerequisites) {
+            val course = data.head
+            val prerequisiteCourse = data.last
+            indegree(course) = indegree(course) + 1
+            graph(prerequisiteCourse) += course
         }
-    }
-
-    private def hasCycle(adj: Array[ArrayBuffer[Int]], node: Int, colors: Array[Int]): Boolean = {
-        colors(node) = GRAY
-        adj(node).foreach { nei =>
-            if (colors(nei) == GRAY) {
-                return true
-            }
-            if (colors(nei) == WHITE && hasCycle(adj, nei, colors)) {
-                return true
+        val startingCourses = indegree.zipWithIndex.filter(_._1.equals(0)).map(_._2)
+        val queue = Queue[Int](startingCourses: _*)
+        var courseTaken = 0
+        while (queue.nonEmpty) {
+            val current = queue.dequeue
+            courseTaken = courseTaken + 1
+            for (neighbor <- graph(current)) {
+                indegree(neighbor) = indegree(neighbor) - 1
+                if (indegree(neighbor).equals(0)) {
+                    queue.enqueue(neighbor)
+                }
             }
         }
-        colors(node) = BLACK
-        false
+        courseTaken == numCourses
     }
 }