在上一篇博文里，我记录了最小生成树的算法实现，而在这篇里，我们来讲讲查找最短路径的算法，Dijkstra算法。
Dijkstra’s algorithm常用于路由算法或者作为其他图算法的一个子模块。距离来说，如果我们将图的顶点理解为每个城市，而边上的权重表示城市间开车行径的路径，该算法可以用来找到两个城市之间的最短路径。
Dijkstra算法是通过为每个顶点v保留目前为止所找到的从s到v的最短路径来工作的。初始时，原点s的路径权重被赋为0(d[s] = 0)。若对于顶点s存在能直接到达的边，则比较路径的长度，如果路径更短则更新存储的值，当算法结束时，d[v]中存储的便是从s到v的最短路径，或者如果路径不存在的话则是无法访问，用marked数组来记录从s到点v是否存在路径。下面我们来看Dijkstra算法的代码实现，首先是C++版本：
#include <iostream>
#include <vector>
#include <stack>
#include "Edge.h"
#include "IndexMinHeap.h"
using namespace std;
// Dijkstra算法求最短路径
template <typename Graph, typename Weight>
class Dijkstra {
private:
Graph &G; // 图的引用
int s; // 起始点
Weight *distTo; // distTo[i]存储从起始点s到i的最短路径长度
bool *marked; // 标记数组，在算法运行过程中标记节点i是否被访问
vector<Edge<Weight> *> from; // from[i]记录最短路径中，到达i点的边是哪一条
// 可以用来恢复整个最短路径
public:
// 构造函数，使用Dijkstra算法求最短路径
Dijkstra(Graph &graph, int s):G(graph) {
// 算法初始化
assert( s >= 0 && s < G.V() );
this->s = s;
distTo = new Weight[G.V()];
marked = new bool[G.V()];
for (int i = 0; i < G.V(); i++) {
distTo[i] = Weight();
marked[i] = false;
from.push_back(NULL);
}
// 使用索引堆记录当前找到的到达每个顶点的最短距离
IndexMinHeap<Weight> ipq(G.V());
// 对于起始点s进行初始化
distTo[s] = Weight();
from[s] = new Edge<Weight>(s, s, 0);
ipq.insert(s, distTo[s]);
marked[s] = true;
while( !ipq.isEmpty() ) {
int v = ipq.extractMinIndex();
// distTo[v] 就是s到v的最短距离
marked[v] = true;
// 对v的所有相邻节点进行更新
typename Graph::adjIterator adj(G, v);
for ( Edge<Weight> *e = adj.begin(); !adj.end(); e = adj.next() ) {
int w = e->other(v);
// 如果从s点到w点的最短路径还没有找到
if ( !marked[w] ) {
// 如果w点以前没有访问过
// 或者访问过，但是通过当前的v点到w点距离更短，则进行更新
if ( from[w] == NULL || distTo[v] + e->wt() < distTo[w] ) {
distTo[w] = distTo[v] + e->wt();
from[w] = e;
if ( ipq.contain(w) )
ipq.change( w, distTo[w] );
else
ipq.insert( w, distTo[w] );
}
}
}
}
}
// 析构函数
~Dijkstra() {
delete[] distTo;
delete[] marked;
delete from[0];
}
// 返回从s点到w点的最短路径长度
Weight shortestPathTo( int w ) {
assert( w >= 0 && w < G.V() );
assert( hasPathTo(w) );
return distTo[w];
}
// 判断从s点到w点是否联通
bool hasPathTo( int w ) {
assert( w >= 0 && w < G.V() );
return marked[w];
}
// 寻找从s到w的最短路径，将整个路径经过的边存放在vec中
void shortestPath( int w, vector< Edge<Weight> > &vec ) {
assert( w >= 0 && w < G.V() );
assert( hasPathTo(w) );
// 通过from数组逆向查找到从s到w的路径，存放在栈中
stack<Edge<Weight>*> s;
Edge<Weight> *e = from[w];
while(e->v() != this->s) {
s.push(e);
e = from[e->v()];
}
s.push(e);
// 从栈中依次取出元素，获得顺序的从s到w的路径
while( !s.empty() ) {
e = s.top();
vec.push_back(*e);
s.pop();
}
}
// 打印从s点到w点的路径
void showPath( int w ) {
assert( w >= 0 && w < G.V() );
assert( hasPathTo(w) );
vector< Edge<Weight> > vec;
shortestPath( w, vec );
for (int i = 0; i < vec.size(); i++) {
cout << vec[i].v() << " -> ";
if ( i == vec.size() - 1 ) {
cout << vec[i].w() << endl;
}
}
}
};
之后是java版本的:
// Dijkstra算法求最短路径
public class Dijkstra<Weight extends Number & Comparable> {
private WeightedGraph G; // 图的引用
private int s; // 起始点
private Number[] distTo; // distTo[i]存储从起始点s到点i的最短路径长度
private boolean[] marked; // 标记数组，在算法运行过程中标记节点是否被访问
private Edge<Weight>[] from; // 可以用来恢复整个最短路径
// 构造函数，使用Dijkstra算法求最短路径
Dijkstra(WeightedGraph graph, int s) {
// 算法初始化
this.G = graph;
assert s >= 0 && s < G.V();
this.s = s;
distTo = new Number[G.V()];
for (int i = 0; i < G.V(); i++) {
distTo[i] = 0.0;
marked[i] = false;
from[i] = null;
}
// 使用索引堆记录当前找到的每个到达顶点的最短距离 iikkkkkk
IndexMinHeap<Weight> ipq = new IndexMinHeap<Weight>(G.V());
// 对于起始点s进行初始化
distTo[s] = 0.0;
from[s] = new Edge<Weight>(s, s, (Weight)(Number)(0.0));
ipq.insert(s, (Weight) distTo[s]);
marked[s] = true;
while (!ipq.isEmpty()) {
int v = ipq.extractMinIndex();
// distTo[v]就是s到v的最短距离
marked[v] = true;
// 对v的所有相邻节点进行更新
for (Object item : G.adj(v)) {
Edge<Weight> e = (Edge<Weight>) item;
int w = e.other(v);
// 如果s点到w点的最短路径还没有找到
if (!marked[w]) {
// 如果w点以前没有访问过
// 或者访问过，但是通过当前v点到w点的距离g更短，则进行更新
if (from[w] == null || distTo[v].doubleValue() + e.wt().doubleValue() < distTo[w].doubleValue()) {
distTo[w] = distTo[v].doubleValue() + e.wt().doubleValue();
from[w] = e;
if ( ipq.contain(w) ) {
ipq.change(w, (Weight) distTo[w]);
} else {
ipq.insert(w, (Weight) distTo[w]);
}
}
}
}
}
}
// 返回从s点到w点的最短路径长度
public Number shortestPathTo(int w) {
assert w >= 0 && w < G.V();
assert hasPathTo(w);
return distTo[w];
}
// 判断从s点到w点是否联通
public boolean hasPathTo(int w) {
assert w >= 0 && w < G.V();
return marked[w];
}
// 寻找从s点到w点的最短路径，将整个路径存放在vec中
private Vector<Edge<Weight>> shortestPath(int w) {
assert w >= 0 && w < G.V();
assert hasPathTo(w);
// 通过from数组逆向查找从s到w的路径，存放到栈中
Stack<Edge<Weight>> s = new Stack<Edge<Weight>>();
Edge<Weight> e = from[w];
while (e.v() != this.s) {
s.push(e);
e = from[e.v()];
}
s.push(e);
// 从栈中依次取出元素，获得顺序的从s到w的路径
Vector<Edge<Weight>> res = new Vector<Edge<Weight>>();
while (!s.isEmpty()) {
e = s.pop();
res.add(e);
}
return res;
}
// 打印出从s点到w点的路径
public void showPath(int w){
assert w >= 0 && w < G.V();
assert hasPathTo(w);
Vector<Edge<Weight>> path = shortestPath(w);
for( int i = 0 ; i < path.size() ; i ++ ){
System.out.print( path.elementAt(i).v() + " -> ");
if( i == path.size()-1 )
System.out.println(path.elementAt(i).w());
}
}
}