代码随想录训练营Day 72|拓扑排序精讲、dijkstra（朴素版）精讲

1.拓扑排序精讲

代码随想录

题目：117. 软件构建

 代码：

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;
int main(){
    // 输入
    int n,m,s,t;
    cin >> n >> m;
    unordered_map<int,vector<int>> umap; // 记录文件间的依赖关系
    vector<int> indegree(n,0);
    vector<int> result;
    while(m--){
        cin >> s >> t;
        indegree[t]++;
        umap[s].push_back(t);
    }
    // 处理
    queue<int> que;
    for(int i = 0; i < n; i++){
        if(indegree[i] == 0) que.push(i);
    }
    while(que.size()){
        int cur = que.front();
        que.pop();
        result.push_back(cur);
        
        vector<int> files = umap[cur];
        if(files.size()){
            for(int i = 0; i < files.size(); i++){
                indegree[files[i]]--;
                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;
    }
}

思路：

每一次把入度为0的结点加入对列，选择对列头部的结点进行操作，保存该节点值到结果里，后弹出该节点，然后根据对列里的结点的依赖关系，找到此节点指向的结点，将这些结点的入度减1，同时如果发现有结点入度为0就加入对列。 

其实思路还是简单的，代码的话，就是用来一个数组来记录各个结点的入度，根据对列的操作动态更新；用一个unordered_map来记录结点间的依赖关系，在进行入队出队操作时，我们是根据这个依赖关系来找哪些结点的入度应该进行删减的。

2.dijkstra（朴素版）精讲

 代码随想录

题目：47. 参加科学大会（第六期模拟笔试） (kamacoder.com)

代码： 

#include <iostream>
#include <vector>
#include <climits>
using namespace std;
int main(){
    int n,m,p1,p2,val;
    cin >> n >> m;
    vector<vector<int>> grid(n + 1,vector<int>(n + 1,INT_MAX));
    for(int i = 0; i < m; i++){
        cin >> p1 >> p2 >> val;
        grid[p1][p2] = val;
    }
    
    int start = 1;
    int end = n;
    
    // 记录源点到每个节点的最短距离
    vector<int> minDist(n + 1,INT_MAX);
    vector<bool> visited(n + 1,false);
    
    minDist[start] = 0;
    
    for(int i = 1; i <= n; i++){ // 遍历所有结点
        int minVal = INT_MAX;
        int cur = 1;
        // 1.选择距离源点最近且未访问的结点
        for(int v = 1; v <= n; v++){
            if(!visited[v] && minDist[v] < minVal){
                minVal = minDist[v];
                cur = v;
            }
        }
        // 2.标记该结点已访问
        visited[cur] = true;
        // 3.更新非访问结点到源点的距离（即minDist数组）
        for(int v = 1; v <= n ; v++){
            if(!visited[v] && grid[cur][v] != INT_MAX && minDist[cur] + grid[cur][v] < minDist[v]){
                minDist[v] = minDist[cur] + grid[cur][v];
            }
        }
    }
    if(minDist[end] == INT_MAX) cout << -1 << endl; // 不能抵达终点
    else cout << minDist[end] << endl;
}

思路：其实就是贪心算法，从起点出发，去找和该结点直接相联的结点，加入到以访问的集合中，每次都从这个集合出发，扩大该集合，同时在扩大到过程中，选取距离起点最短的距离更新到minDist数组里。这样我们将全部的结点访问过一次后，就可以找到终点距离起点的最短距离了。