1.概述

这两天，博客园里有人谈论到地铁图的实现，而之前我也和NeoRAGEx2002同学做了一个Android地铁图应用，因此，对于地铁图的寻路算法，我觉得有必要专门写一篇博客来给出我们的解决方案，供大家参考。本文所述算法的时间复杂度为O(|E|log|E|)，其中|E|为边的数量。

2.概念

1)点和边

基础元素为点(地铁站)和边(两个相邻站之间的有向轨道)。

例如，经过莘庄站有1号线和5号线，含有莘庄站的边有4条，经过世纪大道站有4条线路，含有世纪大道站的边有8条。

2)运营段

在边的基础上，还有运营段的概念，即一组连续边的集合。

例如，1号线有莘庄-富锦路(发车间隔8分)、莘庄-上海火车站(发车间隔6分)、上海南站-富锦路(发车间隔8分)、上海南站-上海火车站(发车间隔6分)、富锦路-莘庄(发车间隔8分)、上海火车站-莘庄(发车间隔6分)等运营段。

3)代价

寻路算法的依据可以为时间、换乘次数、经过边数等任意非负代价，这里着重对时间进行建模。

每条边有一个乘坐时间代价，表示乘坐地铁经过该边所需要花费的时间。

每个运营段有一个等车时间代价，为通过该运营段中的边乘车需要等车的时间，通常可以假设为发车间隔时间(等车时间的最大值)或者发车间隔时间的一半(等车时间的数学期望)。

在每个点有一个换乘时间代价矩阵，表示在任意两条边之间换乘所需要花费的时间。两边之间的关系有直接连通、换乘、不连通三种。连通的换乘时间代价为0，换乘的换乘时间代价为换乘行走时间+等车时间，不连通的换乘时间代价为+∞。这个矩阵可以用稀疏矩阵表示，不连通的两边不出现。由于地铁的设计使得我们不需要考虑沿着某条线路折返的路线，我们可以将一边和它的相反边看做不连通而不是换乘，这样可以降低图的复杂度。

3.算法

1)思路

传统的最短路径算法很多，比如

Dijkstra算法，不过这种算法没有办法解决换乘时间代价问题。

广度优先算法，在加权图的时候无法得到最优解。

受限的深度优先算法，能得到结果，但路径比较长时算法时间过长。

我们可以考虑这样一个自然现象，雪水在山峰上融化，然后流经各个山谷。各站点就是山谷中的点，换乘站点就是山谷分成多股的交叉点。

假设起始点是山峰，水沿着各边扩散，经过一边的用时和边上的乘坐时间代价一样，从一边到一邻边，需要等待换乘时间代价。不停往起始点倒水，水不停流动，当水到达终止点时，水流经过的路径就是我们所需要的最短路径。

这个模型的问题在于水可以有多股水流同时流动，但是我们的算法应该有一个顺序，我们可以假设有一个水流切线，表示所有水流的最前端位置。任意边e，当其起点被水流所覆盖，而终点没有被水流覆盖时，将e加入按代价排序的切线边列表C(红黑树或平衡树实现)，并记录e->水流经过的上一边。继续让水流动，则C中的第一个边e的终点最先被水流所覆盖，从C中移除e。当到达寻路的终止点时，我们可以通过从最后一条边开始回溯上一边，再上一边的上一边，直到寻路的起点，这样就获得了所需要的路径。

算法也可以不在终点结束，而直到水流覆盖地图上的所有点，对性能并没有明显的影响。

2)例子

如图1所示：

图1(a) 时间代价图1(b) 搜索顺序

为了简化问题，我们假设2号线(绿色)和9号线(水色)不存在，只考虑4号线(深蓝色)和6号线(紫红色)。

图1(a)中表示了4号线和6号线的边的时间代价，其中白色表示等车时间，黄色表示乘车时间。

我们假设每个换乘站，换乘时的行走时间为4分钟。

图1(b)表示了搜索顺序，对于相同的代价，其搜索顺序不定，由切线边列表C的实现决定。

例子中的起始点为世纪大道，终止点为上海儿童医学中心。

切线边列表C的变化如下

{1, 2, 3, 5}  
{2, 3, 4, 5}  
{3, 4, 5, 6}  
{4, 5, 6, 9}  
{5, 6, 7, 9}  
{6, 7, 8, 9}  
{7, 8, 9, 10, .., ..}  
{8, 9, 10, .., .., ..}  
{9, 10, .., .., .., ..}  
{10, .., .., .., .., ..} 

需要注意到消去6的时候，增加了10、(蓝村路, 塘桥)、9的反向边三条边，消去9的时候，增加了6的反向边。

消去9时，会再次搜索到10，此时的时间代价为13+4+8=25，但因为10已经记录了其上一边，所以不再加入C。

3)实现

伪代码如下：

record Vertex //点  
    InEdges:List<Edge> //进站边  
    OutEdges:List<Edge> //出站边  
    Connection:Map<Tuple<Edge, Edge>, EdgeConnection> //边连接矩阵，包含换乘行走时间代价，当不连接时不存在  
 
record Edge //边  
    Start:Vertex //起点  
    End:Vertex //终点  
    Cost:Int //乘坐时间代价  
    Ranges:List<Range> //运营段  
 
record Range //运营段  
    Edges:List<Edge> //边  
    Cost:Int //等车时间  
 
taggedunion EdgeConnection  
    Connected:Unit //直接连接  
    Transferable:Int //换乘，行走时间代价  
 
CalculateRoute(Start:Vertex, End:Vertex):List<Edge>  
    if Start == End  
        return new List<Edge>() //起始点和终止点重合  
 
    let Previous <- new Map<Edge, Edge>() //边到上一边的映射  
    let cmp <- (Comparer<Edge>)(...) //路径代价比较函数，将在下面给出  
    let CutEdges <- new RedBlackTree<Edge>(cmp) //水流切线边列表  
 
    foreach o in Start.OutEdges  
        CutEdges <- CutEdges + o  
        Previous <- Previous + (o, null)  
 
    let e <- (Edge)(null) //终边  
 
    while CutEdges.Count > 0  
        let i <- CutEdges.First  
        CutEdges <- CutEdges - i  
 
        let s <- i.End  
        if s == End  
            e <- i  
            break 
 
        foreach o in s.OutEdges  
            if !s.Connection.ContainsKey((i, o))  
                continue 
 
            if Previous.ContainsKey(o)  
                continue 
 
            Previous <- Previous + (o, i)  
            CutEdges <- CutEdges + o  
 
    if e == null  
        return null //没有路径  
 
    let l <- new List<Edge>()  
    while e != null  
        l <- l + e  
        e <- Previous(e)  
 
    return l.Reverse() 

下面为当寻路依据为时间时的比较函数

let Time <- new Map<Edge, Int>()  
let Range <- new Map<Edge, Range>()  
let GetBestRange <- l:List<Range> => l.OrderBy(r => r.Cost).First  
let GetTime <-  
    e =>  
        if e == null  
            return 0  
        if Time.ContainsKey(e)  
            return Time(e)  
        let p <- Previous(e)  
        let v <- GetTime(p)  
        if p != null  
            let c <- e.Start.Connection((p, e))  
            if c  
            | Connected ->  
                let rgOld <- Range(p)  
                let rg <- GetBestRange(p.Ranges.Intersect(e.Ranges))  
                Range <- Range + (e, rg)  
                if rgOld != rg  
                    v <- v - rgOld.Cost + rg.Cost  
            | Transferable t ->  
                let rg <- GetBestRange(e.Ranges)  
                Range <- Range + (e, rg)  
                v <- v + rg.Cost + t  
        else 
            let rg <- GetBestRange(e.Ranges)  
            Range <- Range + (e, rg)  
            v <- v + rg.Cost  
        v <- v + e.Cost  
        Time <- Time + (e, v)  
        return v  
let cmp <-  
    (l:Edge, r:Edge) =>  
        return GetTime(l) - GetTime(r) 

下面为当寻路依据为换乘次数时的比较函数

let TransferCount <- new Map<Edge, Int>()  
let GetTransferCount <-  
    e =>  
        if e == null  
            return 0  
        if TransferCount.ContainsKey(e)  
            return TransferCount(e)  
        let p <- Previous(e)  
        let v <- GetTransferCount(p)  
        if p != null  
            let c <- e.Start.Connection((p, e))  
            if c  
            | Connected ->  
                ()  
            | Transferable _ ->  
                v += 1  
        TransferCount <- TransferCount + (e, v)  
        return v  
let cmp <-  
    (l:Edge, r:Edge) =>  
        return GetTransferCount(l) - GetTransferCount(r) 

下面为当寻路依据为经过边数时的比较函数

let StopCount <- new Map<Edge, Int>()  
let GetStopCount <-  
    e =>  
        if e == null  
            return 0  
        if StopCount.ContainsKey(e)  
            return StopCount(e)  
        let p <- Previous(e)  
        let v <- GetStopCount(p) + 1  
        StopCount <- StopCount + (e, v)  
        return v  
let cmp <-  
    (l:Edge, r:Edge) =>  
        return GetStopCount(l) - GetStopCount(r) 

4.算法复杂度

认为点的入站边和出站边很少，覆盖每条边的运营段很少，并注意到GetTime运行时递归的部分总会在Time变量中缓存，可知时间比较函数的复杂度为O(1)。

CutEdges的红黑树插入删除的复杂度为O(log|E|)。

所有边最多进出CutEdges一次，可知整个算法的复杂度为O(|E|log|E|)。

5.结果

本文所述算法能够在O(|E|log|E|)时间内快速得到全局最佳路径。

在1GHz的单CPU手机上实测得到的上海地铁(11条线路214站)任意两站点之间的寻路时间均为200ms以下。

最后还是介绍下我们的应用。

矢量地铁（上海版）

支持双指无极缩放、动态寻径效果、本地地图显示。虽然我们只是一个小团队，但我们只做最好的地铁图！如果大家有啥问题和建议，欢迎给我们留言！

原文链接：http://www.cnblogs.com/Rex/archive/2012/08/12/2634401.html