acwing 849. Dijkstra求最短路(一) 朴素版本

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式
第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围
1≤n≤500,
1≤m≤10⁵,
图中涉及边长均不超过10000。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3

伪代码表示：

// dist 表示：源点（起点）到其余各点的距离， dist[i] 表示源点到节点i的距离， 初始时，各个元素无穷大 
// st   表示： 记录是否找到了源点到该节点的最短距离，st[i] == true ，表示找到了源点到节点i 的最短距离
int dist[n],st[n];
dist[1] = 0, st[1] = true;
for(i:1 ~ n)
{
    t <- 没有确定最短路径的节点（不在st中的点）中距离源点最近的点;
    s <- t
    用t 更新其他点的距离
}

下面有一个例子示范：

按照上面的步骤操作

1. 源点到源点的距离为 0。即dist[1] = 0。
   

2. 遍历 dist 数组，找到一个节点，这个节点是：没有确定最短路径的节点中距离源点最近的点。假设该节点编号为 i。此时就找到了源点到该节点的最短距离，state[i] 置为 1。

3. 遍历 i 所有可以到达的节点 j，如果 dist[j] 大于 dist[i] 加上 i -> j 的距离，即 dist[j] > dist[i] + w[i][j]（w[i][j] 为 i -> j 的距离） ，则更新 dist[j] = dist[i] + w[i][j]

4. 重复 2 3 步骤，直到所有节点的状态都被置为 1。

5. 此时 dist 数组中，就保存了源点到其余各个节点的最短距离。

代码实现：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 510;

int g[N][N];  //为稠密阵所以用邻接矩阵存储
int dist[N];  //用于记录每一个点距离第一个点的距离
bool st[N];   //用于记录该点的最短距离是否已经确定

int n,m;  // 用n 表示点数量，用m表示边数量

int Dijkstra()
{
    memset(dist, 0x3f, sizeof dist); //初始化距离  0x3f代表无限大
    
    dist[1] = 0; //第一个点到自身的距离为0]
    // st[1] = true;
    
     //有n个点所以要进行n次 迭代
    for(int i =0; i < n; i ++)
    {
        int t = -1; //t存储当前访问的点, 因为本题不涉及负边
        //这里的j代表的是从1号点开始， 这两行代码就是在st数组中所有为false点中找到 dist最小的点
        for(int j = 1; j <= n; j ++)
            //该步骤即寻找还未确定最短路的点中路径最短的点
            if(!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        st[t] = true;
        
         //依次更新每个点所到相邻的点路径值
        for(int j = 1; j <=n ;j ++)
            if(!st[j])   //可加可不加,因为最短的点都已经确定,加上可以减少循环,不加代码更简洁
                dist[j] = min(dist[j], dist[t] + g[t][j]);
    }
    
    //如果第n个点路径为无穷大即不存在最低路径
    if(dist[n] == 0x3f3f3f3f) return -1;   
    
    return dist[n];
}

int main()
{
    cin >> n >> m;
    
    memset(g, 0x3f, sizeof g);  //初始化图 因为是求最短路径, 所以每个点初始为无限大
    
    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);  //如果发生重边的情况则保留最短的一条边
    }
    
    cout << Dijkstra() << endl;
    
    return 0;
}