最短路模版整理

接着前一篇，整理完最小生成树的模版，接下来整理一下最短路的模版。

所有题目都是根据HDU 1874 写的。

图论中求最短路的算法比较多，有Dijkstra、Bellman-ford、Floyd-Warshall、以及SPFA。主要用到的就是这么几个算法。下面一一介绍。

一、Dijkstra

这个算法的做法就是，每次找到一个距源点距离最近的点，然后扩展这个与这个点相邻的点的距离。 这个算法只能针对非负权图进行求单源最短路，算法复杂度是O(V^2)（不优化），但是可以通过堆优化（我就用优先队列写写吧。。）复杂度可以降到O(V+ElogV)

未优化模版：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
struct edge{
    int u,v,next,w;
}e[1005];
int head[205],cnt;
int d[205],vis[205];
int n,m;
void addedge(int u,int v,int w){
    e[cnt].u = u;
    e[cnt].v = v;
    e[cnt].w = w;
    e[cnt].next = head[u];
    head[u] = cnt++;
}
int Dijkstra(int s,int t){
    memset(d,0x3f,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s] = 0;
    for(int i=0;i<n;i++){
        int k = -1,minn = INF;
        for(int j=0;j<n;j++)
            if(!vis[j]&&d[j]<minn)
                minn = d[j],k = j;
        if(k == -1)break;
        vis[k] = 1;
        for(int j = head[k];j!=-1;j = e[j].next){
            int v = e[j].v,w = e[j].w;
            if(!vis[v]&& d[v]>d[k]+w)
                d[v] = d[k]+w;
        }
    }
    if(d[t] == INF)return -1;
    return d[t];
}
int main()
{
    while(scanf("%d%d",&n,&m)==2){
        int u,v,w;
        memset(head,-1,sizeof(head));
        cnt = 0;
        while(m--){
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        scanf("%d%d",&u,&v);
        printf("%d\n",Dijkstra(u,v));
    }
    return 0;
}

对于找最小值的过程，可以用堆优化，为了方便，用优先队列实现。

模版如下

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
typedef pair<int ,int > PII;
struct edge{
    int u,v,next,w;
}e[1005];
int head[205],cnt;
int d[205],vis[205];
int n,m;
void addedge(int u,int v,int w){
    e[cnt].u = u;
    e[cnt].v = v;
    e[cnt].w = w;
    e[cnt].next = head[u];
    head[u] = cnt++;
}
int Dijkstra(int s,int t){
    memset(d,0x3f,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s] = 0;
    priority_queue <PII,vector<PII>,greater<PII> >q;
    q.push(make_pair(d[s],s));
    while(!q.empty()){
        PII t = q.top();
        q.pop();
        vis[t.second] = 1;
        int k = t.second;
        for(int j = head[k];j!=-1;j = e[j].next){
            int v = e[j].v,w = e[j].w;
            if(!vis[v]&&d[v]>d[k]+w)
                d[v] = d[k]+w,q.push(make_pair(d[v],v));
        }
    }
    if(d[t] == INF)return -1;
    return d[t];
}
int main()
{
    while(scanf("%d%d",&n,&m)==2){
        int u,v,w;
        memset(head,-1,sizeof(head));
        cnt = 0;
        while(m--){
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
        }
        scanf("%d%d",&u,&v);
        printf("%d\n",Dijkstra(u,v));
    }
    return 0;
}

二、Bellman-Ford

这个算法思想特别神奇。将起点的距离设为0，其他点设为INF，对于每一条边都做一次松弛操作。总共进行n-1次这样的操作。这样之后，dis数组里存的就是s到各点的最短距离。其实每次操作都只是更新了前一次更新的点，所以进行了很多不必要的扫描。SPFA正是把这些不必要的操作去掉得到的优化。

Bellman-Ford(普通做法 复杂度O(VE))

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
struct edge{
    int u,v,w;
}e[1005];
int n,m,cnt;
int d[205];
int Bellman_ford(int s){
    memset(d,0x3f,sizeof(d));
    d[s] = 0;
    for(int i=1;i<n;i++)
        for(int j=1;j<=cnt;j++)
            d[e[j].v] = min(d[e[j].v],d[e[j].u]+e[j].w);
    for(int i=1;i<=cnt;i++)
        if(d[e[i].v]>d[e[i].u]+e[i].w)return 0;
    return 1;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2){
        int u,v,w,st,ed;
        cnt = 0;
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&u,&v,&w),e[++cnt].u = u,e[cnt].v = v,e[cnt].w = w;
            e[++cnt].u = v,e[cnt].v = u,e[cnt].w = w;
        }
        scanf("%d%d",&st,&ed);
        int ok = Bellman_ford(st);
        if(ok && d[ed]!=INF)printf("%d\n",d[ed]);
        else puts("-1");
    }
    return 0;
}

SPFA(好用，好写，复杂度小)

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
struct edge{
    int u,v,w,next;
}e[1005];
int head[205],d[205],inq[205],cnt,n,m;
void addedge(int u,int v,int w){
    e[cnt].u = u;
    e[cnt].v = v;
    e[cnt].w = w;
    e[cnt].next = head[u];
    head[u] = cnt++;
}
int SPFA(int s){
    memset(inq,0,sizeof(inq));
    memset(d,0x3f,sizeof(d));
    d[s] = 0;
    queue<int>q;
    q.push(s);
    while(!q.empty()){
        int t = q.front();
        q.pop();
        inq[t] = 0;
        for(int i=head[t];i!=-1;i = e[i].next){
            int v = e[i].v,w = e[i].w;
            if(d[v]>d[t]+w){
                d[v] = d[t]+w;
                if(!inq[v])inq[v] = 1,q.push(v);
            }
        }
    }
    for(int i=0;i<cnt;i++)
        if(d[e[i].v]>d[e[i].u]+e[i].w)return 0;
    return 1;
}
int main()
{
    while(scanf("%d%d",&n,&m)==2){
        int u,v,w,st,ed;
        cnt = 0;
        memset(head,-1,sizeof(head));
        while(m--){
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w),addedge(v,u,w);
        }
        scanf("%d%d",&st,&ed);
        int ok = SPFA(st);
        if(ok&&d[ed]!=INF)printf("%d\n",d[ed]);
        else puts("-1");
    }
    return 0;
}

三、 Floyd-Warshall

这个算法非常好写，原理基于动态规划，就不细说了。。能求出任意两点间的最短路，必须使用邻接矩阵存图，复杂度是O(n^3)

模版

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
int g[205][205];
int n,m;
int main()
{
    while(scanf("%d%d",&n,&m)==2){
        int u,v,w;
        memset(g,0x3f,sizeof(g));
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&u,&v,&w);g[u][v] = g[v][u] = min(g[u][v],w);}
        int st,ed;
        scanf("%d%d",&st,&ed);
        for(int i=0;i<n;i++)g[i][i] = 0;
        for(int k=0;k<n;k++)
            for(int i=0;i<n;i++)
                for(int j=0;j<n;j++)
                    if(g[i][j]>g[i][k]+g[k][j])
                        g[i][j] = g[i][k]+g[k][j];
        if(g[st][ed] == INF)g[st][ed] = -1;
        printf("%d\n",g[st][ed]);
    }
    return 0;
}

算法很多，但是要把这些算法都学以致用很不容易。大概以后每道题都要想想多解，才能把这些图论算法的适用范围和自己的优势给弄清楚吧。还差了很多火候。