最短路问题

单源最短路

这里如果是稠密图则用邻接矩阵，稀疏图是邻接表
1.所有边的权重都是正数
1.朴素迪杰斯特拉 O（n^2）
迪杰斯特拉算法就是循环n-1次，在n-1次里每次使用该次循环的最小值(最小值也需要循环一下下来find)来更新所有的的边边。

#include <iostream>
#include<cstring>
#include<algorithm>

using namespace std;
const int N=510;
int g[N][N];
int n,m;
int dist[N],cnt[N];

int djstl(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<n-1;i++){
        int t=-1;
        
        for(int j=1;j<=n;j++)
            if(!cnt[j]&&(t==-1||dist[t]>dist[j]))
                t=j;
        for(int j=1;j<=n;j++)
            dist[j]=min(dist[j],dist[t]+g[t][j]);
        cnt[t]=1;
    }
    
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];
}
int main(){
    cin.tie(0);
    memset(g,0x3f,sizeof g);
    
    cin>>n>>m;
    
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }
    cout<<djstl()<<endl;
}

2.堆优化版迪杰斯特拉O(mlogn)
堆优化就是用个小根堆来存储，然后把最小的那个拿出来更新，然后撇掉。

#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>

using namespace std;
const int N=1e6+10;
int h[N],e[N],ne[N],w[N],idx;
int cnt[N];
int dist[N];
int n,m;
typedef pair <int,int>PII;

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

int djstl(){
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0,1});
    while(heap.size()){
        int t=heap.top().second;
        heap.pop();
        if(cnt[t])continue;
        cnt[t]=1;
        
        for(int i=h[t];i!=-1;i=ne[i]){
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                heap.push({dist[j],j});
            }
            
        }
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];
}
int main(){
    cin.tie(0);
    memset(h,-1,sizeof h);
    cin>>n>>m;
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    cout<<djstl()<<endl;
}

2.存在负数边
1.贝尔曼佛雷算法 O(nm) 如果有负权回路的话可能是找不到最短路的，这里可以用于判断负环的存在，迭代次数k>=n！！！！有边数限制的最短路径问题就只能用这个算法，其他时候SPFA算法优于它
存储边的方式就是开个结构体数据a,b,w(边长；
方法：
循环所有的边dist[b]=min(dist[b],dist[a]+w);
这里就是说for（k次循环（这里的k就是最多可以走几条边））
再嵌套一个遍历每条边的循环，然后更新每条边！注意因为我更新前面的边的长度的时候，可能会造成后面边更新关联，所以在更新前先copy一份。

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 510, M = 10010;

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

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

int bem(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++){
        memcpy(last,dist,sizeof dist);
        for(int j=0;j<m;j++){
            Edge edge =edges[j];
            dist[edge.b]=min(dist[edge.b],last[edge.a]+edge.c);
        }
    }
    return dist[n];
}
int main(){
    cin.tie(0);
    cin>>n>>m>>k;
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        edges[i].a=a;edges[i].b=b;edges[i].c=c;
    }
    
    if(bem()>=0x3f3f3f3f/2)cout<<"impossible"<<endl;
    else cout<<dist[n]<<endl;
}

2.SPFA O(m),最坏O(nm)
SPFA的算法就是说，在贝尔曼算法上用一点bfs的思想，由于每一次更新最短路就是由于它上一个节点的最短路被更新所以它才有可能更新，因此我们把每个更新的点加入queue中，来遍历更新；
判断负环存在就是多开一个变量，用于记录走到这个节点的最短路的点的个数，当然最多只有n-1个咯，如果超过n个name一定会有负环存在。

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

using namespace std;
const int N=100010;

int h[N],e[N],ne[N],w[N],idx;
int cnt[N];
int dist[N];
int n,m;

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

void spfa(){
    memset(dist,0x3f,sizeof dist);
    queue<int> q;
    q.push(1);
    cnt[1]=1;
    dist[1]=0;
    
    while(q.size()){
        int t =q.front();
        q.pop();
        cnt[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 (!cnt[j])
                {
                    q.push(j);
                    cnt[j] = 1;
                }
            }
        }
    }
}
int main(){
    cin>>n>>m;
    memset(h,-1,sizeof h);
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    spfa();
    
    if(dist[n]>=0x3f3f3f3f)cout<<"impossible"<<endl;
    else cout<<dist[n]<<endl;
}

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

using namespace std;

const int N=100010;

int h[N],e[N],ne[N],cnt[N],idx;
int dist[N],st[N],tt[N];
int n,m;

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

int spfa(){
    queue<int> q;
    memset(dist,0x3f,sizeof dist);
    
    for(int i=1;i<=n;i++){
        st[i]=1;
        q.push(i);
    }
    dist[1]=0;
    while(q.size()){
        int k=q.front();
        q.pop();
        st[k]=0;
        for(int i=h[k];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[k]+cnt[i]){
                dist[j]=dist[k]+cnt[i];
                tt[j]=tt[k]+1;
                if(tt[j]>=n)return 1;
                
                if(!st[j]){
                    q.push(j);
                    st[j]=1;
                }
                
                
            }
        }
    }
    return 0;
}
int main(){
    cin.tie(0);
    cin>>n>>m;
    memset(h,-1,sizeof h);
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    if(spfa())cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}

多元汇最短路

1.Floyd算法O(n^3)
这个算法就是存储一个邻接矩阵，然后三层循环，一定要先循环k，i，j随便，dist【i】【j】=min（dist【i】【k】+dist【k】【j】，dist【i】【j】）；

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

int n,m,k;

int e[210][210];

void fl(){
    for(int k=1;k<=n;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                e[i][j]=min(e[i][j],e[i][k]+e[k][j]);
            }
        }
    }
}

int main(){
    cin.tie(0);
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j)e[i][j]=0;
            else e[i][j]=1e9;
        }
    }
    while(m--){
        int a,b,c;
        cin>>a>>b>>c;
        e[a][b]=min(e[a][b],c);
    } 
    fl();
    while(k--){
        int a,b;
        cin>>a>>b;
        if(e[a][b]>=1e9/2)cout<<"impossible"<<endl;
        else cout<<e[a][b]<<endl;
    }
}