再谈Dijkstra算法和堆优化

Orz，今天和Java老师讨论到了图的遍历，然后扩展到最短路。感觉现场在黑板写还是有点紧张，大脑一下子有点懵，本身自己说话就有点口吃，好多都没表达出来，也不知道怎么表达。感觉如果以后面试的时候这样面对HR提问肯定会爆炸啊！！！自己汉语都说不流利，还学毛线的外语！

下面再回顾下dij算法思路和代码：

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

首先Java老师是我认为讲的最干练的一位老师了，虽然课时有限，我之前搞过一段时间Java，感觉以前遇到的重难点老师都点到了。而其他小枝末节让我们自己下来实践。

老师一直强调了dfs(深度优先遍历)的重要性，确实，dfs在图论中一直占据着重要的角色。可扩展到图论中割顶，桥，拓扑，双连通分量，强连通分量问题的解决上。基于深搜的Tarjan算法我到现在都还没时间看(Orz,大二下学期每天满课)。在做一些算法题目的过程中，深搜感觉可以解决大部分搜索类题目了，但是深搜难在剪枝，剪枝可以减少大量不必要的搜索过程。这部分我自己做的不够好。投入时间首先都没达到。

用邻接矩阵的Dijkstra算法的代码：

int mp[maxn][maxn];
int dis[maxn];
bool visit[maxn];
int n,m;   //V,E
    void Dijkstra( int s )
    {
        int i,v,u;
        for( i=1; i<=n; ++i )
        {
            visit[i]=false;
            dis[i]=mp[1][i];
        }
        dis[s]=0;
    while( true )
    {
        v=-1;
        for( u=1; u<=n; ++u )
            if( !visit[u] && ( v==-1 || dis[u]<dis[v]) )
                v=u;
        if( v==-1 ) break;
        visit[v]=true;


        for( u=1; u<=n; u++ )
            dis[u]= min( dis[u],dis[v]+mp[v][u] );
    }
}

Dij算法是基于广搜，松弛的时候有点贪心和动态规划的思想。

使用邻接矩阵实现的dijkstra算法的复杂度是O(V²)。使用邻接表的话，更新最短距离只需要访问每条边一次即可，因此这部分的复杂度是O(E).但是每次要枚举所有的顶点来查找下一个使用的顶点，因此最终复杂度还是O(V²)。在|E|比较小时，大部分的时间都花在了查找下一个使用的顶点上，因此需要使用合适的数据结构进行优化。

  优先队列+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|)来说，尤为有效~

堆的实现原理这里就不说了，在很多书里面都有详细介绍。

下面是使用STL的priority_queue实现。在每次更新时往堆里插入当前最短距离和顶点的值对。

#include <iostream>  
#include <cstdio>  
#include <queue>  
#include <vector>  
using namespace std;  
const int Ni = 10000;  
const int INF = 1<<27;  
struct node{  
    int x,d;  
    node(){}  
    node(int a,int b){x=a;d=b;}  
    bool operator < (const node & a) const  
    {  
        if(d==a.d) return x<a.x;  
        else return d > a.d;  
    }  
};  
vector<node> eg[Ni];  
int dis[Ni],n;  
void Dijkstra(int s)  
{  
    int i;  
    for(i=0;i<=n;i++) dis[i]=INF;  
    dis[s]=0;  
    //用优先队列优化  
    priority_queue<node> q;  
    q.push(node(s,dis[s]));  
    while(!q.empty())  
    {  
        node x=q.top();q.pop();  
        for(i=0;i<eg[x.x].size();i++)  
        {  
            node y=eg[x.x][i];  
            if(dis[y.x]>x.d+y.d)  
            {  
                dis[y.x]=x.d+y.d;  
                q.push(node(y.x,dis[y.x]));  
            }  
        }  
    }  
}  
int main()  
{  
    int a,b,d,m;  
    while(scanf("%d%d",&n,&m),n+m)  
    {  
        for(int i=0;i<=n;i++) eg[i].clear();  
        while(m--)  
        {  
            scanf("%d%d%d",&a,&b,&d);  
            eg[a].push_back(node(b,d));  
            eg[b].push_back(node(a,d));  
        }  
        Dijkstra(1);  
        printf("%d\n",dis[n]);  
    }  
    return 0;  
}  
/* 
6 6 
1 2 2 
3 2 4 
1 4 5 
2 5 2 
3 6 3 
5 6 3 
*/  

最后一点，dij算法不能解决负权值问题。还是需要使用Bellman-Ford算法或者SPFA算法。

自己还是菜的要命

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26