相辅相成的求最单源短路径算法:（SPFA& dijkstra）

引用一位老oier的话：

一道题如果边权没有负数，那么一定是在卡SPFA。这时候就用到了堆优化的Dijkstra;

写在前面：
多打代码！
最好都掌握，灵活变通

SPFA:

主要用于稀疏图和有负权边的图上

参考blog：
https://blog.csdn.net/sxy201658506207/article/details/78779045

（前向星版）
注：起点为1

#include <cstdio>
#include <algorithm>

#define MAXN 11111
#define MAXM 222222
#define INF 2000000000

int n, m, cnt, ans;
int q[MAXN];//队列 
int p[MAXN];//用于打印解 
int is_fuquan[MAXN];//用于判断负圈 

int dis[MAXN], vis[MAXN]/*判断在不在队列中*/, head[MAXN];

struct edge {
    int  y, val, next;
}e[MAXM];//前向星 

void add_edge(int x, int y, int val) {
    cnt++;//边的个数加一 
    e[cnt].y = y;
    e[cnt].val = val;
    e[cnt].next = head[x]; //当前边上一条同起点的边的编号为head[x] 
    head[x] = cnt; //当前边为最后一条以x为起点的边的编号 
    return ;
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= m; i++) {
        int x, y, z; 
        scanf("%d%d%d", &x, &y, &z);
        add_edge(x, y, z);//**双向边** 
        add_edge(y, x, z);
    }

    for(int i = 1; i <= n; i++) dis[i] = INF; //初始化 
    int l = 1, r = 1;
    q[1] = 1; //起点入队 
    dis[1] = 0;  
    vis[1] = 1; 
    while(l <= r) {
        int now = q[l];
        l++;//更新队首 
        vis[now] = 0; //注意不在队列中 要标记为0即 **重复入队**
        for(int i = head[now]; i; i = e[i].next) { //遍历所有now的出边 (重点)
            int y = e[i].y, val = e[i].val; 
            if(dis[y] > dis[now] + val) { //看now所有出边的终点 是否 需要更新
                dis[y] = dis[now] + val; //更新长度 
                p[y] = i;//记录边
                if(vis[y] == 0) { //若终边不在队中 
                    q[++r] = y;
                    vis[y] = 1; //**y入队  标记为1** 
                    if(++is_fuquan[y] > n) return 0;//这可以是其他题目中需要返回的值
                     //这个就是用于发现负圈时及时退出（希望写在应该bool 值的SPFA函数中，然后返回false
                     //因为 一个点在没有负环的情况下，最多只会有 n-1 个点与它相连
                     //若有负环，这个便会一直for 所以这样做 
                }
            } 
        }
    }
    for(int i = 1; i <= n; i++)
        printf("%d ", dis[i]);
    return 0;
}

/*
4 6
1 2 2
2 3 2
2 4 1
1 3 5
3 4 3
1 4 4

dijkstra:

可以解不带负权边的图，在稠密图上有很好性能
参考blog：
ps:出自oier : https://www.cnblogs.com/jason2003/p/7222182.html
过程:
先建立一个dis数组，dis[i]表示第i号点到源点（1号点）的估计值, 然后我们在建立一个临界矩阵，叫做：map，map[i][j]=v表示从i到j这条边的权值是v, dis初始值除了源点本身都是无穷大。源点本身都是0. 我们用minn记录距离1号点最短的路径，留着以后会用。

开始第二次更新时: 以minn相当于把2当源点，求所有点到它的最短路，加上它到真正的源点（1号点）的距离，就是我们要求的最短路。

注:时时更新minn的值

代码:用邻接矩阵实现dijksra：

#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;
int map[110][110];//这就是map数组，存储图
int dis[10010];//dis数组，存储估计值
int vis[10010];//vis[i]代表这个点有没有被当做源点去搜索过，1为有，0为没有。这样就不会重复搜索了。
int n,m;
void dijkstra(int u)//主函数，参数是源点编号
{
    memset(dis,88,sizeof(dis));//把dis数组附最大值（88不是十进制的88，其实很大）
    int start=u;//先从源点搜索
    book[start]=1;//标记源点已经搜索过
    for(int i=1;i<=n;i++)
    {
        dis[i]=min(dis[i],map[start][i]);//先更新一遍
    }
    for(int i=1;i<=n-1;i++)
    {
        int minn=9999999;//这就是刚才所说的minn
        for(int j=1;j<=n;j++) {
        	if(vis[j]==0 && minn>dis[j])
            {
                minn=dis[j];
                start=j;
            }
		}//找到离源点最近的点，然后把编号记录下来，用于搜索。
        	
        vis[start]=1;        
        for(int j=1;j<=n;j++)
            dis[j]=min(dis[j],dis[start]+map[start][j]);//以新的点来更新dis。
    }
}
int main()
{
    cin>>n>>m;
    memset(map,88,sizeof(map));
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        map[a][b]=c;
    }
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(i==j)
                map[i][j]=0;
    dijkstra(1);//以1为源点。
    for(int i=1;i<=n;i++)
        cout<<dis[i]<<" ";
}

优化dijkstra：（堆）

朴素的这玩意貌似很慢大概O(n方)，堆优化应该只是取dis最小快了…吧
出自我自己
// Luogu P4779

#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
#define MAXN 120000
#define MAXM 233333
#define INF 1000003647

using namespace std;

int n, m, S, cnt;
int head[MAXN], dis[MAXN], vis[MAXN];

struct node {
    int id, dis; //id表示点的编号  dis为在加入优先队列时的dis[id] 
    node(int id = 0, int dis = 0) : id(id), dis(dis) {} //构造函数 
    bool operator < (const node &x) const { //重载运算符                 //只有堆是这样的 
        return dis > x.dis; //小根堆  注意  这里用>时  最后堆顶为dis最小的  和sort的comp相反 
    }
};

priority_queue <node> q; //优先队列   堆 

struct edge { 
    int y, val, next;
}e[MAXM];

void add_edge(int x, int y, int val) { //链式前向星 加边 
    e[++cnt].y = y;
    e[cnt].val = val;
    e[cnt].next = head[x];
    head[x] = cnt;
    return ;
}
//总是取最小的，无论它有没有被选 
//注：最开始初始化正无穷！！
//先放起点，并标记为已确定，再堆非空while（直到找完所有点的最短路） 
//取出堆顶，先看它是不是确定的，若不是，就直接确定下来 ，然后遍历它的出边，并更新终点dis值（需比较），再放入堆 
void dijkstra() {  
    for(int i = 1; i <= n; i++) dis[i] = INF;//初始化 
    q.push(node(S, 0)); //把起点加入 //加入编号&dis值 
    dis[S] = 0; // 初始化 
    while(!q.empty()) {
        node tmp = q.top();//当前所有元素中dis最小的 //取出来的是个node 
        q.pop(); //删除堆顶元素 
        int now = tmp.id; //当前点编号 
        if(vis[now]) continue; //若now为已确定元素（已知最短路的点） 则不执行下面语句 
        vis[now] = 1; //标记为已确定 //因为是堆 所以直接是最短的 //所以没有必要再找一遍 
        for(int i = head[now]; i; i = e[i].next) { //遍历边 
            int y = e[i].y; 
            if(dis[y] > tmp.dis + e[i].val) { //更新y的dis 
                dis[y] = tmp.dis + e[i].val;//dis[now] 和 tmp.dis不一定是一样的哦，有可能它已经更新为一个更小的值了
                q.push(node(y, dis[y])); //放入堆 
            }
        }
    }
    return ;
}

int main() {
    scanf("%d%d%d", &n, &m, &S);
    for(int i = 1, x, y, z; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        add_edge(x, y, z);
    }
    dijkstra();
    for(int i = 1; i <= n; i++)
        printf("%d ", dis[i]);
}

需要注意的是：存在负权环路的图中不存在最短路（路径可以一直减少），SPFA算法可以用来判断图中是否有负权环路

多源最短路出门下走至floyd