Dijkstra算法2

// 再来一手精髓的Dijkstra
// 复杂度O( E*log(V) )

#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const int max_N = 1000+2;
const int max_E = 10000+2;
const int INF = 1e9;

int N,E;
int d[max_N];

// 来自何方，已经不重要了。
// 实际上是在邻接表实现的过程中，行号即为来自的顶点
struct edge
{
    int to,cost;
};
// P.first代表距离，P.second代表顶点编号
typedef pair<int,int> P;

vector<edge> G[max_N];

// 这一个算法下来，我们在数组d中得到了从s点到其余所有顶点的最短路程
void dijkstra(int s)
{
    // 建立最堆，来维护最小距离，可以降低一层复杂度
    priority_queue< P,vector<P>,greater<P> > que;

    fill(d,d+N,INF);
    d[s]=0;
    que.push(P(0,s));

    while(!que.empty())
    {
        // 取出一个顶点，看是否是Dijstra算法中，已经确定的最小顶点
        P p=que.top();
        que.pop();

        int v=p.second;
        // 让我们来看看这一步
        // 首先，每次取出堆中的最小元素
        // 然后去检索这个堆顶元素的标号所对应的距离
        // 咦，你会发现堆顶这个距离，竟然比取出的最小元素还要小
        // 惊讶？难道出错了？没有，考虑Dijkstra算法的流程，这个顶点肯定是之前已经确定过的最小顶点了，不需要考虑
        // 之前的实现是多加了一个flag数组来标记，这里可以省去这部分内存，直接用这个条件来判断
        if(d[v]<p.first)
        {
            continue;
        }

        for(int i=0;i<G[v].size();++i)
        {
            edge e=G[v][i];
            if(d[e.to] > d[v] + e.cost)
            {
                d[e.to]=d[v]+e.cost;
                // 数组中维护此次被更新的节点即可，其余节点不需要维护
                que.push(P(d[e.to],e.to));
            }
        }
    }

}

int main()
{
    int a,b,c;
    scanf("%d %d",&N,&E);
    for(int i=0;i<E;++i)
    {
        scanf("%d %d %d",&a,&b,&c);
        edge e;
        e.to=b;
        e.cost=c;
        G[a].push_back(e);
        // 无向图
        e.to=a;
        e.cost=c;
        G[b].push_back(e);
    }

    dijkstra(0);

    for(int i=0;i<N;++i)
    {
        printf("%d ",d[i]);
    }

    return 0;
}

/*
7 10
0 1 2
0 2 5
1 2 4
1 3 6
1 4 10
2 3 2
3 5 1
4 5 3
4 6 5
5 6 9


*/