最短路总结 dijkstra spfa bellman-ford

bellman-ford: 边数限制为k 循环k次，每次更新点之间的最短距离，可以理解为每循环一次，就是从起点出发，往外多扩展一条边

spfa: 只有当前的dist[i]变小了，与i相邻的点的dist才会变小，将距离变小的点存入队列中

dijkstra:每次找一个最小距离，添加到最短路中，然后更新相邻距离

floyd:三层循环，动态规划

bellman - ford

循环k次 有边数限制 每次对每条边进行 dist[y]=min(dist[y],backup[x]+z); 松弛操作

/*这里i每加1就相当于从起点 往外多一条边  i为2就代表最多经过两条边到终点的距离 

i可以理解为从起点出发往外走几条边

走n-1条边就可以到达所有边  如果n-1之后还可以更新   那么就是有负环*/  ！！！
#include<bits/stdc++.h>

using namespace std;
const int N=1e4+10;
struct Edge{
    int a,b,w;
}edge[N];
int n,m,k;
int dist[N],backup[N];

void bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    
    //这里i每加1就相当于从起点 往外多一条边  i为2就代表最多经过两条边到终点的距离
    for(int i=1;i<=k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        for(int i=1;i<=m;i++) 
        {
            int x=edge[i].a,y=edge[i].b,z=edge[i].w;
            dist[y]=min(dist[y],backup[x]+z);
            //这里不一定每次都会更新 spfa在这里做优化
            //只有backup[x]变小了  dist[y]才会变小   spfa在这里做优化
        }
    }
    
    if(dist[n]>0x3f3f3f3f/2) puts("impossible");
    else printf("%d",dist[n]);
}

int main()
{
    scanf("%d%d%d",&n,&m,&k);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].w);
    }
    
    bellman_ford();
}

spfa

求负环：如果当前路径边数>=n 就说明存在负环 这就是判断原则

https://www.acwing.com/solution/content/92094/ 一篇关于负环的题解

每次更新距离 如果有距离更新 就把更新的点添加到队列中 直到队列为空

#include<bits/stdc++.h>

using namespace std;
const int N=1e5+10;
int h[N],e[N],ne[N],w[N],idx;
int n,m;
int dist[N];
bool st[N];

void add(int x,int y,int z)
{
    e[idx]=y,ne[idx]=h[x],w[idx]=z,h[x]=idx++;
}

void spfa()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    queue<int> q;
    q.push(1);
    st[1]=1;
    
    while(q.size())
    {
        int t=q.front();
        q.pop();
        st[t]=0;
        
        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]==0) q.push(j),st[j]=1;//这里st[j]记得更新  要不然会超时  已经在队列中的就不用再次入队
            }
        }
    }
    
    if(dist[n]==0x3f3f3f3f) puts("impossible");
    else printf("%d",dist[n]);
}

int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    while(m--)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
    }
    
    spfa();
}

求负环： https://www.acwing.com/solution/content/92094/ 超级源点

有负环会松弛无数次，dist会趋向于负无穷

#include<iostream>
#include<cstring>
#include<queue>

using namespace std;
const int N=100010;
int h[N],e[N],ne[N],w[N],idx;
int n,m;
int dist[N],cnt[N];
bool st[N];

void add(int x,int y,int z)
{
    e[idx]=y,ne[idx]=h[x],w[idx]=z,h[x]=idx++;
}

int spfa()
{
    //memset(dist,0x3f,sizeof dist);
    /*dist[1]=0;*/
    //有父权边   所以会有dist[j]>dist[t]+w[i]
    
    queue<int>q;
    for(int i=1;i<=n;i++)
    {
        st[i]=1;
        q.push(i);
    }
    
    while(q.size())
    {
        int t=q.front();
        q.pop();
        
        st[t]=0;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[t]+w[i])//这里是t  不是dist[i]
            {
                dist[j]=dist[t]+w[i];
                cnt[j]=cnt[t]+1;
                if(cnt[j]>=n) return 1;
                if(!st[j])  q.push(j),st[j]=1;
            }
        }
    }
    
    return 0;
}

int main()
{
    cin>>n>>m;
    
    memset(h,-1,sizeof h);
    int x,y,z;
    while(m--)
    {
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
    }
    
    
    if(spfa()) puts("Yes");
    else puts("No");
    
    return 0;
}

dijkstra

#include<bits/stdc++.h>

using namespace std;
const int N=150100;
int h[N],e[N],ne[N],idx,w[N];
int n,m;
int dist[N];
typedef pair<int,int> pii;
bool st[N];

void add(int x,int y,int z)
{
    //e[idx]=y,ne[idx]=h[x],w[idx]=z,ne[x]=idx++;
    e[idx]=y,ne[idx]=h[x],w[idx]=z,h[x]=idx++;
}

void dijk()
{
    //memset(dist,0x3f3f3f3f,sizeof dist);
    memset(dist,0x3f,sizeof dist);
    priority_queue<pii,vector<pii>,greater<pii>> heap;
    heap.push({0,1});
    dist[1]=0;
    
    while(heap.size())
    {
        auto t=heap.top();
        heap.pop();
        
        if(st[t.second]) continue;
        st[t.second]=1;
        
        int x=t.second;
        //for(int i=t.first;i!=-1;i=ne[i])
        //for(int i=ne[x];i!=-1;i=ne[i]) 这里ne[]中的下标是idx 并不是点x
        //这两种遍历方式都不对
        
        
        /*for(int i=h[x];i!=-1;i=ne[i])
        {
            dist[i]=min(dist[i],y+w[i]);
            heap.push({dist[i],i});
        }*/
        
        /*for(int i=h[x];i!=-1;i=ne[i]) //i只是一个下标
        {
            int j=e[i];
            //dist[j]=min(dist[j],y+w[i]);  //注意这里是w[i] 不是w[j]
            dist[j]=min(dist[j],dist[x]+w[i]);
            //dist[j]=dist[x]+w[i];
            heap.push({dist[j],j});
        }*/
        
        for(int i=h[x];i!=-1;i=ne[i])
        {
            int j=e[i];//i只是一个下标
            //dist[j]=min(dist[j],y+w[i]);  //注意这里是w[i] 不是w[j]
            if(dist[j]>dist[x]+w[i])
            {
                //dist[j]=min(dist[j],dist[x]+w[i]);
                dist[j]=dist[x]+w[i];
                heap.push({dist[j],j});
            }
            
        }
    }
    
    if(dist[n]==0x3f3f3f3f) printf("-1");
    else printf("%d",dist[n]);
}

int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    while(m--)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
    }
    
    dijk();
}

Floyd

#include<bits/stdc++.h>

using namespace std;
const int N=210;
int d[N][N];
int n,m,k;

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()
{
    memset(d,0x3f,sizeof d);
    scanf("%d%d%d",&n,&m,&k);
    while(m--)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        d[x][y]=min(d[x][y],z);
    }
    
    floyd();
    
    while(k--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        if(x==y) printf("0\n");//这个漏掉一个样例也过不了！！！
        else
        {
            if(d[x][y]>0x3f3f3f3f/2) puts("impossible");
            else printf("%d\n",d[x][y]);
        }
    }
}