笔试算法题(49):简介 - 图最短路径算法

图最短路径算法(Graph Shortest Path Algorithm, eg: Floyd-Warshall, Dijkstra, Bellman-Ford, SPFA, Kruskal, Prim, Johnson)

  • 最短路径问题有多个衍生问题(并且每个衍生问题都涉及是否有负权边)

    单源点最短路径

    单终点最短路径

    单对顶点最短路径

    任意顶点间最短路径

Floyd-Warshall Algorithm

  • 适用于多源,可有负权边的有向图的最短路径;时间复杂度为O(V^3),空间复杂度为O(V^2);

  • 二维数组path[i][j]表示顶点i到顶点j之间的代价(初始化时由于没有探测他们之间的代价关系,所以为无限大);本算法采取的策略是穷举所有顶点对之间所有可能的中间顶点,并选择代价最小的作为最优解;

 1 procedure FloydWarshallWithPathReconstruction ()
 2  for k := 1 to n
 3    for i := 1 to n
 4      for j := 1 to n
 5        if path[i][k] + path[k][j] < path[i][j] then
 6           path[i][j] := path[i][k]+path[k][j];
 7           next[i][j] := k; //next[i][j]表示顶点i和顶点j的中间点
 8 
 9  procedure GetPath (i,j)
10  if path[i][j] equals infinity then
11     return "no path";
12  int intermediate := next[i][j];
13  if intermediate equals 'null' then
14     return " "; /* there is an edge from i to j, with no vertices between */
15  else
16     return GetPath(i,intermediate) + intermediate + GetPath(intermediate,j);

 

Dijkstra Algorithm

  • 适用于有向、无负权边图中,单个源点到其他所有顶点的最短路径问题(Single-Source Shortest Path Problem for Graph with Non-Negative Edge Path Costs)。给定一个带权重的有向图G,V表示所有点的集合,E表示所有边的集合,并且每条边具有权重值w,要求找到给定start点到V中所有其他点 的最短距离。在寻路过程中,如果发现一个新的顶点M,并且从源点到这一个顶点M再到前一个目标顶点的距离比之前的距离小,则更新这个目标定点的最小距离;

  • Dijkstra算法适用于稠密图(边多点少),时间复杂度:使用最小优先队列实现Extract_Min()函数的话,为O(V^2 + E);使用二叉堆实现Extract_Min()函数的话,为O(V^2);使用斐波那契堆(Fibonacci Heap)实现Extract_Min()函数的话,为O(V*lgV + E);Dijkstra算法的一个应用是OSPF(Open Shortest Path First,开放最短路径优先),网络路由寻址的实现

 1 function Dijkstra(G, w, s)
 2  for each vertex v in V[G] //初始化
 3     d[v] := infinity //d[v]存储其他顶点到起始点s的最短距离
 4     previous[v] := undefined //previous[v]存储所有顶点的前置节点
 5  d[s] := 0
 6  S := empty set
 7  Q := set of all vertices
 8  while Q is not an empty set // Dijkstra演算法主體
 9     u := Extract_Min(Q) //Extract_Min()一般使用最小堆实现O(logN)
10     S := S union {u}
11     for each edge (u,v) outgoing from u
12        if d[v] > d[u] + w(u,v) //根据当前节点u的d[u]更新其相邻节点的d[v]
13           d[v] := d[u] + w(u,v)
14           previous[v] := u

 

Bellman-Ford Algorithm

  • 适用于单源、可有负权边的有向图的最短路径,Bellman-Ford对每个顶点都只进行一次处理,所以可以处理负权边,而Dijkstra由于是根据边权值大小选择下一条边,所以负权边可能造成循环;此算法时间复杂度为O(VE),空间复杂度为O(V);

  • 数组V[k]表示所有顶点到source的最短距离(初始化为Infinite),并且使用数组P[h]记录所有顶点的前驱,用于记录最短路径;遍历所有 的边集合E内的边e,e连接顶点u和v,判断u和v之间是否可以组成最短路径,这样的遍历重复|V|次;由于V[k]中元素初始化为Infinite,所 以如果如果某个环内存在负权值边,则算法失败;

 1 procedure BellmanFord(list vertices, list edges, vertex source)
 2    // This implementation takes in a graph, represented as lists of vertices
 3    // and edges, and modifies the vertices so that their distance and
 4    // predecessor attributes store the shortest paths.
 5 
 6    // Step 1: initialize graph
 7    for each vertex v in vertices:
 8        if v is source then v.distance := 0
 9        else v.distance := infinity
10        v.predecessor := null
11 
12    // Step 2: relax edges repeatedly
13    for i from 1 to size(vertices)-1:
14        for each edge uv in edges: // uv is the edge from u to v
15            u := uv.source
16            v := uv.destination
17            if u.distance + uv.weight < v.distance:
18                v.distance := u.distance + uv.weight
19                v.predecessor := u
20 
21    // Step 3: check for negative-weight cycles
22    for each edge uv in edges:
23        u := uv.source
24        v := uv.destination
25        if u.distance + uv.weight < v.distance:
26            error "Graph contains a negative-weight cycle"

 

SPFA (Shortest Path Faster Algorithm)

  • 适用于单源、可有负权边的有向图;大多数时候当图存在负权边,Dijkstra不能使用,而Bellman-Ford时间复杂度过高,所以最好使用 SPFA;其实SPFA是Bellman-Ford的优化版本,时间复杂度为O(kE),K是一个远小于V的数字,表示所有顶点进入FQ队列的平均次数 (<=2),但是SPFA及其不稳定,并严重依赖于图数据;

  • SPFA的策略是只有那些在前一次的Relax中的最小距离减小的点,才检查他们的邻接节点的最小距离是否也可减小。SPFA并不会在每一个顶点的最短路 径更新之后就去更新与其相连的顶点,而是等所有顶点都处理完全之后再进行最短路径的更新,这样大大减少重复更改最短路径的次数;所以SFPA中顶点会多次 进入队列,SPFA适合用于稀疏图,此时其拥有最高的效率;

  • 数组D[k]存储所有其他顶点到Source的最短距离(初始化为Infinite);数组G[i][j]存储图中直接相连的顶点之间的距离;FIFO队 列Q存储需要进一步优化的顶点,每次从Q中取出顶点u,对每一个u直接相连的顶点v进行Relax操作,如果顶点v的最短距离改变了,并检查v没有在Q 中,则将v加入Q中,之后处理下一个与u直接相连的顶点;检查完u所有直接相连的顶点之后从Q中取出下一个顶点,并进行相同的处理;当Q为空的时候算法结 束,次数D[k]存储的就是图中每一个顶点到source的最短距离;

  • 根据将顶点插入到FIFO队列Q的位置不同,SPFA可有两种优化:Small Label First (SLF)和Large Label Last (LLL);但由于SPFA及其不稳定,所以一般情况都使用Dijkstra替代;

 1 void spfa(int start){
 2   int i,j;
 3   //初始化部分
 4   for (i=1;i<=n;++i){
 5     dist[i]=2147483647;
 6     inqueue[i]=0;
 7   }
 8   //将头节点入队
 9   dist[start]=0;
10   int h=0,t=1;
11   inqueue[start]=1;
12   queue[1]=start;
13   int now;
14   do{
15     h++;
16     now=Connect[queue[h];
17     inqueue[queue[h]=0;
18     while (now){
19       if (dist[Data[now].v]>dist[queue[h]+Data[now].w){
20         dist[Data[now].v]=dist[queue[h]+Data[now].w;
21         //进行松弛并扩展被松弛的点
22         if (!inqueue[Data[now].v]){
23           inqueue[Data[now].v]=1;
24           queue[++t]=Data[now].v;
25         }
26       }
27       now=Pre[now];
28     }
29   }while (h<t);
30  }

 

Johnson Algorithm

  • 为了让Dijkstra适用于具有负权值边的图,Johnson通过特殊方式将负权值图转换为正权值图,并且为所有顶点之间的最短路径;
  • 首先进行一次Bellman-Ford,然后利用等式W(i,j)=h[i]-h[j]+w(i,j);对原图进行重新标号(Re-wrighting, 其实是去除负权值边从而可以使用Dijkstra算法,h[]就是通过Bellman-Ford得到的路径标记,w[][]是边的原始权值);最后对每个 点使用Dijkstra。Johnson是目前在无负权值图中对所有点求最短路径的最高效的算法;

转载于:https://www.cnblogs.com/leo-chen-2014/p/3756559.html

你可能感兴趣的:(笔试算法题(49):简介 - 图最短路径算法)