最短路径之Dijkstra算法详细讲解

１ 最短路径算法

在日常生活中，我们如果需要常常往返A地区和B地区之间，我们最希望知道的可能是从A地区到B地区间的众多路径中，那一条路径的路途最短。最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括：

（１）确定起点的最短路径问题：即已知起始结点，求最短路径的问题。

（２）确定终点的最短路径问题：与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。

（３）确定起点终点的最短路径问题：即已知起点和终点，求两结点之间的最短路径。

（４）全局最短路径问题：求图中所有的最短路径。

用于解决最短路径问题的算法被称做“最短路径算法”， 有时被简称作“路径算法”。 最常用的路径算法有：Dijkstra算法、A*算法、Bellman-Ford算法、Floyd-Warshall算法、Johnson算法。

本文主要研究Dijkstra算法的单源算法。

２ Dijkstra算法

2.1 Dijkstra算法

　　Dijkstra算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。

Dijkstra算法是很有代表性的最短路算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。　

2.2 Dijkstra算法思想

Dijkstra算法思想为：设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将 加入到集合S中，直到全部顶点都加入到S中，算法就结束了），第二组为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点加入S中。在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离，是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。

2.3 Dijkstra算法具体步骤　　

（1）初始时，S只包含源点，即S＝，v的距离为0。U包含除v外的其他顶点，U中顶点u距离为边上的权（若v与u有边）或 ）（若u不是v的出边邻接点）。

（2）从U中选取一个距离v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。

（3）以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u（u U）的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值的顶点k的距离加上边上的权。

（4）重复步骤（2）和（3）直到所有顶点都包含在S中。

2.4 Dijkstra算法举例说明

如下图，设A为源点，求A到其他各顶点（B、C、D、E、F）的最短路径。线上所标注为相邻线段之间的距离，即权值。（注：此图为随意所画，其相邻顶点间的距离与图中的目视长度不能一一对等）

图一：Dijkstra无向图





算法执行步骤如下表：【注：图片要是看不到请到“相册--日志相册”中，名为“Dijkstra算法过程”的图就是了】





参考文献

[1] 黄国瑜、叶乃菁，数据结构，清华大学出版社，2001年8月第1版

[2] 最短路径，http://baike.baidu.com/view/349189.htm?func=retitle

[3] 李春葆，数据结构教程，清华大学出版社，2005年1月第1版

[3] Dijkstra算法，http://baike.baidu.com/view/7839.htm

最短路径算法——Dijkstra算法

Dijkstra算法在刚开始在学数据结构的时候，完全没弄明白，主要是也不怎么想去弄明白。而从学校出来到现在，最短路径算法都没有实际运用过，最近在一个GIS项目中总算用到了，于是乎把教材重温了下，同时查阅了网上一些资料，借鉴了一些别人的东西，并顺利用写进了项目中，文中的主要代码来自于园子里的一位大哥，这位大哥对通用框架的研究很深入，他的链接为：http://zhuweisky.cnblogs.com/archive/2005/09/29/246677.html（最短路径）。另外，文章的最后面的一些链接是我找资料的时候用到过的，有兴趣

的朋友可以去看看。

最短路径分析在事故抢修、交通指挥、GPS导航等行业应用中使用的非常广泛， 以至于大多数GIS平台都会把这个分析功能作为一个最基础的功能集成进去，如ARCGIS，SuperMap等。个人感觉想要了解这个算法的来龙去脉，一方面是参与相关书籍仔细理解，另外一个最重要的是要去调试代码。由于历史原因，对于书上的伪C代码，我是完全不感兴趣的，而且由于有严格的数学证明，所以看起来相对较难，而对于面向对象实现的算法，我很感兴趣，也感觉很容易理解，所以一边针对C#实现的面向对象代码再一边对照书籍，感觉理解的层次就加深了。
Dijkstra算法又称为单源最短路径，所谓单源是在一个有向图中，从一个顶点出发，求该顶点至所有可到达顶点的最短路径问题。要顺利实现算法，要求理解Dijstra的算法，同时还要理解图的一些基本概念，图由节点和边构成，将节点和边看成对象，每个对象有自己的特有属性，如在GIS中，一个节点必须都有ID，横坐标，纵坐标等基本属性，边有起点节点，终点节点，长度等属性，而最短路径分析，就是根据边的长度（权值）进行分析的。
边的定义如下：

public class Edge

{

public string StartNodeID;

public string EndNodeID;

public double Weight; //权值，代价

}

节点的定义：

public class Node

{

private string iD ;

private List<Edge> edgeList ;//Edge的集合－－出边表

public Node(string id )

{

this.iD = id ;

this.edgeList = new List<Edge>() ;

}

#region property

public string ID

{

get

{

return this.iD ;

}

}

public List<Edge> EdgeList

{

get

{

return this.edgeList ;

}

}

#endregion

}

本次用于分析的拓扑图如下：(A为起点，D为终点，边上的数字为权值)
　　


利用上述的边与节点的定义，可以通过代码简单的构成如下图：

public class Graph

{

public List<Node> m_nodeList = null;

public Graph()

{

m_nodeList = new List<Node>();

}

/// <summary>

/// 获取图的节点集合

/// </summary>

public List<Node> NodeList

{

get { return this.m_nodeList; }

}

/// <summary>

/// 初始化拓扑图

/// </summary>

public void Init()

{

//***************** B Node *******************

Node aNode = new Node("A");

m_nodeList.Add(aNode);

//A -> B

Edge aEdge1 = new Edge();

aEdge1.StartNodeID = aNode.ID;

aEdge1.EndNodeID = "B";

aEdge1.Weight = 10;

aNode.EdgeList.Add(aEdge1);

//A -> C

Edge aEdge2 = new Edge();

aEdge2.StartNodeID = aNode.ID;

aEdge2.EndNodeID = "C";

aEdge2.Weight = 20;

aNode.EdgeList.Add(aEdge2);

//A -> E

Edge aEdge3 = new Edge();

aEdge3.StartNodeID = aNode.ID;

aEdge3.EndNodeID = "E";

aEdge3.Weight = 30;

aNode.EdgeList.Add(aEdge3);

//***************** B Node *******************

Node bNode = new Node("B");

m_nodeList.Add(bNode);

//B -> C

Edge bEdge1 = new Edge();

bEdge1.StartNodeID = bNode.ID;

bEdge1.EndNodeID = "C";

bEdge1.Weight = 5;

bNode.EdgeList.Add(bEdge1);

//B -> E

Edge bEdge2 = new Edge();

bEdge2.StartNodeID = bNode.ID;

bEdge2.EndNodeID = "E";

bEdge2.Weight = 10;

bNode.EdgeList.Add(bEdge2);

//***************** C Node *******************

Node cNode = new Node("C");

m_nodeList.Add(cNode);

//C -> D

Edge cEdge1 = new Edge();

cEdge1.StartNodeID = cNode.ID;

cEdge1.EndNodeID = "D";

cEdge1.Weight = 30;

cNode.EdgeList.Add(cEdge1);

//***************** D Node *******************

Node dNode = new Node("D");

m_nodeList.Add(dNode);

//***************** C Node *******************

Node eNode = new Node("E");

m_nodeList.Add(eNode);

//E -> D

Edge eEdge1 = new Edge();

eEdge1.StartNodeID = eNode.ID;

eEdge1.EndNodeID = "D";

eEdge1.Weight = 20;

eNode.EdgeList.Add(eEdge1);

}

}

有了拓扑节点和边，就可以根据算法构造其他最短路径分析的对象了，主要步骤如下：
Ø 初始化图中的从A出发的路径集合：

/// <summary>

/// PlanCourse 缓存从源节点到其它任一节点的最小权值路径（路径表）

/// </summary>

public class PlanCourse

{

private Hashtable htPassedPath;

#region ctor

public PlanCourse(List<Node> nodeList, string originID)

{

this.htPassedPath = new Hashtable();

Node originNode = null;

foreach (Node node in nodeList)

{

if (node.ID == originID)

{

originNode = node;

}

else

{

PassedPath pPath = new PassedPath(node.ID);

this.htPassedPath.Add(node.ID, pPath);

}

}

if (originNode == null)

{

throw new Exception("The origin node is not exist !");

}

this.InitializeWeight(originNode);

}

/// <summary>

/// 通过指定节点的边的权值初始化路径表

/// </summary>

/// <param name="originNode"></param>

private void InitializeWeight(Node originNode)

{

if ((originNode.EdgeList == null) || (originNode.EdgeList.Count == 0))

{

return;

}

foreach (Edge edge in originNode.EdgeList)

{

PassedPath pPath = this[edge.EndNodeID];

if (pPath == null)

{

continue;

}

pPath.PassedIDList.Add(originNode.ID);

pPath.Weight = edge.Weight;

}

}

#endregion

/// <summary>

/// 获取指定点的路径表

/// </summary>

/// <param name="nodeID"></param>

/// <returns></returns>

public PassedPath this[string nodeID]

{

get

{

return (PassedPath)this.htPassedPath[nodeID];

}

}

}

Ø 从A中最短路径集合中找到一个最短的路径点Vi开始分析

/// <summary>

/// 从PlanCourse取出一个当前累积权值最小，并且没有被处理过的节点

/// </summary>

/// <returns></returns>

private Node GetMinWeightRudeNode(PlanCourse planCourse, List<Node> nodeList, string originID)

{

double weight = double.MaxValue;

Node destNode = null;

foreach (Node node in nodeList)

{

if (node.ID == originID)

{

continue;

}

PassedPath pPath = planCourse[node.ID];

if (pPath.BeProcessed)

{

continue;

}

if (pPath.Weight < weight)

{

weight = pPath.Weight;

destNode = node;

}

}

return destNode;

}

Ø 修正从A出发至Vi最短路径，并重新选择另一个最短路径点Vj点开始分析，重新执行上述步骤的路径分析

while (curNode != null)

{

PassedPath curPath = planCourse[curNode.ID];

foreach (Edge edge in curNode.EdgeList)

{

PassedPath targetPath = planCourse[edge.EndNodeID];

double tempWeight = curPath.Weight + edge.Weight;

if (tempWeight < targetPath.Weight)

{

targetPath.Weight = tempWeight;

targetPath.PassedIDList.Clear();

for (int i = 0; i < curPath.PassedIDList.Count; i++)

{

targetPath.PassedIDList.Add(curPath.PassedIDList[i].ToString());

}

targetPath.PassedIDList.Add(curNode.ID);

}

}

//标志为已处理

planCourse[curNode.ID].BeProcessed = true;

//获取下一个未处理节点

curNode = this.GetMinWeightRudeNode(planCourse, nodeList, originID);

}

Ø 重复上述两个步骤，一直到所有的对象都分析完为止。

Ø 这个时候的路径集合表中已经保存了从A到任意一点的最短路径集合了。

/// <summary>

/// 从PlanCourse表中取出目标节点的PassedPath，这个PassedPath即是规划结果

/// </summary>

/// <returns></returns>

private RoutePlanResult GetResult(PlanCourse planCourse, string destID)

{

PassedPath pPath = planCourse[destID];

if (pPath.Weight == int.MaxValue)

{

RoutePlanResult result1 = new RoutePlanResult(null, int.MaxValue);

return result1;

}

string[] passedNodeIDs = new string[pPath.PassedIDList.Count];

for (int i = 0; i < passedNodeIDs.Length; i++)

{

passedNodeIDs[i] = pPath.PassedIDList[i].ToString();

}

RoutePlanResult result = new RoutePlanResult(passedNodeIDs, pPath.Weight);

return result;

}

最短路径的结果类定义如下：

public class RoutePlanResult

{

public RoutePlanResult(string[] passedNodes, double value)

{

m_resultNodes = passedNodes;

m_value = value;

}

private string[] m_resultNodes;

/// <summary>

/// 最短路径经过的节点

/// </summary>

public string[] ResultNodes

{

get { return m_resultNodes; }

}

private double m_value;

/// <summary>

/// 最短路径的值

/// </summary>

private double Value

{

get { return m_value; }

}

}

Demo下载：最短路径分析demo
其他技术文章链接：
1.
Dijkstra算法/content/5273273.html

2.最短路径 dijsktra 模板http://www.cnblogs.com/yezizhe/archive/2009/04/16/1437062.html

3. Shortest Path Problem: Dijkstra's Algorithm http://www.codeproject.com/KB/recipes/Shortest_Path_Problem.aspx
4. Dijkstra:Shortest Route Calculation - Object Oriented
http://www.codeproject.com/KB/recipes/ShortestPathCalculation.aspx
5.推荐：路径规划（最短路径）算法C#实现http://zhuweisky.cnblogs.com/archive/2005/09/29/246677.html
6.【Floyd最短路径算法/content/5273274.html

7.【最短路径算法及应用】
http://blog.csdn.net/baggioan/archive/2007/07/28/1713294.aspx