最短路问题的模板复习

大部分摘自《算法竞赛进阶指南》

单源最短路问题

Dijkstra（边权为非负）

朴素版

原题链接

算法流程：
1、初始化dist[1]=0，其余节点的dist值为正无穷大。
2、找出一个未被标记的dist[x]最小的节点x，然后标记节点x。
3、扫描节点x的所有出边(x,y,z)，若dist[y]>dist[x]+z，则使用dist[x]+z更新dist[y]。
4、重复上述的两个步骤，直到所有节点都被标记。

代码实现：

#include<bits/stdc++.h>
#define N 500+10
using namespace std;

int n,m,v;
int d[N];
int a[N][N];
int used[N];

int main(){
    memset(d,0x3f,sizeof(d));
    memset(a,0x3f,sizeof(a));
    memset(used,0,sizeof(used));
    
    cin>>n>>m;
    for(int i=1;i<=n;i++)a[i][i]=0;
    for(int i=1;i<=m;i++){
        int x,y,z;cin>>x>>y>>z;
        a[x][y]=min(a[x][y],z);
    }
    
    d[1]=0;
    for(int i=1;i<=n;i++){
        int v=0;
        
        for(int j=1;j<=n;j++){
            if(used[j]==0){
                if(v==0)v=j;
                else if(d[j]<d[v])v=j;
            }
        }
        
        used[v]=1;
        for(int j=1;j<=n;j++)
            d[j]=min(d[j],d[v]+a[v][j]);
    }
    
    if(d[n]!=0x3f3f3f3f)cout<<d[n];
    else cout<<"-1";
    return 0;
}

堆优化版

原题链接

可以用二叉堆（C++STLpriority_queue）对dist数组进行维护，用O(log n)的时间获取最小值并从堆中删除。

代码实现：

#include<bits/stdc++.h>
#define N 100000+10
using namespace std;

int n,m,tot;
int d[N],used[N];
vector<int>v[N];
vector<int>val[N];

priority_queue<pair<int,int>>q;

void dijkstra(){
    memset(d,0x3f,sizeof(d));
    memset(used,0,sizeof(used));
    
    d[1]=0;
    q.push(make_pair(0,1));
    
    while(q.size()){
        int t=q.top().second;q.pop();
        if(used[t])continue;
        used[t]=true;
        
        for(int i=0;i<v[t].size();i++){
            int j=v[t][i],k=val[t][i];
            
            if(d[j]>d[t]+k){
                d[j]=d[t]+k;
                q.push(make_pair(-d[j],j));
            }
        }
    }
}

int main(){
    cin>>n>>m;
    
    for(int i=1;i<=m;i++){
        int x,y,z;cin>>x>>y>>z;
        if(x==y)continue;
        v[x].push_back(y);
        val[x].push_back(z);
    }
    
    dijkstra();
    
    if(d[n]==0x3f3f3f3f)d[n]=-1;
    cout<<d[n];
    return 0;
}

Bellman-Ford（有负权边）

算法流程：
1、扫描所有边(x,y,z)，若dist[y]>dist[x]+z，更新dist[y]。
2、重复上述步骤，直到没有更新操作发生。

可以用来解决有边数限制的最短路问题。

原题链接

代码实现：

#include<bits/stdc++.h>
#define N 10000+10
#define M 500+10
using namespace std;

int n,m,k;
int d[M],dl[M];
int st[N],ed[N],w[N];

int main(){
    memset(d,0x3f,sizeof(d));
    d[1]=0;
    cin>>n>>m>>k;
    
    for(int i=1;i<=m;i++)
        cin>>st[i]>>ed[i]>>w[i];
        
    for(int i=1;i<=k;i++){
        memcpy(dl,d,sizeof(dl));
        
        for(int j=1;j<=m;j++){
            if (d[ed[j]]>dl[st[j]]+w[j])
                d[ed[j]]=dl[st[j]]+w[j];
        }
    }
    
    if(d[n]<=0x3f3f3f3f/2)cout<<d[n];
    else cout<<"impossible";
    return 0;
}

Spfa（有负权边）

原题链接

算法流程：
1、建立一个队列，最初队列中只含起点1.
2、取出队头节点x，扫描它的左右出边(x,y,z)，若dist[y]>dist[x]+z，则使用dist[x]+z更新dist[y]。同时，若y不在队列中，则把y入队。
3、重复上述步骤，直到队列为空。

代码实现：

#include<bits/stdc++.h>
#define N 100000+10
using namespace std;

int n,m,tot;
int h[N],ve[N],e[N],ne[N],d[N];
bool v[N];

queue<int>q;

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

void spfa(){
    memset(d,0x3f,sizeof(d));
    memset(v,0,sizeof(v));
    
    d[1]=0;v[1]=true;
    q.push(1);
    
    while(q.size()){
        int t=q.front();q.pop();
        v[t]=false;
        
        for(int i=h[t];i;i=ne[i]){
            int j=ve[i];
            
            if(d[j]>d[t]+e[i]){
                d[j]=d[t]+e[i];
                
                if(!v[j])q.push(j),v[j]=true;
            }
        }
    }
}

int main(){
    cin>>n>>m;
    
    for(int i=1;i<=m;i++){
        int x,y,z;cin>>x>>y>>z;
        
        add(x,y,z);
    }
    
    spfa();
    
    if(d[n]==0x3f3f3f3f)cout<<"impossible";
    else cout<<d[n];
    
    return 0;
}

spfa还可以解决判断负环的问题。

代码实现：

#include<bits/stdc++.h>
#define N 100000+10
using namespace std;

int n,m,tot;
int h[N],ve[N],e[N],ne[N],d[N];
int cnt[N];
bool v[N];

queue<int>q;

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

bool spfa(){
    memset(d,0x3f,sizeof(d));
    memset(cnt,0,sizeof(cnt));
    memset(v,0,sizeof(v));
    
    d[1]=0;v[1]=true;
    cnt[1]=0;
    
    
    for(int i=1;i<=n;i++){
        q.push(i);v[i]=true;
    }
    
    while(q.size()){
        int t=q.front();q.pop();
        v[t]=false;
        
        for(int i=h[t];i;i=ne[i]){
            int j=ve[i];
            
            if(d[j]>d[t]+e[i]){
                d[j]=d[t]+e[i];
                cnt[j]=cnt[t]+1;
                
                if(cnt[j]>=n)return true;
                
                if(!v[j])q.push(j),v[j]=true;
            }
        }
    }
    
    return false;
}

int main(){
    cin>>n>>m;
    
    for(int i=1;i<=m;i++){
        int x,y,z;
        cin>>x>>y>>z;
        
        add(x,y,z);
    }
    
    if(spfa())cout<<"Yes";
    else cout<<"No";
    
    return 0;
}

多源多汇最短路问题

Floyd

原题链接

运用动态规划的思想。三重循环，二维数组。
状态转移方程：D[i,j]=min(D[i,j],D[i,k]+D[k,j])

代码实现：

#define N 200+10
using namespace std;

int n,m,tk;
int d[N][N];

int main(){
    memset(d,0x3f,sizeof(d));
    cin>>n>>m>>tk;
    
    for(int i=1;i<=n;i++)
        d[i][i]=0;
        
    for(int i=1;i<=m;i++){
        int x,y,z;
        cin>>x>>y>>z;
        
        d[x][y]=min(d[x][y],z);
    }
    
    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]);
                
    for(int k=1;k<=tk;k++){
        int i,j;cin>>i>>j;
        if(d[i][j]>=0x3f3f3f3f/2)cout<<"impossible"<<endl;
        else cout<<d[i][j]<<endl;
    }
    
    return 0;
}