最短路问题（——模板习题与总结）

　　摘要：本文主要讲解在竞赛中如何求解图中存在环的最短路问题。其中涉及的算法有Floyd算法，Dijkstra算法，使用邻接表和优先队列优化的Dijkstra算法，Bellman-Ford算法，简要总结各算法的基本思想和实现以及使用注意事项。

　　最短路问题主要分为单源最短路问题和多源最短路问题。给出顶点数和边数，以及边的权值，让我们计算从某个顶点到某个顶点的最短路径，单源最短路就是求其中一个顶点到其他各个顶点的最短路，多源最短路就是求解任意两点间的最短路。

　　先总结一下只有五行的Floyd算法，一句话概括就是：从i号顶点到j号顶点只经过前k号顶点松弛过的最短路径。

　　模板习题：http://www.cnblogs.com/wenzhixin/p/7327981.html

　　AC代码：

#include<stdio.h>
int main()
{
    int n,m,e[210][210],inf=99999999,t1,t2,t3,s,t,i,j,k;
    while(scanf("%d%d",&n,&m) != EOF)
    {
        for(i=0;i<n;i++)
        {
            for(j=0;j<n;j++)
            {
                if(i==j)
                e[i][j]=0;
                else
                e[i][j]=inf;
            }
        }
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&t1,&t2,&t3);
            if(e[t1][t2] > t3)//道路可能存在重复，去最小值即可 
            e[t1][t2]=e[t2][t1]=t3;
        }
        scanf("%d%d",&s,&t);
        
        for(k=0;k<n;k++)
            for(i=0;i<n;i++)
                for(j=0;j<n;j++)
                if(e[i][j] > e[i][k]+e[k][j])
                e[i][j]=e[i][k]+e[k][j];
        if(e[s][t]==inf)
        printf("-1
");
        else
        printf("%d
",e[s][t]);
    }
    return 0;
}

　　该算法的优势在于可以计算顶点数不太多的图的任意两点的最短路径，很容易实现求解多源最短路径。

　　缺点在于不能计算顶点数太多的图的最短路径，一是二维数组开不了那么大，二是该算法时间复杂度太高，达到O（n*n*n），很容易超时（超过1000个顶点就不能使用）。另外该算法可以解决带负权边的图，并且均摊到每一对点上，但是不能解决带有负权回路的图（其实如果一个图中存在负权回路，那么该图就不存在最短路径了）。

　　接下来，总结一下求解单源最短路径常用的Dijkstra算法。

　　基本步骤：1. 将所有的顶点分为两个集合，已知最短路径的顶点集合P和未知最短路径的顶点集合Q。起初，已知最短路径的顶点集合P中只有一个源点这一个顶点，我们还需要有一个数组来记录哪些顶点在集合P中，哪些在集合Q中。比如可以用book数组进行标记，当book[i]=1;表示i号顶点在集合P中，当book[i]=0;表示i号顶点在集合Q中。

　　　　　　　2. 设置源点s到自己的最短路径为0即dis[s]=0;,如果存在有源点能够直接到达的顶点i，则将dis[i]赋值为e[s][i]；如果不存在该源点直接到达的顶点i，则将

dis[i]赋值正无穷大。

　　　　　　　3. 在集合Q的所有顶点中选择一个离源点最近的顶点u加入到集合P。并考察所有以u为起点的边，对每一条路径进行松弛操作。

　　　　　　　4. 重复第3步，如果P集合为空，算法结束。

　　模板习题：http://www.cnblogs.com/wenzhixin/p/7387613.html

　　AC代码：

#include<stdio.h>
#include<string.h>
int e[1010][1010],dis[1010],bk[1010];
int main()
{
    int i,j,min,t,t1,t2,t3,n,u,v;
    int inf=99999999;
    while(scanf("%d%d",&t,&n)!=EOF)
    {
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(i==j)
                e[i][j]=0;
                else
                e[i][j]=inf;
            }
        }
        for(i=1;i<=t;i++)
        {
            scanf("%d%d%d",&t1,&t2,&t3);
            if(e[t1][t2]>t3)
            {
                e[t1][t2]=t3;
                e[t2][t1]=t3;
            }
        }
        for(i=1;i<=n;i++)
            dis[i]=e[1][i];
        memset(bk,0,sizeof(bk));
        bk[1]=1;
        for(i=1;i<=n-1;i++)
        {
            min=inf;
            for(j=1;j<=n;j++)
            {
                if(bk[j]==0&&dis[j]<min)
                {
                    min=dis[j];
                    u=j;
                }
            }
            bk[u]=1;
            for(v=1;v<=n;v++)
            {
                if(e[u][v]<inf && dis[v]>dis[u]+e[u][v])
                        dis[v]=dis[u]+e[u][v];
            }
        }
        printf("%d
",dis[n]);
    }
    return 0;
}

　　不过竞赛题大多是对Dijkstra算法的变形应用，例如求解最短路径的最大权值，最长路径的最小权值。

　　最长路径的最小权值：http://www.cnblogs.com/wenzhixin/p/7336948.html

　　最短路径的最大权值：http://www.cnblogs.com/wenzhixin/p/7412176.html

　　其实懂得了算法基本思想，根据要求稍微变化一下就好了。

 　  上述算法的时间复杂度为O（n*n），还是很高的，对于一些要求高的题目需要使用进一步优化的算法，时间复杂度是O（mlogn），下面借鉴《算法入门经典》中的优化算法进行讲解。具体的优化方法是使用邻接表存图，再使用优先队列优化。使用vector数组保存边的编号，遍历从某一顶点出发的所有边，更新d数组，就可以写成“for(int i = 0; i < G[u].size(); i++) 更新操作;”。使用优先队列保证每次弹出的是d值最小的结点，并弹出结点编号，方便后序松弛操作。

代码实现如下：

#include<vector>
#include<queue> 
#include<cstring>
#include<cstdio>
using namespace std;

const int INF = 99999999;
const int maxn = 1001;

struct Edge{
    int from, to, dist;
    Edge(int u, int v, int d) :from(u), to(v), dist(d) { };//注释1 
};

//使用优先队列存储的结点 
struct HeapNode {
    int d, u;//最小的d值及其结点编号
    bool operator < (const HeapNode& a) const {//注释2 
        return d > a.d;
    } 
}; 

//为了使用方便，将算法中用到的数据结构封装在一个结构体中，有点类的意思，实际上结构体和类只是在权限上有一点差别
struct Dijkstra{
    int n, m;
    vector<Edge> edges; //使用vector数组存储邻接表，更容易理解，
    vector<int> G[maxn];
    bool done[maxn];    //标记数组
    int d[maxn];        //s到各个顶点的最短路径
    int p[maxn];        //最短路中的上一条弧
    
    void init(int n){//初始化 
        this->n = n; //注释3 
        for(int i = 0; i < n; i++)
            G[i].clear();//清空邻接表 
        edges.clear();     //清空边表 
    }    
    
    void AddEdge(int from, int to, int dist) {//添加边 
        edges.push_back(Edge(from, to, dist));
        m = edges.size();//每加入一条边对其进行编号
        G[from].push_back(m - 1);//以from为起点的边的编号分别是多少 
    }
    
    void dijkstra(int s){//Dijkstra 
        priority_queue<HeapNode> q;
        
        for(int i = 0; i < n; i++)    d[i] = INF;
        d[s] = 0;
        
        memset(done, 0, sizeof(done));
        q.push((HeapNode){0, s});
        
        while(!q.empty()){
            HeapNode x = q.top();
            q.pop();
            int u = x.u;
            
            if(done[u])    continue;
            done[u] = 1;
            
            for(int i = 0; i < G[u].size(); i++){//遍历所有从u出发的边 
                Edge e = edges[G[u][i]];
                if(d[e.to] > d[u] + e.dist){//更新s到e.to的最短距离 
                    d[e.to] = d[u] + e.dist;
                    
                    p[e.to] = G[u][i];//记录使用编号为G[u][i]的边走到e.to这个顶点 
                    q.push((HeapNode){d[e.to], e.to});//加入d[e.to]及其结点的编号表示可以从这个点松弛其他路径 
                }
            }
        }
    } 
};

int main()
{
    //有了结构体的封装，使用的时候操作如下 
    struct Dijkstra solver;//类似定义一个求解单源最短路的对象，有一点需要特别注意，当图特别大的时候要将此语句放在主函数外
    //原因是局部变量没有太大的存储空间，所以需要变成全局变量 
    int n,m;
    scanf("%d%d",&n, &m); // 读入顶点数和边的条数
    solver.init(n);//将邻接表清空 
     
    for(int i = 0; i < m; i++){
        int u, v, w;
        scanf("%d%d%d",&u, &v, &w);//注意点的编号是从0开始还是从1开始
        u--; v--;//如果是从1开始计数的，需要减1
        solver.AddEdge(u, v, w);//如果双向路需要反过来再调用一次即可 
    } 
    
    solver.dijkstra(0); //求顶点0到其他各个顶点的最短距离,注意减1 
    
    //如何使用p数组打印最短路径的方案
    for(int i = 1; i < solver.n; i++){
        printf("从1到%d的最短路径方案是：
", i+1);
        
        vector<int> path;//取出路径编号，倒序输出结点 
        int tmp = i;
        do {
            tmp = solver.p[tmp];
            path.push_back(tmp);
        }while(solver.edges[tmp].from != 0);
        
        for(int j = path.size() - 1; j >= 1; j--){
            printf("%d->%d,", solver.edges[path[j]].from+1, solver.edges[path[j]].to+1);
        }
        printf("%d->%d
", solver.edges[path[0]].from+1, solver.edges[path[0]].to+1);
        
        printf("最短距离是%d
", i+1, solver.d[i]);
    } 
    return 0;
}
/*
5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100
*/

　　程序中有三个注释分别如下：

　　注释1，初始化列表，作用就是给边的各个属性赋值。

　　注释2，操作符重载重const的使用，第一个const保证这个结构体中的变量不被修改，第二个const保证之前的结构体const不被修改。

　　注释3，this指针，当参数与成员变量名相同时使用this指针，如this->n = n （不能写成n = n）。

　　测试样例结果如图：

     

这里给出一道练习题http://acm.hdu.edu.cn/showproblem.php?pid=1535，参考解答https://www.cnblogs.com/wenzhixin/p/9062574.html。

　　可以发现，当一个图中存在负权边的时候，不一定存在最短路，当存在最短路的时候，Dijkstra算法就不适用了，因为松弛过程中会不断找到更短的“松弛路径”，导致最短路径为负，显然是不正确的。这就需要Bellman-Ford算法来解决图中带有负权边的单源最短路问题了。

　　如果说Dijkstra算法是操作结点来进行路径松弛的话，那么Bellman-Ford算法就是操作边来松弛路径了。代码如下：

/*
n为顶点数，m为边数
边的描述为u[i]->v[i]的权值为w[i] 
*/ 
for(int j = 1; j <= n-1; j++){
    for(int i = 1; i <= m; i++){
        if(d[v[i]] > d[u[i]] + w[i])
            d[v[i]] > d[u[i]] + w[i];
    }
}

　　内层循环m次，意思就是依次枚举每一条边，如果u[i]->v[i]这条边能使源点到v[i]的距离变短，就更新d[v[i]]的值。为什么外层循环需要n-1次呢，因为在一个含有n个顶点的，不包含负环的图中，最短路最多经过n-1个点（因为不包括起点），通过n-1轮松弛就可以得到。

　　反过来说，如果经过n-1轮松弛后，还能更新，就说明图中存在负环。利用这个特性还可以用Bellman-Ford算法判断图中是否存在负环。具体例子如POJ 3259 Wormholes

　　AC代码：

/*
题意描述
第一行输入n个顶点和m条边以及虫洞的个数
接下来输入m行边，a->b花费的时间是c
接下来wn行是虫洞的描述，a->b可以回到c秒前，也就是-c
问这个人能不能回到遇到之前的自己，也就是是否存在负环。 
*/ 
#include<cstdio>
const int INF = 99999999;
const int maxn = 510;
int u[maxn*15], v[maxn*15], w[maxn*15];
int n, m, wn, pn;
int Bellman_Ford();

int main()
{
    int F;
    while(scanf("%d", &F) != EOF){
        while(F--) {
            scanf("%d%d%d", &n, &m, &wn);
            int a, b, c;
            pn = 1;
            for(int i = 1; i <= m; i++) {
                scanf("%d%d%d", &a, &b, &c);
                u[pn] = a; v[pn] = b; w[pn++] = c;
                u[pn] = b; v[pn] = a; w[pn++] = c; 
            } 
            for(int i = 1; i <= wn; i++) {
                scanf("%d%d%d", &a, &b, &c);
                u[pn] = a; v[pn] = b; w[pn++] = -c;
            }
            pn --;
            //利用pn计数每条边
             
            if(Bellman_Ford())
                printf("YES
");
            else
                printf("NO
");
        } 
    }
    return 0;
}

int Bellman_Ford() {
    int dis[maxn];
    for(int i = 1; i <= n; i++){
        dis[i] = INF;
    }
    dis[1] = 0;
    
    for(int i = 1; i <= n - 1; i++) {
        for(int j = 1; j <= pn; j++) {
            if(dis[v[j]] > dis[u[j]] + w[j])
                dis[v[j]] = dis[u[j]] + w[j];
        }
    }
    
    int flag = 0;//标记，如果还能更新就说明存在环 
    for(int j = 1; j <= pn; j++) {
            if(dis[v[j]] > dis[u[j]] + w[j])
                flag = 1;
    }
    if(flag)
        return 1;
    return 0;
}

　　不过可惜的是这个算法时间复杂度太高，在竞赛中我们利用队列非空循环一直进行松弛，在含有n个顶点的图中，如果不存在负环，包括源点在内的任意两点间的最短路径所利用点不超过n个，如果一个点被用超过n次，就说明有多余的点松弛最短路径，只能说明存在负环。不存在负环，结点的标记不会取消，计算最短路径，直至队列为空，返回不存在负环。代码如下：

bool bellman_ford(int s) {
    queue<int> q;
    memset(inq, 0, sizeof(inq));
    memset(cnt, 0, sizeof(cnt));
    
    for(int i = 0; i < n; i++)
        d[i] = INF;
    d[s] = 0;
    inq[s] = true;
    q.push(s);
    
    while(!q.empty()){
        int u = q.front();
        q.pop();//弹出一个点
        intq[u] = 0;
        
        for(int i = 0; i < G[u].size(); i++){//枚举以该点为起点的每一条边
            Edge e = edges[G[u][i]];
            if(d[u] < INF && d[e.to] > d[u] + e.dist) {//如果该边能够使源点到d[e.to]的距离变小，就更新  
                d[e.to] = d[u] + e.dist;
                p[e.to] = G[u][i];
                if(!inq[e.to]){//没有被标记过 
                    q.push(e.to);
                    inq[e.to] = 1;
                    if(++cnt[e.to] > n)//如果弹出过程中，某一个点进队了n+1次，直接判定存在负环 
                        return 0;
                }
            }
        }
    }
    return 1;
}

　　上面的写法和优化后Dijkstra算法很像，不同的是它能让一个节点多次进入FIFO队列，从而判断是否存在负环，同时也能计算最短路径。使用的时候也用结构体封装一下就能像优化后的Dijkstra算法一样使用了。Bellman-Ford算法不论从思想上还是实现上都很成熟，在实际应用中也很广泛，也有人称队列优化后的Bellman-Ford算法为SPFA（Shortest Path Faster Algorithm）算法。

　　下面给出一道例题：POJ 1860 Currency Exchange 参考解答：https://www.cnblogs.com/wenzhixin/p/9383074.html

　　至此，最短路问题的求解的几种常见算法就介绍完了，各有个的优点，Foley算法，精简，能解决带负权边但不存在负环的图的最短路问题，但时间复杂度高，Dijkstra算法时间复杂度低，但是不能求解有负权边的图的最短路问题，Bellman-Ford算法相对比较完美，但是据说竞赛的时候有很小的可能被恶意数据卡死。因此需要我们在竞赛中根据具体问题，选择合适的算法才行。