leetcode Course Schedule

原题链接：https://leetcode.com/problems/course-schedule/

Description

There are a total of n courses you have to take, labeled from $0$ to $n - 1$.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: $[0,1]$

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

2, $[[1,0]]$
There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, $[[1,0],[0,1]]$
There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

拓扑排序。。

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {
        if (numCourses && prerequisites.empty()) return true;
        tot = 0;
        int num = 0, m = prerequisites.size();
        inq = new int[numCourses + 10];
        memset(inq, 0, sizeof(int)* (numCourses + 10));
        head = new int[numCourses + 10];
        memset(head, -1, sizeof(int)* (numCourses + 10));
        G = new edge[m + 10];
        for (int i = 0; i < m; i++) {
            int u = prerequisites[i].first, v = prerequisites[i].second;
            inq[v]++;
            add_edge(u, v);
        }
        queue<int> q;
        for (int i = 0; i < numCourses; i++) { if (!inq[i])  q.push(i); }
        while (!q.empty()) {
            num++;
            int u = q.front(); q.pop();
            for (int i = head[u]; ~i; i = G[i].next) {
                if (--inq[G[i].to] == 0) q.push(G[i].to);
            }
        }
        delete []G; delete []inq, delete []head;
        return num == numCourses;
    }
private:
    int tot, *inq, *head;
    struct edge { int to, next; }*G;
    inline void add_edge(int u, int v) {
        G[tot].to = v, G[tot].next = head[u], head[u] = tot++;
    }
};