HDOJ2544最短路-----堆优化的Dijkstra

题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=2544

Problem Description

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？
 

 

 

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

 

 

Output

对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

 

 

Sample Input

2 1 1 2 3 3 3 1 2 5 2 3 5 3 1 2 0 0

 

 

Sample Output

3 2

题意：就是一个模板的单源最短路问题，这里采用了堆优化的迪杰特斯拉算法。

朴素的迪杰特斯拉时间复杂度是O（n^2），内循环每次在dis数组里寻找最小时都会有一个O（n）的时间复杂度，

如果采用小顶堆，那么每次内循环的复杂度将为O（logn），总的时间复杂度可以优化为O（n*logn）

采用优先队列优化，需要注意几个问题：

① 优先队列重载运算符有2种形式，一种是直接用友元函数（或者普通函数） ，还有一种是结构体中用常成员函数（重载函数末尾必须加个const，不然编译报错）。

②每次弹出一个最小值就可以确定一个节点的最短路，然后需要更新其它节点的最短路。理论上需要把原来在队列中的最短路替换成更新后的值，但是优先队列只能取根节点的值，所以这个做不到，不过其实也不需要这样做。

因为更新后的值比原来的值更小，直接把更新后的值push进优先队列即可，每次pop的时候如果一个节点对应有多个最短路的值，只会pop出最小的，然后再用flag数组标记下节点已经找到最短路，下次再pop出这个节点时直接continue就行了。

③下面代码初始化的时候，一定要注意node数组除起点外全部初始化成INF,不然while循环执行1次就出去了（我因为这个原因WA了45次....）

    #include <cstdio>
    #include <algorithm>
    #include <cstring>
    #include <queue>
    #define INF 0x3f3f3f3f
    using namespace std;
    int n,m;
    bool flag[105];// 标记是否找到最短路
    int G[105][105];// 存图Graph
    
    struct Node {
        int dis;// 距离数组
        int pos;// 节点编号
    }node[105];
    
    int operator < (const Node &a,const Node &b) {
        return a.dis > b.dis;
    }
    
    priority_queue<Node> q;// 优先队列
    
    // 初始化
    void Init() {
        memset(flag,0,sizeof(flag));
        for (int i = 1;i <= n;i++) {
            node[i].dis = INF;
            node[i].pos = i;
                
        }
        node[1].dis = 0;
        while(!q.empty()) {
            q.pop();
        }
    }
    
    // 迪杰特斯拉算法
    void Dijkstra() {
        q.push(node[1]);
        int count = 0;
        while(!q.empty()) {
            Node t = q.top();
            q.pop();
            if(flag[t.pos] == true) {
                continue;
            }
            flag[t.pos] = true;
            // 更新node
            for(int i = 1;i <= n;i++) {
                if(flag[i])
                    continue;
                
                if(G[i][t.pos]+node[t.pos].dis < node[i].dis) {
                    // 更新最短路
                    node[i].dis = G[i][t.pos]+node[t.pos].dis;
                    q.push(node[i]);
                }
            }
        }
    }
    
    
    int main()
    {
        while(scanf("%d%d",&n,&m) != EOF) {
            if(n == 0 && m == 0)
                break;
            for(int i = 1;i < 105;i++)
                for(int j = 1;j < 105;j++) {
                    if(i == j) {
                        G[i][j] = 0;
                    }
                    else {
                        G[i][j] = G[j][i] = INF;
                    }
                }
            int a,b,c;      
            for(int i = 0;i < m;i++) {
                scanf("%d%d%d",&a,&b,&c);
                if(G[a][b] > c)
                    G[a][b] = G[b][a] = c;
            }
            Init();
            Dijkstra();
            printf("%d\n",node[n].dis);
        }
        
        return 0;
    }