单源最短路：Dijsktra，堆优化，Bellman-ford，SPFA

图论之单源最短路

0x3f 0x3f3f3f3f 的区别？
memset 按字节赋值，所以memset 0x3f 就等价与赋值为0x3f3f3f3f，

1. Dijkstra

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

int Dijkstra()
{
    memset(dist, 0x3f,sizeof dist);     //初始化距离  0x3f代表无限大

    dist[1]=0;  //第一个点到自身的距离为0

    for(int i=0;i<n;i++)      //有n个点所以要进行n次 迭代
    {
        int t=-1;       //t存储当前访问的点

        for(int j=1;j<=n;j++)   //这里的j代表的是从1号点开始
            if(!st[j]&&(t==-1||dist[t]>dist[j]))     
                t=j;

        st[t]=true;   

        for(int j=1;j<=n;j++)           //依次更新每个点所到相邻的点路径值
            dist[j]=min(dist[j],dist[t]+g[t][j]);
    }

    if(dist[n]==0x3f3f3f3f) return -1;  //如果第n个点路径为无穷大即不存在最低路径
    return dist[n];
}

2. 堆优化版的Dijkstra

堆优化版的dijkstra是对朴素版dijkstra进行了优化，在朴素版dijkstra中时间复杂度最高的寻找距离最短的点O(n^2)可以使用小根堆优化。

1. 一号点的距离初始化为零，其他点初始化成无穷大。
2. 将一号点放入堆中。
3. 不断循环，直到堆空。每一次循环中执行的操作为：
   弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。
   用该点更新临界点的距离，若更新成功就加入到堆中。

注意第一次入队, 不一定最短距离就确定了. 只要自己被别人更新过,就会入队.
但是第一次出队的时候, 最短路径一定就确定了. 想想dijksra的思想.

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1]=0;
    priority_queue<PII, vector<PII>, greater<PII> > heap;
    heap.push({0, 1});//first表示距离，second表示点的编号
    
    // 注意第一次入队, 不一定最短距离就确定了. 只要自己被
    // 别人更新过,就会入队.
    // 但是第一次出队的时候, 最短路径一定就确定了. 想想dijksra的思想.
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        
        int ver=t.second, distance=t.first;
        
        // 如果不加这句话,就超时了.
        if(st[ver]) continue;//处理冗余的点，就是已经确定了最短距离的点
        st[ver]= true;
        
        for(int i=h[ver]; i!=-1; i=ne[i])
        {
            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];
}

什么时候用到pair？有连带作用的时候。不管是出队入队还是排序。
一般情况下，数组就够了，数组下标进行映射，数组中的第i个元素，i就是指针。
i就是索引，在不同的数组或者结构体中索引同一个对象的不同属性。

3.Bellman-ford（有边数限制的最短路）

• SPFA算法各方面优于该算法，但是在碰到限制了最短路径上边的长度时就只能用bellman_ford了，此时直接把n重循环改成k次循环即可
• 如果边数限制为k，则外层循环为k，内层循环是枚举所有的边，对所有的边都进行一次松弛操作。如果没有边数限制的话，外层循环n次，内层每次松弛所有边，执行完之后一定会找到起点到终点的最短路了。
  原题链接：https://www.acwing.com/problem/content/855/
  这个题解写的好：https://www.acwing.com/solution/content/17551/

//这道题有收藏题解，写的挺不错的
#include<cstring>
#include<iostream>
#include<algorithm>
#include<stdio.h>
using namespace std;

const int N=510,M=10010;

int n,m,k;
int dist[N],backup[N];

struct Edge{
    int a,b,w;
}edges[M];

int bellman_ford()
{
    dist[1]=0;
    // 如果k是n的话，就不需要backup数组了
    for(int i=0;i<k;i++)
    {
        //为什么需要back[a]数组
//  为了避免串联情况，有可能1号点把2号点的距离更新了. 如果不用backup数组的话, 2号点会在本次循环中把3号点也更新了, 那就不对了. 计网中不是讲过吗
        memcpy(backup,dist,sizeof dist);
        
        for(int j=0;j<m;j++)//枚举所有的边，三角不等式！！
        {
            int a=edges[j].a,b=edges[j].b,w=edges[j].w;
            dist[b]=min(dist[b],backup[a]+w);
        }
        
        
    }
    // cout<<dist[n]<<endl;
    // if(dist[n]>0x3f3f3f3f/2) return -1;
    return dist[n];
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    memset(dist,0x3f3f3f3f,sizeof dist);
    for(int i=0;i<m;i++)
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        edges[i]={a,b,w};
    }
    
    int t=bellman_ford();
    
    // if(t==-1) puts("impossible");有道理，万一返回的t就是-1呢，那岂不是会输出impossible
    //应该直接返回dist[n],在外边判断
    if(dist[n]>0x3f3f3f3f/2) puts("impossible");
    else printf("%d\n",t);
    return 0;
}

4. SPFA

看这个题解：https://www.acwing.com/solution/content/9306/

Bellman_ford算法可以存在负权回路，是因为其循环的次数是有限制的因此最终不会发生死循环；但是SPFA算法不可以，由于用了队列来存储，只要发生了更新就会不断的入队，因此假如有负权回路请你不要用SPFA否则会死循环。

由于SPFA算法是由Bellman_ford算法优化而来，在最坏的情况下时间复杂度和它一样即时间复杂度为 O(nm)O(nm) ，假如题目时间允许可以直接用SPFA算法去解Dijkstra算法的题目。(好像SPFA有点小小万能的感觉?)

1. Dijkstra算法中的st数组保存的是当前确定了到源点距离最小的点，且一旦确定了最小那么就不可逆了(不可标记为true后改变为false)；SPFA算法中的st数组仅仅只是表示的当前发生过更新的点，且spfa中的st数组可逆(可以在标记为true之后又标记为false)。顺带一提的是BFS中的st数组记录的是当前已经被遍历过的点。

2. Dijkstra算法里使用的是优先队列保存的是当前未确定最小距离的点，目的是快速的取出当前到源点距离最小的点；SPFA算法中使用的是队列(你也可以使用别的数据结构),目的只是记录一下当前发生过更新的点。队列超时的时候，可以试试栈。这是玄学，一般判断环的时候用栈好一些。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

const int N=1e5+10;

#define fi first
#define se second

typedef pair<int,int> PII;//到源点的距离，下标号

int h[N],e[N],w[N],ne[N],idx=0;
int dist[N];//各点到源点的距离
bool st[N];
int n,m;
void add(int a,int b,int c){
    e[idx]=b;w[idx]=c;ne[idx]=h[a];h[a]=idx++;
}

int spfa(){
    queue<PII> q;
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    q.push({0,1});
    st[1]=true;
    while(q.size()){
        PII p=q.front();
        q.pop();
        int t=p.se;
        st[t]=false;//从队列中取出来之后该节点st被标记为false,代表之后该节点如果发生更新可再次入队
        // 枚举所有相连的边。
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                if(!st[j]){//当前已经加入队列的结点，无需再次加入队列，即便发生了更新也只用更新数值即可，重复添加降低效率
                    st[j]=true;
                    q.push({dist[j],j});
                }
            }
        }
    }
    if(dist[n]==0x3f3f3f3f) return -1;
    else 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);
    }
    int res=spfa();
    if(res==-1) puts("impossible");
    else printf("%d",res);

    return 0;
}