Course Schedule

最新推荐文章于 2020-04-30 10:16:30 发布

原创最新推荐文章于 2020-04-30 10:16:30 发布 · 399 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LeetCode #深搜 #dfs

算法专栏收录该内容

3 篇文章

订阅专栏

本文介绍了一个用于判断课程学习计划是否可行的算法实现。通过构建有向图并进行深度优先搜索来检测是否存在环，以此判断给定的先修课程关系是否会导致学习计划无法完成。

public class Solution {

    private Node[] nodes;

    private int[] tail;

    private int[] status;

    public boolean canFinish(int numCourses, int[][] prerequisites) {
        int len = prerequisites.length;
        if (len == 0) {
            return true;
        }
        this.tail = new int[numCourses];
        this.nodes = new Node[len + 1];
        for (int i = 1; i <= len; ++i) {
            int[] tmp = prerequisites[i - 1];
            this.nodes[i] = new Node(this.tail[tmp[0]], tmp[1]);
            this.tail[tmp[0]] = i;
        }
        this.status = new int[numCourses];
        for (int i = 0; i < numCourses; ++i) {
            if (this.status[i] == 0 && this.dfs(i)) {
                return false;
            }
        }
        return true;
    }

    private boolean dfs(int index) {
        this.status[index] = 1;
        for (int i = tail[index]; i != 0; i = this.nodes[i].getPre()) {
            int t = this.nodes[i].getChild();
            if (this.status[t] == 1) {
                return true;
            }
            if (this.status[t] == 0 && this.dfs(t)) {
                return true;
            }
        }
        this.status[index] = 2;
        return false;
    }

    private class Node {

        private int pre;

        private int child;

        public Node(int pre, int child) {
            this.pre = pre;
            this.child = child;
        }

        public int getPre() {
            return pre;
        }

        public int getChild() {
            return child;
        }

    }

}