代码随想录Day 58|拓扑排序、dijkstra算法精讲，题目:软件构建、参加科学大会

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

图论part08
- **拓扑排序精讲**
- [题目：117. 软件构建](#题目：117. 软件构建)
- 拓扑排序的背景
- - 解题思路：
  - 模拟过程
- **dijkstra（朴素版）精讲**
- [题目：47. 参加科学大会](#题目：47. 参加科学大会)
- - 解题思路
- 朴素版dijkstra
- - 模拟过程
- 总结

图论part08

拓扑排序精讲

题目：117. 软件构建

117. 软件构建 (kamacoder.com)

拓扑排序的背景

拓扑排序：

图论问题：拓扑排序是图论中的一个经典问题。
应用场景：
- 大学排课：需要按照先决条件排序课程。
- 文件处理：在项目安装或依赖管理中处理复杂的文件依赖关系。
处理大规模依赖：适用于处理成千上万的依赖关系。
检测循环依赖：拓扑排序可以发现循环依赖，即无法进行线性排序的情况。
排序目标：将有向图中的顶点转换为线性顺序。

解题思路：

广度优先搜索（BFS）：这是实现拓扑排序最常用的方法，简单易懂。
算法步骤：
- 入度表：首先构建一个入度表，记录每个顶点的入度，即指向该顶点的边的数量。
- 队列：将所有入度为0的顶点（即没有任何顶点指向的顶点）加入队列。
- 处理队列：当队列非空时，依次从队列中取出一个顶点，加入到拓扑排序的结果序列中，并减少与该顶点相邻的顶点的入度。如果相邻顶点的入度变为0，也将它们加入队列。
- 重复：重复上述过程，直到队列为空。
- 检测环：如果结果序列中的顶点数小于图中顶点的总数，说明图中存在环，无法进行拓扑排序。
深度优先搜索（DFS）：另一种实现拓扑排序的方法，但不是本篇的重点。
卡恩算法：1962年提出的拓扑排序算法，基于BFS。
核心思想：拓扑排序的核心思想是将有向无环图中的顶点进行线性排序，同时检测图中是否存在环。

拓扑排序的简单理解：

找起点：先找到所有没有任何前置条件（入度为0）的节点。
加入结果：把这些节点加入到一个结果列表中。
移除节点：从图中删除这些节点，以及它们指向的所有边。
重复：重复以上步骤，直到找不到入度为0的节点。
检测环：如果最后结果列表中的节点数和图中的节点数不一样，说明有环，无法完成排序。
输出：如果能找到完整的排序，就输出结果列表；否则，说明存在环，输出错误信息。

拓扑排序就是按照一定的顺序，把图中的节点排成一行，同时确保所有的依赖关系都得到满足。如果排不出这样的顺序，就说明图中有环，存在无法解决的依赖关系。

模拟过程

假设我们有以下的任务依赖关系：

复制代码

A -> C
A -> D
B -> C
C -> D

这意味着：

要执行任务C，必须先执行任务A。
要执行任务D，必须先执行任务A和C。
要执行任务C，必须先执行任务B。

我们来模拟拓扑排序的步骤：

步骤1：初始化

入度：A=0, B=0, C=2（A->C, B->C）, D=2（A->D, C->D）
依赖关系：A->(C, D), B->©, C->(D)
结果集：()

步骤2：找到入度为0的节点

A和B的入度都为0，我们可以选择A或B作为起点。这里我们选择A。

步骤3：加入结果集并移除节点

结果集变为：(A)
移除A及其依赖关系，更新入度：
- 移除A后，C的入度变为1（只剩B->C），D的入度变为1（只剩C->D）。

步骤4：重复步骤2

接下来，我们再次找入度为0的节点，现在B的入度为0。

步骤5：加入结果集并移除节点

结果集变为：(A, B)
移除B及其依赖关系，更新入度：
- 移除B后，C的入度变为0。

步骤6：重复步骤2

现在C的入度为0。

步骤7：加入结果集并移除节点

结果集变为：(A, B, C)
移除C及其依赖关系，更新入度：
- 移除C后，D的入度变为0。

步骤8：重复步骤2

最后，D的入度为0。

步骤9：加入结果集

结果集变为：(A, B, C, D)

步骤10：检测环

结果集的节点数等于图中的节点数，说明没有环，我们可以完成排序。

最终结果：(A, B, C, D)

这个顺序告诉我们，为了满足所有依赖关系，我们可以先执行A，然后执行B，接着执行C，最后执行D。

如果在这个过程中，我们发现无法再找到入度为0的节点，但结果集中的节点数小于图中节点的总数，那么我们可以确定图中存在环，无法进行拓扑排序。

最后代码如下：

cpp 复制代码

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;
int main() {
    int m, n, s, t;
    cin >> n >> m;
    vector<int> inDegree(n, 0); // 记录每个文件的入度

    unordered_map<int, vector<int>> umap;// 记录文件依赖关系
    vector<int> result; // 记录结果

    while (m--) {
        // s->t，先有s才能有t
        cin >> s >> t;
        inDegree[t]++; // t的入度加一
        umap[s].push_back(t); // 记录s指向哪些文件
    }
    queue<int> que;
    for (int i = 0; i < n; i++) {
        // 入度为0的文件，可以作为开头，先加入队列
        if (inDegree[i] == 0) que.push(i);
        //cout << inDegree[i] << endl;
    }
    // int count = 0;
    while (que.size()) {
        int  cur = que.front(); // 当前选中的文件
        que.pop();
        //count++;
        result.push_back(cur);
        vector<int> files = umap[cur]; //获取该文件指向的文件
        if (files.size()) { // cur有后续文件
            for (int i = 0; i < files.size(); i++) {
                inDegree[files[i]] --; // cur的指向的文件入度-1
                if(inDegree[files[i]] == 0) que.push(files[i]);
            }
        }
    }
    if (result.size() == n) {
        for (int i = 0; i < n - 1; i++) cout << result[i] << " ";
        cout << result[n - 1];
    } else cout << -1 << endl;


}