leetcode Course Schedule

题目链接

思路：
根据给出的依赖关系构建一个图。然后在图里面用深度优先遍历判断是否有回路。如果依赖有回路，那么就是无法完成的。

深度优先判断回路：

如果一个课可以修到，那么着色为黑色实现如下：
因为深度优先遍历是递归的，所以我们在刚刚进去一个点A的时候着色为灰，代表这个点还有依赖（子孙B）。如果我们在遍历子孙B的时候，发现子孙依赖的节点是灰色的（不妨假设子孙B依赖A），那么代表产生环了，这是就是环路依赖。如果子孙依赖黑色点C，那么依赖点C可以修到，可以返回。
如果点A的所有子孙都不产生环路依赖，那么A也是可以修到的，着色黑。

public class Solution {
    private boolean  graph[][];
    private int record[];
    private final int  black=2;
    private final int  gray=1;
    private final int  write=0;
    private int coursesCount;

    private boolean DFS(boolean graph[][],int rowIndex)
    {
        if(record[rowIndex]==write)
        {
            record[rowIndex]=gray;
        }
        else if(record[rowIndex]==gray)
        {
            return false;
        }
        else
        {
            return true;
        }
        for(int i=0;i<coursesCount;i++)
        {
            if(graph[rowIndex][i])
            {
                if(DFS(graph,i))
                {
                    continue;
                }
                else
                {
                    return false;
                }
            }
        }

        record[rowIndex]=black;
        return true;
    }



    public boolean canFinish(int numCourses, int[][] prerequisites) {
        coursesCount=numCourses;
        graph=new boolean[numCourses][numCourses];
        record=new int[numCourses];
        for(int i=0;i<prerequisites.length;i++)
        {
            for(int j=prerequisites[i].length-1;j>0;j--)
            {
                graph[prerequisites[i][j]][prerequisites[i][j-1]]=true;
            }
        }


        for(int i=0;i<numCourses;i++)
        {
            for(int j=0;j<numCourses;j++)
            {
                if(graph[i][j])
                {
                    if(DFS(graph,i))
                    {
                        continue;  
                    }
                    else
                    {
                        return false;
                    }
                }
            }
        }


        return true;


    }

}