leecode｜课程表

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

在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。

例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。
请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。

//转换一下就好做了，就是看这个有向图是否成环（自己指向自己）
//拓扑排序
class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        // 统计入度
        vector<int> in(numCourses, 0);
        vector<vector<int>> g(numCourses);
        for(auto p: prerequisites) {
            in[p[1]]++;
            g[p[0]].push_back(p[1]);
        }
        // 创建队列存储所有初始入度为0的点
        deque<int> nodes;
        for(int i=0; i<numCourses; i++) {
            if (in[i] == 0)
                nodes.push_back(i);
        }
        while(!nodes.empty()) {
            // 取出入度为0的点
            int n = nodes.front();
            nodes.pop_front();
            // 节点总数-1
            numCourses--;
            // 所有后驱节点的入度减1
            for(auto son: g[n]) {
                in[son]--;
                if(in[son]==0) {
                    nodes.push_back(son);
                }
            }
        }
        // 最后判断是否还有剩余节点
        return numCourses == 0;
    }
};

课程表II
现在你总共有 numCourses 门课需要选，记为 0 到 numCourses - 1。给你一个数组 prerequisites ，其中 prerequisites[i] = [ai, bi] ，表示在选修课程 ai 前 必须 先选修 bi 。

例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示：[0,1] 。
返回你为了学完所有课程所安排的学习顺序。可能会有多个正确的顺序，你只要返回 任意一种 就可以了。如果不可能完成所有课程，返回 一个空数组 。

class Solution {
private:
    // 存储有向图
    vector> edges;
    // 标记每个节点的状态：0=未搜索，1=搜索中，2=已完成
    vector visited;
    // 用数组来模拟栈，下标 0 为栈底，n-1 为栈顶
    vector result;
    // 判断有向图中是否有环
    bool valid = true;

public:
    void dfs(int u) {
        // 将节点标记为「搜索中」
        visited[u] = 1;
        // 搜索其相邻节点
        // 只要发现有环，立刻停止搜索
        for (int v: edges[u]) {
            // 如果「未搜索」那么搜索相邻节点
            if (visited[v] == 0) {
                dfs(v);
                if (!valid) {
                    return;
                }
            }
            // 如果「搜索中」说明找到了环
            else if (visited[v] == 1) {
                valid = false;
                return;
            }
        }
        // 将节点标记为「已完成」
        visited[u] = 2;
        // 将节点入栈
        result.push_back(u);
    }

    vector findOrder(int numCourses, vector>& prerequisites) {
        edges.resize(numCourses);
        visited.resize(numCourses);
        for (const auto& info: prerequisites) {
            edges[info[1]].push_back(info[0]);
        }
        // 每次挑选一个「未搜索」的节点，开始进行深度优先搜索
        for (int i = 0; i < numCourses && valid; ++i) {
            if (!visited[i]) {
                dfs(i);
            }
        }
        if (!valid) {
            return {};
        }
        // 如果没有环，那么就有拓扑排序
        // 注意下标 0 为栈底，因此需要将数组反序输出
        reverse(result.begin(), result.end());
        return result;
    }
};

课程表III
这里有 n 门不同的在线课程，按从 1 到 n 编号。给你一个数组 courses ，其中 courses[i] = [durationi, lastDayi] 表示第 i 门课将会 持续 上 durationi 天课，并且必须在不晚于 lastDayi 的时候完成。

你的学期从第 1 天开始。且不能同时修读两门及两门以上的课程。

返回你最多可以修读的课程数目。

class Solution {
public:
    int scheduleCourse(vector>& courses) {
        //根据结束时间排序（注意不是根据学习时长）
        int len = courses.size();
        sort(courses.begin(), courses.end(), [](vector&v1, vector&v2){return v1[1] < v2[1];});

        //优先队列，默认为大根堆
        priority_queue pQue;
        int totalDuration = 0;  //学习总时长

        for(int i = 0; i < len; ++i){
            int duration = courses[i][0], end = courses[i][1];
            pQue.push(duration);        //把当前课程信息压入队列
            totalDuration += duration;  //记录时间
            if(totalDuration > end){
                //总时间大于结束时间，说明不合法，要使得其合法，必须弹出一个元素
                totalDuration -= pQue.top();
                pQue.pop();
            }
        }
        return pQue.size();
    }
};

//经常是正难则反，可是经常逻辑是不清晰的

课程表IV
你总共需要上 numCourses 门课，课程编号依次为 0 到 numCourses-1 。你会得到一个数组 prerequisite ，其中 prerequisites[i] = [ai, bi] 表示如果你想选 bi 课程，你 必须 先选 ai 课程。

有的课会有直接的先修课程，比如如果想上课程 1 ，你必须先上课程 0 ，那么会以 [0,1] 数对的形式给出先修课程数对。
先决条件也可以是 间接 的。如果课程 a 是课程 b 的先决条件，课程 b 是课程 c 的先决条件，那么课程 a 就是课程 c 的先决条件。

你也得到一个数组 queries ，其中 queries[j] = [uj, vj]。对于第 j 个查询，您应该回答课程 uj 是否是课程 vj 的先决条件。

返回一个布尔数组 answer ，其中 answer[j] 是第 j 个查询的答案。

class Solution {
public:
    vector checkIfPrerequisite(int numCourses, vector>& prerequisites, vector>& queries) {
        //numCourses = 3, prerequisites = [[1,2],[1,0],[2,0]], queries = [[1,0],[1,2]]
        int n = numCourses;
        vector> graph(n);

        for(auto &pre : prerequisites){             //                              0   1       2
            graph[pre[0]].push_back(pre[1]);        //存储 起始点为pre[0]的相连的线段 [[], [o, 2], [0]]
        }

        vector> isReached(n, vector(n));
        for(int i = 0; i < n; ++i){
            queue q;
            q.push(i);
            while(!q.empty()){          //很妙BFS 把中间过渡点也捡起来了
                int u = q.front();
                q.pop();
                for(auto &v : graph[u]){            //i 和v 必定相连，那么i 和与v 做左端点的线段是否相连呢？如队试试看
                    if(!isReached[i][v]){
                        isReached[i][v] = true;
                        q.push(v);
                    }
                }
            }
        }
        vector ans;
        for(auto &query : queries){
            ans.push_back(isReached[query[0]][query[1]]);
        }
        return ans;
    }
};

简单总结一下：除了第三个是用了证明法，其余都是深度遍历BFS