Dijkstra算法求最短路

一 、Dijkstra 只适用于单源最短路中所有边权都是正数的情况

二 、存储方式

　　　　1、稠密图用邻接矩阵

　　　　2、稀疏图用邻接表

三 、算法实现

• 用一个 dist 数组保存源点到其余各个节点的距离，dist[i] 表示源点到节点 i 的距离。将dist数组赋值为正无穷,dist[1]=0

• 用一个状态数组 st 记录是否找到了源点到该节点的最短距离，state[i] 如果为真，则表示找到了源点到节点 i 的最短距离，state[i] 如果为假，则表示源点到节点 i 的最短距离还没有找到。

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

　　　　　　

• 遍历 i 所有可以到达的节点 j，如果 dist[j] 大于 dist[i] 加上 i->j 的距离 更新 dist[j] = min(dist[j] , dist[i] + w[i][j])

　　　　　　

 

• 重复以上步骤一直到个点的state状态为真　　　　

code:

1 : 邻接表实现

#include<iostream>
#define fast ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
using namespace std;
const int N = 101010;

int e[N], ne[N], h[N], w[N], idx;//邻接表

int dist[N], st[N];  //dist[i] 1号点到i号点的最短距离  st[i] i号点的最短路距离是否确定

int n, m, x, y, z;

void add(int a, int b,int c) {
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void Dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    for (int i = 1; i <= n; i++)
    {
        int t = -1;

        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[j] < dist[t])) t = j;

        for (int k = h[t]; k != -1; k = ne[k])
        {
            int i = e[k];
            if (dist[i] > dist[t] + w[k]) dist[i] = dist[t] + w[k];
        }
    }
}
int main()
{
    fast;
    memset(h, -1, sizeof h);

    cin >> n >> m;

    while (m--) {
    
        cin >> x >> y >> z;

        add(x, y, z);

    }

    Dijkstra();

    cout << dist[n];

    return 0;
}

 

2 : 邻接矩阵实现

#include<iostream>
#include<cstring>
#define fast ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define itn int
using namespace std;

const int N = 510;

int n, m;
int map[N][N];
bool st[10010];
int dist[N];

int dijkstra() {
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 1; i <= n; i++)
    {
        int t = -1;

        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[j] < dist[t])) t = j;

        st[t] = true;

        for (int k = 1; k <= n; k++)
            dist[k] = min(dist[k], dist[t] + map[t][k]);

    }
    if (dist[n] == 0x3f3f3f3f) return-1;
    return dist[n];
}

int main() {
    fast;

    cin >> n >> m;

    memset(map, 0x3f, sizeof map);

    for (int j = 1; j <= m; j++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        map[a][b] = min(map[a][b], c);
    }

    int t = dijkstra();

    cout << t;

    return 0;
}

dikstra算法时间复杂度为O(n^2) 主要耗时的步骤是从dist 数组中选出没有确定最短路径的节点中距离源点最近的点 t。

如果能在一组数中每次能很快的找到最小值，那么时间复杂度可以大大降低，这时候我们就能想到一种数据结构:优先队列

堆里存储距离和节点编号 pair<int,int>

优先队列定义 : priority_queue<Type, Container, Functional> 

Type 就是数据类型，Container 就是容器类型（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list。STL里面默认用的是vector），Functional 就是比较的方式，当需要用自定义的数据类型时才需要传入这三个参数，使用基本数据类型时，只需要传入数据类型，默认是大顶

#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>//堆的头文件

using namespace std;

typedef pair<int, int> PII;//堆里存储距离和节点编号

const int N = 1e6 + 10;

int n, m;//节点数量和边数
int h[N], w[N], e[N], ne[N], idx;//邻接表存储图
int dist[N];//存储距离
bool st[N];//存储状态

void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);//距离初始化为无穷大
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;//小根堆
    heap.push({0, 1});//插入距离和节点编号

    while (heap.size())
    {
        auto t = heap.top();//取距离源点最近的点
        heap.pop();

        int ver = t.second, distance = t.first;//ver:节点编号，distance:源点距离ver 的距离

        if (st[ver]) continue;//如果距离已经确定，则跳过该点
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])//更新ver所指向的节点距离
        {
            int j = e[i];
            if (dist[j] > dist[ver] + w[i])
            {
                dist[j] = dist[ver] + w[i];
                heap.push({dist[j], j});//距离变小，则入堆
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d", &n, &m);

    memset(h, -1, sizeof h);
    while (m -- )
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c);
    }

    cout << dijkstra() << endl;

    return 0;
}

总结：

Dijkstra算法适用于求正权有向图中，源点到其余各个节点的最短路径。注意：图中可以有环，但不能有负权边