8.Dijkstra求最短路 I 朴素Dijkstra

 

 稠密图用邻接矩阵

稀疏图用邻接表

最短路问题

只有一个起点是单源

多个起点是多源

 n是点的数量，m是边的数量

朴素Dijkstra算法的时间复杂度和边数无关，适合稠密图（边数较多时），m和n ^ 2一个级别时

堆优化版的Dijkstra算法适用于稀疏图，n和m一个级别

SPFA算法是对Bellman- Ford算法进行了优化

　　但有些问题是SPFA算法无法解决的，经过不超过k条边的最短路，只能用Bellman- Ford算法

 Dijkstra基于贪心

Bellman- Ford基于离散数学

Floyd基于动态规划

==================================

然后先讲朴素Dijkstra，求的是从1号点到其他所有点的最短距离

基于贪心

1.初始化距离

　　首先1号点到自己的距离是0，其他点到1号点的距离是正无穷

2.循环n次

　　定义一个集合S，集合S里面存的是当前已经确定最短距离的点

　　然后每次循环，找到不在S中的，距离最近的点t

　　把t加进S里面

　　用t来更新其他所有点的距离

　　　　如何更新呢？

　　　　看一下从t出去的所有边，组成的路径能不能更新其他点的距离

　　　　比如t可以走到x

　　　　然后就看从起点到x的距离，能不能用从起点到t的距离更新

　　　　

 　　每一次循环都可以确定一个点的最短距离，那么循环n次的话，就可以确定n个点到起点的最短距离

#include <bits/stdc++.h>
using namespace std;
const int N = 510;
int g[N][N]; //稠密图用邻接矩阵
int dist[N]; //表示从1号点走到这个点的距离
bool st[N]; //表示每个点的最短路是否确定
int n, m;
int dijkstra() {
    //1.初始化距离
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;
    //2.遍历n次
    for (int i = 0; i < n; i++) {
        int t = -1;
        for (int j = 1; j <= n; j++) { //遍历所有点
            if (!st[j] && (t == -1 || dist[t] > dist[j])) {
                t = j;
            }
        }
        if (t == n) {
            break;
        }
        st[t] = true; //加进S
        for (int j = 1; j <= n; j++) { //用这个点更新其他点
            dist[j] = min(dist[j], dist[t] + g[t][j]);
        }
    }
    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;
}