Dijkstra 算法

使用priority_queue实现

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <cstdlib>
#include <climits>
#include <ctype.h>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <deque>
#include <set>
#include <map>
#include <iostream>
#include <algorithm>

#define mst(a,b) memset(a,b,sizeof(a));

using namespace std;

typedef long long ll;
typedef pair<int,int> P;
const int MAX_E = 100001;
const ll mod = 1000000007;
const int INF = 0x7fffffff;

struct edge{
    int to, cost;
};

const int MAX_V = 5001;

vector<edge> G[MAX_V];
int dist[MAX_V];
int N, R;

void read(){
    int a, b, c;
    cin >> N >> R;
    for(int i = 0; i < R; i++){
        cin >> a >> b >> c;
        edge e;
        e.to = b; e.cost = c;
        edge e2;
        e2.to = a; e2.cost = c;
        G[a].push_back(e);
        G[b].push_back(e2);

    }
}
// p.first = current distance
// p.second = index

void solve(){
    priority_queue < P, vector<P>, greater<P> > que;
    fill(dist, dist+N+1, INF);
    dist[1] = 0;                // from node 1
    que.push(P(0,1));

    while(!que.empty()){
        P p = que.top();
        que.pop();
        int v = p.second;
        if(dist[v] < p.first)
            continue;
        for(int j = 0; j < G[v].size(); j++){
            edge e = G[v][j];
            if(dist[e.to] > dist[v] + e.cost){
                dist[e.to] = dist[v] + e.cost;
                que.push(P(dist[e.to], e.to));
            }
        }
    }
    // from node 1 - N
    printf("the shortest path is : %d\n", dist[N]);

}

int main()
{
    read();
    solve();	
    return 0;
}