leetcode210. 课程表 II 拓扑排序建图&入度矩阵+BFS

FakeOccupational

已于 2023-08-02 15:03:14 修改

阅读量389

点赞数

CC 4.0 BY-SA版权

分类专栏：笔记文章标签：算法深度优先 leetcode

于 2023-04-05 22:25:25 首次发布

本文链接：https://blog.youkuaiyun.com/ResumeProject/article/details/129974057

笔记专栏收录该内容

122 篇文章

订阅专栏

文章提供了解决LeetCode上的课程计划II问题的两种算法：BFS和DFS。BFS方法通过构建有向图，利用队列存储入度为0的节点，不断更新节点的入度并入队。DFS方法则通过深度优先搜索判断有向图中是否存在环，不存在环时进行拓扑排序。两种方法都用于确定满足先决条件的课程学习顺序。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述

https://leetcode.cn/problems/course-schedule-ii/

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

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

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

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {

    }
};

BFS

遵循BFS算法结构，使用queue< int >存储节点，队列中存储入度为0的节点索引。
每次从队首取结点（结点加入结果集），将这个结点(所指向的)邻接结点入度减 1，并判断是否入队。

#include <stdio.h>
#include <algorithm>
#include<vector>
#include<queue>
#include<iostream>
#include<memory>
#include "dfs.h"
using namespace std;



class Solution {
public:
    vector<bool> visit;
    vector<int> inDegree;
    vector<vector<int>> buildGraph(vector<vector<int>>& prerequisites,int numCourses) {
        vector<vector<int>> graph(numCourses);
        inDegree.resize(numCourses,0);//度数矩阵
        for (auto pre: prerequisites) {
            int from = pre[1];
            int to = pre[0];
            graph[from].push_back(to);
            inDegree[to]++;
        }
        return graph;
    }


    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<vector<int>> graph = buildGraph(prerequisites, numCourses);
        vector<int> res;
        queue<int> q;
        for (int i = 0; i < numCourses; ++i) {//首先，把所有入度为 0 的结点加入队列
            if (inDegree[i] == 0){
                q.push(i);
                res.push_back(i);
            }
        }
        int num = 0;
        while(!q.empty()) {
            int x = q.front();//入度为0节点
            num++;
            for (int i = 0; i < graph[x].size(); ++i) {//遍历邻接节点
                inDegree[graph[x][i]]--;
                if (inDegree[graph[x][i]] == 0) {
                    q.push(graph[x][i]);
                    res.push_back(graph[x][i]);
                }
            }
            q.pop();
        }
        if (res.size() < numCourses)return {};
        return res;
    }
};


int
main ()
{
    //Solution *myslo = new Solution();
    unique_ptr < Solution1 > myslo = unique_ptr < Solution1 > (new Solution1 ()); //unique_ptr < Solution1 > myslo = unique_ptr < Solution1 > (new Solution1 ());
    vector < vector < int >>v1 = { {1,0},{2,0},{3,1},{3,2}};
    vector<int> res = myslo->findOrder (4,v1);
    for(auto v : res){
        cout << v << endl;
    }
    cout << "*************************************************************" <<endl;
    //delete myslo;
    return 0;
}

DFS

在这里插入图片描述

注意：本题所建的图为有向图

// https://leetcode.cn/problems/course-schedule-ii/solution/ke-cheng-biao-ii-by-leetcode-solution/
来源：力扣（LeetCode）
#include <stdio.h>
#include <algorithm>
#include<vector>
#include<queue>
#include<iostream>
#include<memory>
using namespace std;



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

public:
    void dfs(int u) {
        // 将节点标记为「搜索中」
        visited[u] = 1;
        // 搜索其相邻节点
        // 只要发现有环，立刻停止搜索
        for (int v: edges[u]) {
            // 如果「未搜索」那么搜索相邻节点  (edges[u]已经提供了类似栈的结构记录临接节点，所以在遍历中没有使用栈)
            if (visited[v] == 0) {
                dfs(v);
                if (!valid) {
                    return;
                }
            }
            // 如果「搜索中」说明找到了环
            else if (visited[v] == 1) {
                valid = false;
                return;
            }
        }
        // 将节点标记为「已完成」
        visited[u] = 2;
        // 将节点放入result
        result.push_back(u);
    }

    vector<int> findOrder(int numCourses, vector<vector<int>>& 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;
    }
};





int
main ()
{
  //Solution *myslo = new Solution();
  unique_ptr < Solution > myslo = unique_ptr < Solution > (new Solution ());
  vector < vector < int >>v1 = { {1,0},{2,0},{3,1},{3,2}};
  vector<int> res = myslo->findOrder (4,v1);
  for(auto v : res){
      cout << v << endl;
  }
 
  cout << "*************************************************************" <<endl;
  //delete myslo;
  return 0;
}