引言
最短路径算法是图算法中比较重要的组成部分,在《算法导论》中有比较详细的阐述和证明。很长时间没在看过图算法的内容,在接触到增强学习后,复习了下A*算法,故对最短路径算法进行一下简单的总结,A*算法将会另外开一篇文章。Dijkstra和Floyd算法是最为经典的两个针对无向图进行最短路径求取的算法,本文先对这两个算法进行回顾和总结。
Dijkstra算法
Dijkstra算法在解决最短路径算法时有一定的局限性,要求图中不能存在负边权重(具体的证明可参考《算法导论》)。个人看来Dijkstra算法应该属于贪心算法的部分,但某些参考书籍把它归入到了动态规划的范围。当然我们不会对这个问题深究,看自己证明好理解吧。Dijkstra是从源点出发,一次求取到其余所有点的最短路径。这也称为单源最短路径。
算法的大致是先从源点
S
出发,选取距离源点距离最短的点
如上图,现在我们要求从源点
(1). 将
A
放入最后的结果中
(2). 选取与
A
距离最短的点,显然是
(3). 由于
C
已经被选取,在下一次选择距离
(4). 以此类推,选择
D
并更新和
最后
Ret={A,C,B,D,E,F}
,这便是源点
A
到图中所有点的最短路径,例如求
const int MAXINT = INT_MAX; //图中不直接连接的点的权重定义
const int MAXNUM = 6; //图中的节点数目
int dst[MAXNUM]; //存放源点到其它点的距离
int prev[MAXNUM]; //存放路径
int G[MAXNUM][MAXNUM]; //图的邻接矩阵
void Dijstra(int v0)
{
bool used[MAXNUM]; // 判断图中节点时候已经被加入最后的结果中,初始为false
int node_num = MAXNUM;
for(int i = 1; i<=n; i++)
{
dst[i] = G[v0][i]; //从邻接矩阵中获取距离信息
used[i] = false;
if( MAXINT == dst[i] )
prev[i] = -1;
else
prev[i] = v0; // 设置源点直接连接的点的前驱为源点
}
dst[v0] = 0; // 源点到源点的距离设置为0
used[v0] = true; //标记源点已经被加入最后的结果中
for(int i = 2; i <= n; i++){
int mindst = MAXINT;
int u = v0;
for(int j = 1; j <= n; j++) // 选取目前距离矩阵中与源点最短距离的点
{
if( (!used[j]) && dst[j] < mindst){
u = j;
mindst = dst[j];
}
used[u] = true; //将该点加入到最后结果中
for(int j = 1; j <= n; ++j)
{
if( (!used[j]) && G[u][j] < MAXINT)
{
if(dst[u]+G[u][j] < dst[j])
{
dst[j] = dst[u]+G[u][j]; // 更新距离
pre[j] = u; // 设置前驱
}
}
}
}
}
}
Floyd算法
Dijkstra算法是解决单源最短路径算法,当需要解决图中任意两点的最短路径时,Dijkstra则需要多次计算,而且,当图中存在负的边权重时,Dijkstra则显得无能为力。Floyd算法的提出很好的解决了这一问题,能一次求出任意两点的最短路径,并且边权重可正可负。
Floyd算法的思想是从两点最短路径的可能性思考的,两点之间的最短路径无非有如下几个情况:
(1). 两点直接到达的距离最短。
(2). 两点之间通过1个或者1个以上节点连接到达的距离最短。
所以,如果是第一种情况,则可以在邻接矩阵中直接获取。如果是第二种情况,则需要依次判断以每个点为中间点连接起点和终点的最短距离。如果需要中间点的个数大于1,则将问题继续划分为其它终点和起点的问题。例如求AB间的最短距离,对于中间点有C,那么则需要判断
distance(A,B)
与
distance(A,C)+distance(C,B)
的大小,如果还有其它点,则间
distance(A,C)
和
distance(C,B)
按照这种方式继续划分下去,很显然,Floyd算法其实就是一种自顶而低的动态规划。我们先给出代码:
void getGraphicData(){//获取数据
ifstream in("data");
in>>vertexnum>>edgenum; //获取节点数和边数
int from,to;
double w;
// 初始化邻接矩阵和路径矩阵
while(in>>from>>to>>w){
weight[from][to] = w;
path[from][to] = from;
weight[from][from] = 0;
path[from][from] = from;
weight[to][to] = 0;
path[to][to] = to;
}
}
void floyd(){
for(int k = 0;k < vertexnum;k++) // 中间点变量
for(int i= 0;i < vertexnum;i++) // 起点变量
for(int j = 0;j < vertexnum;j++){ //终点变量
weight[i][j] = min(weight[i][j], weight[i][k] + weight[k][j]);
path[i][j] = path[k][j];
}
}
}
void displaypath(int source,int dest){ // 求取路径
stack<int> shortpath;
int temp = dest;
while(temp != source){
shortpath.push(temp);
temp = path[source][temp];
}
shortpath.push(source);
cout<<"short distance:"<<weight[source][dest]<<endl<<"path:";
while(!shortpath.empty()){
cout<<shortpath.top()<<" ";
shortpath.pop();
}
}
结合下图:
(1). 初始化工作无非就是对图的邻接矩阵就行初始化,直接连接的边为常数权重,非直接连接的边初始化为无穷大,路径矩阵则是对点的前驱进行计算。
(2). 首先确定中间点
k
,例如
(3). 最后是确立路径,也就是起点和终点之间的中间点。
Floyd算法在实现时有一点需要注意,就是中间点的循环(这里时k)必须在外层,如果放在内层时,有的路径权重不会改变,这会对最后的结果产生错误,说起来比较难懂,可以手动模拟一下,就会发现这个问题。
小结
Dijkstra算法适合于单点的路径就算,而当需要任意两点间的最短路径时,Floyd算法比
V
次Dijkstra算法效率要高,并且当图中存在负权重时,Dijkstra则无能为力。除了这两种算法外,SPFA对于稀疏图的效率比较高,但计算任意两点的最短路径时,Floyd算法的效率依然高于