Dijkstra算法求最短路(朴素版)

图论中求最短路的算法有很多,这里使用一道模板题来介绍可以求单源最短路的Dijkstra算法
AcWing 849. Dijkstra求最短路 I

题意

求一个源点到 除了这个点之外其他所有的点 的最短距离， 不需要记录每条路径

困惑

这题一直困惑着我的是，为什么一开始找的最小的最短距离就是确定的最短距离？
想了好久，后来慢慢就理解了。
首先Dijkstra算法只能处理边权为正的图的最最短距离,既然所有边权都是正数，那么我们可以这样来想：

     遍历了源点到所有点的距离，这里会发现源点到某一个点的距离是最小的，那么有没有可能
     源点经过其它点然后再到这个点 的距离会更小吗？？？！！！
    
	 答案是绝对不可能的！
	 
     因为权值(i,j) > 权值(i,k),  且权值(j,k) > 0
     所以权值(i,j) + 权值(j,k)  > 权值(i,k)

这也是为什么Dijkstra算法只能用来处理所有边权为正的图,如果有一条边的权值为负,那么以上的证明就不会成立

解决方案

1.先输入点数和边数，然后输入全部有向边的数据，稠密图使用邻接矩阵，稀疏图使用邻接表或者链式前向星

2.初始化d[1] = 0 //因为第一个点是源点，而它到自身的距离就是0，暂时不初始化st[1]，等下再用

3.接下来做n次操作，每次操作都可以确定源点到一个点的最短距离

4.每次操作时，先把起点到所有点的最短距离遍历一次，利用贪心的思想，把最小的最短距离所在的那个点(这个点没有被确定为最短距离)保存下来

5.因为当前点到起点的最短距离是 没有被确定的所有点中最短的，因此使用这个点来更新起点到所有点的距离

6.重复n次4、5的步骤，这样就找到一个点到所有点的最短距离

代码

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

using namespace std;

const int N = 505, INF = 0x3f3f3f3f;

/*g为邻接矩阵,用来存储稠密图,d[i]表示i号点到源点的距离,
  n为点数,m为边数*/
int g[N][N], d[N], n, m;

/*st[i]为true,表示i号点到源点的最短距离已经确定;
  st[i]为false,表示i号点到源点的最短距离还没有确定*/
bool st[N];

int dijkstra() {
    memset(d, INF, sizeof d); //将源点到所有点的距离初始化为无穷大
    
    //这里把1号点当作源点,因此1号点到源点的最短距离可以确定为0
    d[1] = 0;  
    //n次操作,每次操作都会确定一个点到源点的最短距离
    for (int i = 0; i < n; i++) {
        //t为未确定到源点最短距离的点的索引
        int t = -1;   
        
        //找出未标记的点中离源点最近的点,点的范围是1~n
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || d[j] < d[t]))
                t = j;
                
        st[t] = 1; //标记这个点到源点的最短距离已经确定
        
        /*因为已经确定了一个点到源点的最短距离,
          那么就使用这个点作为中间点来更新其他点到源点的最短距离*/
        for (int j = 1; j <= n; j++)
            d[j] = min(d[j], d[t] + g[t][j]);
    }
    
    //如果源点到n号点的距离为无穷大级别,那么就返回-1;否则返回距离
    if (d[n] > INF / 2) return -1;
    return d[n];
}

int main() {
    scanf("%d%d", &n, &m);  
    memset(g, INF, sizeof g);//初始化邻接矩阵为无穷大
    
    //输入m条边的信息
    while (m--) {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        g[a][b] = min(g[a][b], c);
    }
    
    cout << dijkstra();
}

时间复杂度：O(nn)
空间复杂度：O(nn)
n为点数