最短路算法略解

Part 0. 最短路是解决这类问题的,给定一个图 $ G = (V,E) $ ,以及图中各边的距离，询问两点间的最短路径是多少。常用的有以下几种算法.

Part 1. Dijkstra算法

　　能够计算一个节点到其他所有节点的最短路径.前提是 $ G $ 中的边的权值均不为负.

下面是我的代码习惯:

$ G[i][j] $ 表示节点 $ i $ 和节点 $ j $ 之间的距离

$ N $ 表示节点个数. $ st $ 表示起点. $ inf $ 表示一个很大的数 若 $ G[i][j] = inf $ 则表示 节点 $ i $ 和 $ j $ 不可达

$ low[i] $ 表示节点 $ i $ 到 $ st $ 的距离

松弛操作 $ Relax(u,v,w) if (low[v] > low[u] + w) low[v] = low[u] + w; $ 也就是判断$ st ightarrow v $ 和 $ st $ $ ightarrow $ $ u $ $ ightarrow $ $ v $ 哪个路径更短.

集合 $ S $ 中的节点均为已确定最短路的节点，并用 $ vis[i] = true $ 来标记

$ path[i] $ 表示节点 $ i $ 在最短路径中的前驱

算法过程:

　　初始化操作

for each vertex v
    low[v] = G[st][v] ;
    path[v] = -1;
low[st] = path[st] = 0 ;

 　求解步骤

1. 刚开始时 $ S $ 中只有 $ st $，选择一个 $ S $ 外的节点 $ v $ ，且满足 $ low[v] <= low[u] && u in V - S  $，即 $ v $ 是所有未确定最小值的点中距 $ st $ 最近的，那么可以直接确定 $ v $ 不能再被松弛，若可以被松弛则满足 $ low[v] > low[u] + G[u][v] &&  u in V-S $ 这与 $ low[v] <= low[u] &&  u in V-s $ 矛盾。所以，令 $ S[2] = v , vis[v] = true $ 。
   
2. 现在集合 $ S $ 中已经有了两个元素了，那么刚刚加入的元素有什么用处么？我们尝试用它来松弛其他每一个 $ S $ 外的节点。
3. 刚刚加入的节点已经起到了它的作用，现在只需要重复步骤 1 即可，也就是从 $ V - S $ 中寻找 $ low[v] <= low[u] $ ，同样，节点 $ V $ 可以直接加入集合 $ S $ ，同样用反证法证明
4. 不断重复步骤 1 ， 2 直到所有节点加入到 $ S $

代码如下:

class Dijkstra
{
public:
    int N , R , st , G[maxn][maxn] , low[maxn] , path[maxn] ;
    bool vis[maxn] ;
    void Init(int n,int r,int sst) {
        N = n , R = r , st = sst ;
        memset(vis,false,sizeof(vis)) ;
        memset(G,inf,sizeof(G)) ;
    }
    void addedge(int u,int v,int w) {
        G[u][v] = G[v][u] = w ;
    }
    void DIJ() {
        rep(i,N) {
            G[i][i] = 0 ;
            low[i] = G[st][i] ;
            if (low[i] == inf) path[i] = -1 ;
            else path[i] = st ;
        }
        path[st] = 0 ;
        vis[st] = true ;
        int tmp , id ;
        rep(i,N-1) {
            tmp = inf ;
            rep(j,N) {
                if (!vis[j] && low[j] < tmp) {
                    tmp = low[j] ;
                    id = j ;
                }
            }
            vis[id] = true ;
            rep(j,N) {
                if (!vis[j] && low[j] > low[id] + G[id][j]) {
                    low[j] = low[id] + G[id][j] ;
                    path[j] = id ;
                }
            }
        }
    }
    void pathprint(int en) {
        int p = en ;
        while (p != st) {
            printf("%d ",p) ;
            p = path[p] ;
        }
        printf("%d
",st) ;
    }
}ans;

Dijkstra 算法还有一种队列优化的形式，道理是一样的.代码在下面:

hdu 2544

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
using namespace std ;
#define rep(i,n) for (int i = 1 ; i <= n ; ++ i)
#define LL long long
const int inf = 0x3f3f3f3f ;
const int maxn = 110 ;
struct EDGE
{
    int u , v , w ;
};
struct HEHE
{
    int u , w ;
    friend bool operator < (const HEHE & P,const HEHE & T) {
        return T.w < P.w ;
    }
};

class DIJKSTRA
{
public:
    vector<EDGE> egs ;
    vector<int> G_id[maxn] ;
    bool vis[maxn] ;
    int low[maxn] , N , R , st , path[maxn] ;
    void Init(int n,int r,int sst) {
        N = n , R = r , st = sst ;
        rep(i,N) {
            G_id[i].clear() ;
            vis[i] = false ;
            low[i] = inf ;
            path[i] = -1 ;
        }
        egs.clear() ;
        low[st] = path[st] = 0 ;
    }
    void addedge(int u,int v,int w) {
        egs.push_back(EDGE{u,v,w}) ;
        G_id[u].push_back(egs.size()-1) ;
    }
    void DIJ() {
        priority_queue<HEHE> Q ;
        while (!Q.empty()) Q.pop() ;
        HEHE tmp ;
        int u ;
        Q.push(HEHE{st,0}) ;
        while (!Q.empty()) {
            tmp = Q.top() ;
            Q.pop() ;
            u = tmp.u ;
            for (int i = 0 ; i < G_id[u].size() ; ++ i) {
                EDGE & e = egs[G_id[u][i]] ;
                if (low[e.v] > low[u] + e.w) {
                    low[e.v] = low[u] + e.w ;
                    Q.push(HEHE{e.v,low[e.v]}) ;
                    path[e.v] = u ;
                }
            }
        }
    }
    void pathprint(int en) {
        int p = en ;
        while (p != st) {
            printf("%d ",p);
            p = path[p] ;
        }
        printf("%d 
",st);
    }

}ans;

int main()
{
    int N , R , u , v , x ;
    while (scanf("%d%d",&N,&R) == 2 && N && R) {
        ans.Init(N,R,1) ;
        rep(i,R) {
            scanf("%d%d%d",&u,&v,&x) ;
            ans.addedge(u,v,x) ;
            ans.addedge(v,u,x) ;
        }
        ans.DIJ() ;
        printf("%d
",ans.low[N]) ;
//        while (cin >> v) {
//            ans.pathprint(v) ;
//        }
    }
    return 0 ;
}

Part 2. Floyd算法

　　能够计算任意两点之间的最短路径，同样无法处理有负权边的情况.

算法过程

　　初始化操作 $ G[i][j] = inf $

　　求解步骤 三重循环

　　$ Floyd $ 算法是一种动态规划的思想 令 $ G[k][i][j] $ 表示 $ i ightarrow j $ 的路径上经过的节点编号不大于 $ k $ 的最短距离，当 $ k = N $ 时即为最短路径。现在已知 $ G[k-1][i][j] $ 考虑怎么求解 $ G[k][i][j] $

若经过 $ k $ 节点，则 $ G[k][i][j] = G[k-1][i][k] + G[k-1][k][j] $

若不经过 $ k $ 节点，则 $ G[k][i][j] = G[k-1][i][j] $

而最终 $ G[k][i][j] $ 就要取其中较小值.

可以看出这是一个动态规划的转移方程，初始状态怎么确定呢，很简单， $ G[0][i][j] = distance[i][j] $

从转移方程可以看出 $ k $ 要放在最外层循环，否则会出错的，下面有一个样例

 

 代码如下:

　　

class FLOYD
{
public:
    int N , R , G[maxn][maxn] , path[maxn][maxn] ;
    void Init(int n,int r) {
         N = n , R = r ;
         memset(G,inf,sizeof(G)) ;
    }
    void addedge(int u,int v,int w) {
        G[u][v] = G[v][u] = w ;
    }
    void floyd() {
        for (int i = 1 ; i <= N ; ++ i) {
            for (int j = 1 ; j <= N ; ++ j) {
                if (G[i][j] == inf) path[i][j] = -1 ;
                else path[i][j] = j ;
            }
        }
        for (int k = 1 ; k <= N ; ++ k) {
            for (int i = 1 ; i <= N ; ++ i) {
                for (int j = 1 ; j <= N ; ++ j) {
                    if (G[i][j] > G[i][k] + G[k][j]) {
                        G[i][j] = G[i][k] + G[k][j] ;
                        path[i][j] = path[i][k] ;
                    }
                }
            }
        }
    }
    void pathprint(int st,int en) {
     //   printf("now is solving %d and %d
",st,en) ;
        printf("%d ",st) ;
        while (st != en) {
            printf("%d ",path[st][en]) ;
            st = path[st][en] ;
        }
        puts("") ;
    }
}ans;

Part 3. Bellman_Ford算法

　　这个可以计算含负权边的图.若含负环则返回 $ false $

　　还能用于差分约束系统.

算法原理 最短路径一定不会含环（无论正环负环或者零），所以最短路径的最大长度是 $ |V| - 1 $ ，构造以 $ st $ 为树根的最短路径树，则树深不超过 $ |V| - 1 $。先看下代码:

for (int i = 1 ; i < N ; ++ i) {
    for (int j = 1 ; j <= R ; ++ j) {
        EDGE & e = edges[j] ;
        if (low[e.to] > low[e.fr] + e.di) {
            low[e.to] = low[e.fr] + e.di ;
        }
    }
}//初始化low[i] 为无穷大，low[st] = 0

 当内层循环循环了一遍之后，生成了树的第一层节点，至少能够找出所有与 $ st $ 直接相连的节点的最短路，

内层循环第二遍之后，会生成深度为二的节点，也就是和 $ st $ 之间间隔了一个节点的最短路径

依次执行下去就会得到最优解。

比如下图，首先初始化 $$ low[st] = 0 , low[A] = inf , low[B] = inf , low[C] = inf $$ 假设存储的边的顺序是 (st,A),(st,B),(B,A),(B,C),那么执行一次内层循环过程后就是这样的: $$ low[st] = 0 , low[A] = 10 , low[B] = 3 , low[A] = 8 , low[C] = 13 $$居然一下子求出了最短路，不过这实在是巧合，比如边的顺序是这样的话(B,C),(B,A),(st,B),(st,A)，一次循环后是:$$ low[C] = inf , low[A] = inf , low[B] = 3 , low[A] = 10 $$ 这是最坏的情况，不过即使是在这样的情况下它也求得了 st 直接到各个点的距离，第二次之后是 $$ low[C] = 13 , low[A] = 8 , low[B] = 3 , low[A] = 8 $$ 这个时候得到的是 st 到各个节点的路径上有不多于一个点的情况下的最短路，第三次之后还是这样（因为已经不能松弛了）

 poj 1860

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std ;
#define rep(i,n) for (int i = 1 ; i <= n ; ++ i)
#define LL long long
const int maxn = 110 ;
struct Node
{
    int u ;
    int v ;
    double r ;
    double c ;
};

class Bellman_Ford
{
public:
    int N , R , st , cnt ;
    double low[maxn] ;
    Node egs[maxn<<1] ;
    void Init(int n,int r,int sst,double my) {
        N = n , R = r , st = sst ;
        rep(i,N) low[i] = 0.0 ;
        low[st] = my , cnt = 0 ;
    }
    void addedge(int u,int v,double r,double c) {
        egs[++cnt] = Node{u,v,r,c} ;
    }
    bool bellmanford() {
        bool ok ;
        rep(i,N-1) {
            ok = false ;
            rep(j,cnt) {
                Node & e = egs[j] ;
                if ((low[e.u] - e.c)*e.r > low[e.v]) {
                    low[e.v] = (low[e.u] - e.c)*e.r ;
                    ok = true ;
                }
            }
            if (!ok) break ;
        }
        rep(j,cnt) {
            Node & e = egs[j] ;
            if ((low[e.u] - e.c)*e.r > low[e.v]) {
                return true ;
            }
        }
        return false ;
    }
}ans;

int main()
{
    double c , r , w , my ;
    int N , R , st , u , v;
  //  freopen("in.txt","r",stdin) ;
    while (scanf("%d%d%d%lf",&N,&R,&st,&my) == 4) {
        ans.Init(N,R,st,my) ;
        rep(i,R) {
            scanf("%d%d%lf%lf",&u,&v,&r,&c) ;
            ans.addedge(u,v,r,c) ;
            scanf("%lf%lf",&r,&c) ;
            ans.addedge(v,u,r,c) ;
        }
        if (ans.bellmanford()) puts("YES") ;
        else puts("NO") ;
    }
    return 0;
}

Part 4.spfa 算法.

　　求单源最短路的SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于1994年发表的。

---摘自百度百科

 

 在刚才的 Bellman_Ford算法中，可以看到可能会做很多没必要的松弛尝试操作，比如，第一次边的顺序里，low[B] = inf 那么所有从 B 点出发的边都不用检查的，spfa算法就是把之前松弛过的节点放入队列，再用这些点尝试松弛其他节点（比如一个点没有松弛过，那从他出去的边也无法松弛其他节点），代码大致是这样的:

void spfa()
{
    rep(i,N) {
        vis[i] = false , low[i] = inf ;
    }
    low[st] = 0 , vis[st] = true ;
    queue<int> Q ;
　　Q.push(st) ;
    //while (!Q.empty()) Q.pop() ;
    while (!Q.empty()) {
        u = Q.front() ;
        vis[u] = false ;
        Q.pop() ;
        for (int i = h[u] ; i != -1 ; i = G[i].nxt) {
            v = G[i].to , w = G[i].val ;
            if (low[v] > low[u] + w) {
                low[v] = low[u] + w ;
                if (!vis[v]) vis[v] = true , Q.push(v) ;
            }
        }
    }
}

　　

参考:

http://www.cnblogs.com/hxsyl/p/3270401.html

http://www.cnblogs.com/hxsyl/p/3248391.html#top

http://blog.csdn.net/zhongkeli/article/details/8832946

http://www.cnblogs.com/biyeymyhjob/archive/2012/07/31/2615833.html

http://blog.csdn.net/niushuai666/article/details/6772706

http://nopainnogain.iteye.com/blog/1047818

http://blog.csdn.net/xu3737284/article/details/8973615

　　

end~_~