最短路算法

一、单源最短路
1、Dijkstra(迪杰斯特拉)算法

假设图中1点为起点，求1点到其余个点的距离，将dis数组初始赋为极大值，且dis[1]=0。
从1开始，我们先更新和1直接相连的节点，更新节点2、3、4。而后又可以从这三个节点选择一个继续搜下去。因为我们求的是最短路，所以我们选一个目前dis最小的节点进行扩展。假设当前节点为u，扩展到的节点为v，两点之间边权为w，只要在扩展图中发现存在dis[v]<dis[u]+w 就可以直接更新dis[ v ]的值了。也就是说每次都找到一个点来更新其他所有点的dis。

struct node
{
    ll w;
    ll to;
    ll pre;
} edge[1000005];
ll head[1000005];
ll vis[1000005];
ll dis[1000005];
ll cnt;
ll n,m,s,t,k;
void init()
{
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(dis,0x3f,sizeof(dis));
    cnt=0;
}
void add(ll u,ll v,ll w)
{//链式前向星存图
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].pre=head[u];
    head[u]=cnt++;
}
void Dijkstra()
{
    priority_queue<pii,vector<pii>,greater<pii> > q;
    dis[s]=0;
    q.push({dis[s],s});
    while(!q.empty())
    {
        ll now=q.top().second;
        q.pop();
        if(vis[now])
        {
            continue;
        }
        vis[now]=1;
        for(ll i=head[now]; i!=-1; i=edge[i].pre)
        {
            ll v=edge[i].to;
            if(!vis[v]&&dis[v]>dis[now]+edge[i].w)
            {
                dis[v]=dis[now]+edge[i].w;
                q.push({dis[v],v});
            }
        }
    }
}

2、bellman_ford算法，可以求负权值
讲解
可以用在限制经过的边数的最短路

const int N=510,M=10010;
int dist[N],backup[N];
int n,m,k;
struct node
{
    int a,b,w;
}edge[M];
int bellman_ford()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    for(int i=0;i<k;i++)
    {//迭代次数表示至多经过了k条边的最短路
        memcpy(backup,dist,sizeof(dist));//储存上一次迭代结果，防止串
        for(int j=0;j<m;j++)
        {
            int a,b,w;
            a=edge[j].a,b=edge[j].b,w=edge[j].w;
            dist[b]=min(dist[b],backup[a]+w);
        }
    }
    if(dist[n]>0x3f3f3f3f/2)
    {//有可能一个inf跟了一个负权，然后更新了后一个节点，所以不是等于某个值
        return -1;//没有路径
    }
    return dist[n];
}

3、spfa算法
边权可以是负值，存在自环，重边。
讲解

struct node
{
    int w;
    int to;
    int pre;
} edge[1000005];
int head[1000005];
int vis[1000005];
int dist[1000005];
int cnt;
int n,m,s,t,k;
void init()
{
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(dis,0x3f,sizeof(dis));
    cnt=0;
}
void add(ll u,ll v,ll w)
{//链式前向星存图
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].pre=head[u];
    head[u]=cnt++;
}
int spfa()
{
    memset(dist,0x3f,sizeof(dist));
    dist[1]=0;
    queue<int>q;
    q.push(1);
    vis[1]=1;
    while(q.size())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;//这个点从队列中弹出，下次可以继续将该点加入
        for(int i=head[u],i!=-1;i=edge[i].pre)
        {
            int v=edge[i].to;
            if(dist[v]>dist[u]+edge[i].w)
            {
                dist[v]=dist[u]+edge[i].w;
                if(!vis[v])
                {//如果队列中没有这个点，将这个点加入队列
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    if(dist[n]==0x3f3f3f3f) return -1;
    else return dist[n];
}

spfa判断是否存在负环：
实质上是只加了一个cnt数组记录从起始点到该点的最短路上的边数，如果边数大于等于n，那么一定是存在负环。
题目在这里 讲解在这里

struct node
{
    int w;
    int to;
    int pre;
} edge[1000005];
int head[1000005];
int vis[1000005];
int dist[1000005];
int cnt;
int n,m,s,t,k;
void init()
{
    memset(vis,0,sizeof(vis));
    memset(head,-1,sizeof(head));
    memset(dis,0x3f,sizeof(dis));
    cnt=0;
}
void add(ll u,ll v,ll w)
{//链式前向星存图
    edge[cnt].to=v;
    edge[cnt].w=w;
    edge[cnt].pre=head[u];
    head[u]=cnt++;
}
int spfa()
{
    //memset(dist,0x3f,sizeof(dist));//因为不是求距离了，所以可以不用初始化
    queue<int>q;
    //q.push(1);//因为不是求从1开始的路上的环，所以需要将所有的点先放入队列中
    //vis[1]=1;
    for(int i=1;i<=n;i++)
    {
        vis[i]=1;
        q.push(i);
    }
    while(q.size())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int i=head[u],i!=-1;i=edge[i].pre)
        {
            int v=edge[i].to;
            if(dist[v]>dist[u]+edge[i].w)
            {
                dist[v]=dist[u]+edge[i].w;
                cnt[v]=cnt[u]+1;//到达u的边数加上1等于当前到达v的边数
                if(cnt[v]>=n) return 1;
                if(!vis[v])
                {
                    q.push(v);
                    vis[v]=1;
                }
            }
        }
    }
    return 0;
}

二、多源最短路
floyd一般处理多个询问的问题，规模较小的情况。floyd因为有可能出现inf更新负数的情况，所以不存在路的情况下d也会小于inf，所以，判断不存在的条件改成大于某一个较大的数，比如inf/2。
题目在这里 讲解在这里

#pragma GCC optimize(3,"Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
int n,m,Q;
int d[1000][1000];
void floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
            }
        }
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&Q);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {//初始化邻接矩阵
            if(i==j) d[i][j]=0;
            else d[i][j]=1e9;
        }
    }
    while(m--)
    {
        int a,b,w;
        scanf("%d%d%d",&a,&b,&w);
        d[a][b]=min(d[a][b],w);//如果有多条边，只取路径最短的就可以了
    }
    floyd();
    while(Q--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        //如果存在最大值也会更新的情况，判断路径不存在的条件就应该改成大于某一个极大数，因为有可能inf更新了负数导致它比inf小了
        if(d[a][b]>(1e9)/2) puts("impossible");
        else printf("%d\n",d[a][b]);
    }
    return 0;
}