1，迪杰斯特拉算法介绍 迪杰斯特拉算法是典型最短路径算法，用于计算图或网中某个特定顶点到其他所有顶点的最短路径。主要特点是以起始点为中心向外，层层扩展，直到扩展覆盖所有顶点。 2，迪杰斯特拉算法思想 设G=(V,E)为一个带全有向图，把图中顶点集合V分成两组。第一组为已求出最短路径的顶点集合（用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将所到达最短路径的顶点加入到集合S中，直到全部顶点都加入到S中）。第二组为其余未确定最短路径的顶点集合（用U表示，U=V-S，U中的顶点不断的加入到S中，直到U为空，S=V）。在U加入S的过程中，始终保持源点到S中各顶点的最短路径长度小于或等于源点到U中任意顶点的最短路径长度。 3，迪杰斯特拉算法执行步骤 设 n 为图 G=(V,E) 中的顶点数，dist[n] 存放从源点到每个终点当前最短路径的长度，path[n] 存放相应路径，S 为已求得最短路径的终点的集合，U为V-S,初始为不含有源点的所有顶点。 （1）初始化已求的最短路径的集合S为只含有元素源点a，S=｛a｝。 （2）从U中选取一个距离源点v最小的顶点k，把k，加入S中（该选定的距离就是v到k的最短路径长度）。 （3）以k为新考虑的中间点，修改U中各顶点的距离；若从源点v到顶点u（u U）的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值为顶点k的距离加上顶点k到u边上的权。 （4）重复步骤（2）和（3）直到所有顶点都包含在S中。 4，迪杰斯特拉算法举例说明 （1）有向图如下，以a为源点，求源点a到其他各顶点的最短路径。
（2）算法详细步骤如下表：
| 步骤 | S集合中 | U集合中 |
| 初始化 | 选入a，此时s={a} 此时最短路径有a->a=0 以a为中间点，从a开始找 | U={b,c,d,e,f} a->b=1 a->c=2 a->e=15 a->其他U中顶点为无穷 |
| 1 | 从U={b,c,d,e,f}中发现路径a->b=1最短 选入b，S={a,b} 此时最短路径有a->a=0,a->b=1 以b为中间点，从a->b=1这条最短路径开始找 | U={c,d,e,f} (a->b->d=7)<初始的无穷 改写a->b->d=无穷为当前的a->b->d=7 a-> b->其他U中顶点为无穷 |
| 2 | 从U={c,d,e,f}中发现路径a->c=2最短 选入c，S={a,b,c} 此时最短路径有 a->a=0,a->b=1,a->c=2 以b为中间点，从a->c=2这条最短路径开始找 | U={d,e,f} (a->c->d=5)<已有的7 改写为a->c->d=5 |
| 3 | 从U={d,e,f}中发现路径a->c->d=5最短 选入d，S={a,b,c,d} 此时最短路径有 a->a=0,a->b=1,a->c=2,a->c->d=5 以d为中间点，从a->c->d=5这条最短路径开始找 | U={e,f} (a->c->d->e=9)<步骤1中的15 改写为a->c->d->e=9 (a->c->d->f=6)<初始的无穷 改写为a->c->d->f=6 |
| 4 | 从U={e,f}中发现路径a->c->d->f=6最短 选入f，S={a,b,c,d,f} 此时最短路径有 a->a=0,a->b=1,a->c=2,a->c->d=5 a->c->d->f=6 以f为中间点，从a->c->d->f=6这条最短路径开始找 | U={e} (a->c->d->f->e=7)<步骤3中改写成的9 改写为a->c->d->f->e=7 |
| 5 | 从U={f}中发现路径a->c->d->f->e=7最短 选入f，S={a,b,c,d,f,e} 此时最短路径有 a->a=0,a->b=1,a->c=2,a->c->d=5 a->c->d->f=6,a->c->d->f->e=7 | U集合已空，查找完毕。 |
例如，对下图中的有向图，应用Dijkstra算法计算从源顶点1到其它顶点间最短路径的过程列在下表中。
Dijkstra算法的迭代过程：
主题好好理解上图！
以下是具体的实现(C/C++):
#include
<
iostream
>
using
namespace
std;
const
int
maxnum
=
100
;
const
int
maxint
=
999999
;
void
Dijkstra(
int
n,
int
v,
int
*
dist,
int
*
prev,
int
c[maxnum][maxnum])
{
bool
s[maxnum];
//
判断是否已存入该点到S集合中
for
(
int
i
=
1
; i
<=
n;
++
i)
{
dist[i]
=
c[v][i];
//初始化其他点到源点的最短距离
s[i]
=
0
;
//
初始都未用过该点
if
(dist[i]
==
maxint)
//初始化其他点距离源点最短路径的 前一个点
prev[i]
=
0
; //其他点到源点 不存在路径时，
else
prev[i]
=
v;
}
//初始化源点的状态
dist[v]
=
0
;
s[v]
=
1
;
//
依次将未放入S集合的结点中，取dist[]最小值的结点，放入结合S中
//
一旦S包含了所有V中顶点，dist就记录了从源点到所有其他顶点之间的最短路径长度
for
(
int
i
=
2
; i
<=
n;
++
i)
{
int
tmp
=
maxint;
int
u
=
v;
//
找出当前未使用的点j的dist[j]最小值
for
(
int
j
=
1
; j
<=
n;
++
j)
if
((
!
s[j])
&&
dist[j]
<
tmp)
{
u
=
j;
//
u保存当前邻接点中距离最小的点的号码
tmp
=
dist[j];
}
s[u]
=
1
;
//
表示u点已存入S集合中
//
更新其他点距离源点 最短距离点的 dist
for
(
int
j
=
1
; j
<=
n;
++
j)
if
((
!
s[j])
&&
c[u][j]
<
maxint)
{
int
newdist
=
dist[u]
+
c[u][j];
if
(newdist
<
dist[j])
{
dist[j]
=
newdist;
prev[j]
=
u;
}
}
}
}
void
searchPath(
int
*
prev,
int
v,
int
u)
{
int
que[maxnum];
int
tot
=
1
;
que[tot]
=
u;
tot
++
;
int
tmp
=
prev[u];
while
(tmp
!=
v)
{
que[tot]
=
tmp;
tot
++
;
tmp
=
prev[tmp];
}
que[tot]
=
v;
for
(
int
i
=
tot; i
>=
1
;
—
i)
if
(i
!=
1
)
cout
<<
que[i]
<<
“
->
“
;
else
cout
<<
que[i]
<<
endl;
}
int
main()
{
freopen(
“
input.txt
“
,
“
r
“
, stdin);
//
各数组都从下标1开始
int
dist[maxnum];
//
表示当前点到源点的最短路径长度
int
prev[maxnum];
//
记录当前点的前一个结点
int
c[maxnum][maxnum];
//
记录图的两点间路径长度
int
n, line;
//
图的结点数和路径数
//
输入结点数
cin
>>
n;
//
输入路径数
cin
>>
line;
int
p, q, len;
//
输入p, q两点及其路径长度
//
初始化c[][]为maxint
for
(
int
i
=
1
; i
<=
n;
++
i)
for
(
int
j
=
1
; j
<=
n;
++
j)
c[i][j]
=
maxint;
for
(
int
i
=
1
; i
<=
line;
++
i)
{
cin
>>
p
>>
q
>>
len;
if
(len
<
c[p][q])
//
有重边
{
c[p][q]
=
len;
//
p指向q
c[q][p]
=
len;
//
q指向p，这样表示无向图
}
}
for
(
int
i
=
1
; i
<=
n;
++
i)
dist[i]
=
maxint;
for
(
int
i
=
1
; i
<=
n;
++
i)
{
for
(
int
j
=
1
; j
<=
n;
++
j)
printf(
“
%8d
“
, c[i][j]);
printf(
“
\n
“
);
}
Dijkstra(n,
1
, dist, prev, c);
//
最短路径长度
cout
<<
“
源点到最后一个顶点的最短路径长度:
“
<<
dist[n]
<<
endl;
//
路径
cout
<<
“
源点到最后一个顶点的路径为:
“
;
searchPath(prev,
1
, n);
}
输入数据:
5
7
1 2 10
1 4 30
1 5 100
2 3 50
3 5 10
4 3 20
4 5 60
输出数据:
999999 10 999999 30 100
10 999999 50 999999 999999
999999 50 999999 20 10
30 999999 20 999999 60
100 999999 10 60 999999
源点到最后一个顶点的最短路径长度: 60
源点到最后一个顶点的路径为: 1 -> 4 -> 3 -> 5
以下是java实现
import java.util.ArrayList;
import java.util.LinkedHashMap;
public class DijkstraPath {
/**
* @param args
*/
static int[][] cost;
static ArrayList<String> visited = new ArrayList<String>();
static ArrayList<String> unVisited = new ArrayList<String>();
static ArrayList<String> vertexs = new ArrayList<String>();
static LinkedHashMap<String ,Integer> shortPath = new LinkedHashMap<String ,Integer>();
static ArrayList<arc> arcs = new ArrayList<arc>();
static LinkedHashMap<String ,String> shortPathWay = new LinkedHashMap<String ,String>();
public static void main(String[] args) {
// TODO Auto-generated method stub
//init the verges set
arcs.add(new arc(“A”,”B”,2));
arcs.add(new arc(“A”,”C”,4));
arcs.add(new arc(“A”,”D”,15));
arcs.add(new arc(“B”,”D”,5));
arcs.add(new arc(“B”,”C”,1));
arcs.add(new arc(“C”,”D”,7));
arcs.add(new arc(“D”,”E”,4));
//init the nodes set
vertexs.add(“A”);
vertexs.add(“B”);
vertexs.add(“C”);
vertexs.add(“D”);
vertexs.add(“E”);
// init the novisited set
visited.add(“A”);
//init the visited set
unVisited.add(“B”);
unVisited.add(“C”);
unVisited.add(“D”);
unVisited.add(“E”);
//init the shortPath map
for(String unvisitNode:unVisited)
{
boolean access = false;
for(arc a:arcs)
{
if(a.startNode.equals(“A”) && a.endNode.equals(unvisitNode))
{
shortPath.put(unvisitNode,a.weight);
access = true;
break;
}
}
if(access == false)
{
shortPath.put(unvisitNode, -1);
}
}
//把第一个临近节点的前驱找到
initFirstShortPathWay();
while(unVisited.size()>0){
String lastVisitedNode = getLastVisitedNode();
for(String unvisitNode:unVisited)
{
//获得最后一访问节点到未访问节点到距离
int newPath = getWeight(lastVisitedNode,unvisitNode);
if(newPath > 0)
{
//获得源点到未访问节点的距离
int oldPath = getOldPath(unvisitNode);
//如果二者都存在话，改变shortPath 的相应值为最小值
if(oldPath > 0)
{
if(oldPath > getOldPath(lastVisitedNode)+newPath){
resetShortPath(unvisitNode,getOldPath(lastVisitedNode)+newPath);
shortPathWay.put(unvisitNode,lastVisitedNode);//后继——前驱
}
}
//如果原来不可达的话，但是通过中间节点可以到达，那么同样要改变shortPath
else
{
resetShortPath(unvisitNode,getOldPath(lastVisitedNode)+newPath);
shortPathWay.put(unvisitNode,lastVisitedNode);
}
}
}
String minNode = getTheMinPathNode();
removeNode(minNode,unVisited);
addNode(minNode,visited);
}
//输出最终结果
printResult();
}
//初始化第一个 路径的前驱
public static void initFirstShortPathWay()
{
int min = 500;
String firstNode =””;
for(String vertex:shortPath.keySet())
{
int tem = shortPath.get(vertex);
if(tem > 0){
min = min > tem?tem:min;
}
}
for(String vertex:shortPath.keySet())
{
if(min == shortPath.get(vertex))firstNode = vertex;
}
shortPathWay.put(firstNode,”A”);
}
//add a node to the set
public static void addNode(String node,ArrayList<String> set)
{
set.add(node);
}
// remove a node of the set
public static void removeNode(String delNode,ArrayList<String> set){
int index = 0;
for(int i=0;i<set.size();i++)
{
if(delNode.equals(set.get(i)))
{
index = i;
}
}
set.remove(index);
}
//得到未访问结点中shutPath的最小值的点
public static String getTheMinPathNode()
{
int min = 500; //距离超过500为不可达
String node = “”;
for(String unode:unVisited)
{
int tem = shortPath.get(unode);
if(tem>0){
min = min>tem?tem:min;
}
}
for(String unode:unVisited)
{
if(min == shortPath.get(unode))node=unode;
}
return node;
}
//得到源点到未访问结点的最短距离
public static int getOldPath(String node)
{
if(node.equals(“A”))return 0;
return shortPath.get(node);
}
//重新设定 shortPath
public static void resetShortPath(String node,int path)
{
for(String snode:shortPath.keySet())
{
if(snode.equals(node))shortPath.put(snode, path);
}
}
//get the last node of the visited set
public static String getLastVisitedNode()
{
return visited.get(visited.size()-1);
}
// get the weight
public static int getWeight(String startNode, String endNode)
{
int weight=-1;
for(arc a:arcs)
{
if(a.startNode.equals(startNode) && a.endNode.equals(endNode))
{
weight = a.weight;
System.out.println(a.startNode+”–>”+a.endNode+”=”+weight);
}
}
return weight;
}
// get the min num
public static void printResult()
{
for(String vertex:shortPath.keySet())
{
System.out.print(“从源点A到”+vertex+”的最短路径为”);
printPath(vertex);
System.out.print(vertex);
System.out.print(“长度为：”+shortPath.get(vertex));
System.out.println(” “);
}
}
public static void printPath(String vertex)
{
String node = shortPathWay.get(vertex);
if(!node.equals(“A”))printPath(node);
System.out.print(node+” “);
}
}
class arc{
String startNode = “”;
String endNode = “”;
int weight =0;
public arc(String startNode,String endNode,int weight){
this.startNode = startNode;
this.endNode = endNode;
this.weight = weight;
}
}
