leetcode刷题笔记 207题 与 210题 课程表Ｉ 与 课程表ＩＩ

leetcode刷题笔记 207题 与 210题 课程表Ｉ　与　课程表ＩＩ

源地址：

207. 课程表

210. 课程表 II

207问题描述：

你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-1 。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们：[0,1]

给定课程总量以及它们的先决条件，请你判断是否可能完成所有课程的学习？

示例 1:

输入: 2, [[1,0]]
输出: true
解释: 总共有 2 门课程。学习课程 1 之前，你需要完成课程 0。所以这是可能的。
示例 2:

输入: 2, [[1,0],[0,1]]
输出: false
解释: 总共有 2 门课程。学习课程 1 之前，你需要先完成课程 0；并且学习课程 0 之前，你还应先完成课程 1。这是不可能的。

提示：

输入的先决条件是由 边缘列表 表示的图形，而不是 邻接矩阵 。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
1 <= numCourses <= 10^5

//本题属于典型的拓扑排序问题,判断整个图中是否存在环
//可使用BFS 与 邻接表进行处理
import scala.collection.mutable
object Solution {
    def canFinish(numCourses: Int, prerequisites: Array[Array[Int]]): Boolean = {
        if (numCourses <= 0) return false
        val inDegree = new Array[Int](numCourses)
        val queue = mutable.Queue[Int]()
        val adjacency = List.fill(numCourses)(mutable.ListBuffer[Int]())
        var count = numCourses
        
        //统计入度 构建邻接表
        for (elem <- prerequisites) {
            inDegree(elem(0)) += 1
            adjacency(elem(1)).append(elem(0))
        }
        
        //将入度为0的节点插入队列
        for (i <- 0 to numCourses-1) {
            if (inDegree(i) == 0) queue.enqueue(i)
        }
        
        //将队列中的节点弹出,依据邻接表更新入度,若入度为0 则插入队列
        //每出队列一个节点,将计数减一
        while (queue.nonEmpty) {
                val pre = queue.dequeue
                //println("pre: " + pre)
                count -= 1
                for (cur <- adjacency(pre)){
                    inDegree(cur) -= 1
                    if (inDegree(cur) == 0) queue.enqueue(cur)
            }
        }
        
        //println(count)
        //count == 0 拓扑有序 所有节点出队列
        //count != 0 存在环
        return count == 0
  }
}

//DFS方法检测是否存在环
//flags用于记录节点状态
//	0 : 未访问
//	1 : 本轮已访问
// -1 : 之前已成功访问(不存在环情况)
import scala.collection.mutable
object Solution {
    def canFinish(numCourses: Int, prerequisites: Array[Array[Int]]): Boolean = {
    val adjacency = List.fill(numCourses)(mutable.ListBuffer[Int]())
    val flags = Array.fill(numCourses)(0)
    val result = mutable.ListBuffer[Int]()
    for (elem <- prerequisites) adjacency(elem(1)).append(elem(0))

    def dfs(i: Int): Boolean = {
        if (flags(i) == -1) return true
        if (flags(i) ==  1) return false
        flags(i) = 1
        for (elem <- adjacency(i)) {
            if (dfs(elem) == false) return false
        }
        flags(i) = -1
        result.prepend(i)
        return true
    }

    for (i <- 0 to numCourses-1) {
        if (dfs(i) == false) return List
    }
    return true
  }
}

​ 210问题描述：

现在你总共有 n 门课需要选，记为 0 到 n-1。

在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]

给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。

可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。

示例 1:

输入: 2, [[1,0]]
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
示例 2:

输入: 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] 。
说明:

输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
你可以假定输入的先决条件中没有重复的边。
提示:

这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
拓扑排序也可以通过 BFS 完成。

//BFS方法
//与207题基本一致,出队的节点放入result数组
import scala.collection.mutable
object Solution {
    def findOrder(numCourses: Int, prerequisites: Array[Array[Int]]): Array[Int] = {
        val inDegree = new Array[Int](numCourses)
        val queue = mutable.Queue[Int]()
        val adjacency = List.fill(numCourses)(mutable.ListBuffer[Int]())
        var count = numCourses
        val result = mutable.ArrayBuffer[Int]()
        
        for (elem <- prerequisites) {
            inDegree(elem(0)) += 1
            adjacency(elem(1)).append(elem(0))
        }
        
        for (i <- 0 to numCourses-1) {
            if (inDegree(i) == 0) queue.enqueue(i)
        }
        
        while (queue.nonEmpty) {
                val pre = queue.dequeue
                result.append(pre)
                //println("pre: " + pre)
                count -= 1
                for (cur <- adjacency(pre)){
                    inDegree(cur) -= 1
                    if (inDegree(cur) == 0) queue.enqueue(cur)
            }
        }
        
        if (count == 0) return result.toArray
        return Array()
    }
}

//DFS 将flags = -1的节点放入result
import scala.collection.mutable
object Solution {
    def findOrder(numCourses: Int, prerequisites: Array[Array[Int]]): Array[Int] = {
         val adjacency = List.fill(numCourses)(mutable.ListBuffer[Int]())
    val flags = Array.fill(numCourses)(0)
    val result = mutable.ListBuffer[Int]()
    for (elem <- prerequisites) adjacency(elem(1)).append(elem(0))

    def dfs(i: Int): Boolean = {
        if (flags(i) == -1) return true
        if (flags(i) ==  1) return false
        flags(i) = 1
        for (elem <- adjacency(i)) {
            if (dfs(elem) == false) return false
        }
        flags(i) = -1
        result.prepend(i)
        return true
    }

    for (i <- 0 to numCourses-1) {
        if (dfs(i) == false) return Array()
    }
   
    return result.toArray
    }
}