dijkstra算法与优先队列

　　这是鄙人的第一篇技术博客，作为算法小菜鸟外加轻度写作障碍者，写技术博客也算是对自己的一种挑战和鞭策吧~

　　言归正传，什么是dijkstra算法呢？

　　　　　　　　　　-dijkstra算法是一种解决最短路径问题的简单有效的方法~也算是一种非常naive&effcient的最优化算法吧~

最短路径问题

　　如上图，从点A->点F，最短路径为A->C->D->F，Min=3+3+3=9

　　假设用暴力深度搜索遍历所有路径的话，时间复杂度O将会是指数级的(NP-hard Problem)~

　　dijkstra算法

　  作为我最喜欢的经典算法之一，dijkstra算法并没有用到高深的图论和拓扑学的知识，

　  它的核心思想也很简单：贪心法+动态规划

下面贴出维基百科上的伪代码：

 1  function Dijkstra(Graph, source):
 2      dist[source]  := 0                     // Distance from source to source
 3      for each vertex v in Graph:            // Initializations
 4          if v ≠ source
 5              dist[v]  := infinity           // Unknown distance function from source to v
 6              previous[v]  := undefined      // Previous node in optimal path from source
 7          end if
 8          add v to Q                         // All nodes initially in Q (unvisited nodes)
 9      end for
10
11      while Q is not empty:                  // The main loop
12          u := vertex in Q with min dist[u]  // Source node in first case
13          remove u from Q
14
15          for each neighbor v of u:           // where v has not yet been removed from Q.
16              alt := dist[u] + length(u, v)
17              if alt < dist[v]:               // A shorter path to v has been found
18                  dist[v]  := alt
19                  previous[v]  := u
20              end if
21          end for
22      end while
23      return dist[], previous[]
24  end function

　 贪心的思想体现在 Line12:  u := vertex in Q with min dist[u]

　　　　从所有的待优化的点Q中找出距离起点最近的点u~

　 动态规划的思想体现在  Line16-20:  最优表达式为 dist[v] := min{dist[v],dist[u] + length(u, v)}

　　　　　　即如果存在dist[start->u->v]<dist[start->v]，则将路径更新~

　　

　 在dijkstra算法里，每个点的路径可能会被更新N次(length(Q)>N>=0)，并不存在一个明确的状态递进。

因此，如何保证在更新N次后，一定能求出最优解，是算法的核心问题~

答案就是贪心法，运用贪心法优化更新的顺序，确保从小到大，更新一遍Q即求出最优解。

优先队列+dijkstra算法

让我们分析一下dijkstra算法的时间复杂度：

　　　　总时间复杂度=找最短距离  u := vertex in Q with min dist[u] 的时间复杂度 +

　　　　　　　　　　　更新距离   dist[v] := min{dist[v],dist[u] + length(u, v)} 的时间复杂度

　　　　对于一个无向图G(V,E)来说，

　　　　　　找最短距离的时间复杂度为O(|V|*|V|)(共循环V次，每次V个点)，考虑到Q每次递减1，实际复杂度为O(|V|^2/2)；

　　　　　  由于图共有E条边，每条边最多被更新2次（1条边2个端点），因此更新距离的时间复杂度为O(2*|E|)。

　　　　　　因此，总时间复杂度=O(2*|E|+|V|^2/2)

　　

　　然后，实际情况中经常会遇到 |V|^2>>|E| 的稀疏图，即O(2*|E|+|V|^2/2)=O(|V|^2/2)~

因此，如果我们能够优化 findMIN部分，即可大大优化稀疏图下的dijkstra算法~

findMIN的部分优化方法很多，最简单的就是用二分搜索O(logN)代替线性搜索 O(N)~

这里我们将集合Q转化成一个优先队列(priority queue)，这样findMIN的时间复杂度变成了O(1)，而每次更新priority queue需要花费O(log|V|)~

综上，采用优先队列之后，总时间复杂度=O(2*|E|+|V|*log|V|),

　　　　　　这样的优化对于稀疏图(|V|^2>>|E|)来说，尤为有效~

　

　  P.S. 本文仅想谈谈鄙人对dijkstra算法的一些浅见，即粗浅又不够系统，还望各位大牛多多指点~

　　　　下一篇博文将会拓展 优先队列(priority queue)  的内容（如果鄙人木有被板砖拍死的话^ ^）

　最后贴上鄙人用python实现的dijkstra+priority queue的demo，经测试在G(V=2000,E=10000)时，priority queue能够提升近1倍的运算速度:

　　

 # -*- coding: utf-8 -*-
 """
 Created on Sun Aug 24 2014

 @author: Sperling
 """
 import random,time,heapq

 ###采用优先队列的dijkstra算法###
 def dijkstra_pq(conj):
     ##初始化 各点到起点的最优距离(dis)##
     dis=[0]
     dis.extend([-1]*(len(conj)-1))
     for c in conj[0]:
         dis[c[1]]=c[0]
     ##初始化  待优化的点(排除起点)##
     pool=[i for i in range(1,len(conj))]
     ##初始化 路径记录列表##
     pre=[0 if dis[i]>=0 else -1 for i in range(len(conj))]
     pre[0]=-1
     ##初始化 优先队列(Fibonacci heap)##
     pq=[(dis[i],i) for i in range(1,len(conj)) if dis[i]>=0]
     heapq.heapify(pq)

     while len(pool)>0:
         ##找出待优化池中的最短路径点(argmin)##
         argmin=-1
         while (argmin not in pool) and len(pq)>0:
             MIN,argmin=heapq.heappop(pq)
         ##将最短路径点(argmin)从池中捞出##
         if argmin not in pool:
             break
         else:
             pool.remove(argmin)
         ##更新与argmin直接连通的点<->起点的最短路径##
         for c in conj[argmin]:
             if c[0]+MIN<dis[c[1]] or dis[c[1]]<0:
                 dis[c[1]]=c[0]+MIN
                 pre[c[1]]=argmin
                 heapq.heappush(pq,(dis[c[1]],c[1]))

     return dis,pre           

 ###原始dijkstra算法###
 def dijkstra(conj):
    ##初始化 各点到起点的最优距离(dis)##
     dis=[0]
     dis.extend([-1]*(len(conj)-1))
     for c in conj[0]:
         dis[c[1]]=c[0]
     ##初始化  待优化的点(排除起点)##
     pool=[i for i in range(1,len(conj))]
     ##初始化 路径记录列表##
     pre=[0 if dis[i]>=0 else -1 for i in range(len(conj))]
     pre[0]=-1

     while len(pool)>0:
         ##找出待优化池中的最短路径点(argmin)##
         MIN,argmin=1000000,-1
         for i in pool:
             if dis[i]>0 and MIN>=dis[i]:
                 MIN,argmin=dis[i],i
         ##将最短路径点(argmin)从池中捞出##
         if argmin<0:
             break
         else:
             pool.remove(argmin)
         ##更新与argmin直接连通的点<->起点的最短路径##
         for c in conj[argmin]:
             if c[0]+MIN<dis[c[1]] or dis[c[1]]<0:
                 dis[c[1]]=c[0]+MIN
                 pre[c[1]]=argmin

     return dis,pre        

 ###回溯最优路径###
 def trace(pre,p):
     route=[]
     while p>=0:
         route.append(p)
         p=pre[p]
     return route[::-1]

 ###构造随机图，不能保证图的连通性###
 def randomroute(nV,nE):
     ##构造nE*nE的随机关联矩阵(mat)，其中有2*nV个点是连通的##
     mat=[[0 if i==j else -1 for i in range(nV)] for j in range(nV)]
     rE=random.sample(xrange(nV*(nV-1)/2),nE)
     for k in rE:
         i,j=0,k
         while i<j:
             i+=1
             j-=i
         i+=1
         r=random.randint(1,100)
         mat[i][j],mat[j][i]=r,r
     ##将随机关联矩阵(mat) 转化为 每个顶点的直接连通点列表(route)##
     route=[]
     for i in range(len(mat)):
         route.append([])
         for j in range(len(mat[i])):
             if mat[i][j]>0:
                 route[i].append((mat[i][j],j))

     return route

 if __name__=='__main__':
     conj=randomroute(2000,10000)
     t0=time.clock()
     dis,pre=dijkstra(conj)
     t1=time.clock()
     print 'time_cost dijkstra:%f'%(t1-t0)
     print dis[len(conj)-1]
     print trace(pre,len(conj)-1)

     t0=time.clock()
     dis,pre=dijkstra_pq(conj)
     t1=time.clock()
     print 'time_cost dijkstra+priority queue:%f'%(t1-t0)
     print dis[len(conj)-1]
     print trace(pre,len(conj)-1)