HDU 2544 最短路(模板题)

求1到N的最短路径，模板题，以1为源点，用dijkstra算法（可以用优先级队列优化）

#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdio.h>
#include <string>
#include <vector>
#include <queue>

using namespace std;
const int maxn=0x3f3f3f3f;

int road[][];//road[i][j]表示i与j的距离(这里指进过该条路的时间)
int dis[];//dis[i]表示i点到源点1的最短路径大小
int vis[];//vis[i]=1表示节点i已经求过到源点的单源最短路径
vector<int> link[];//link[i]表示i与哪些点连接
int n,m;
int a,b,c;

struct Node{
    int u,dis;

    bool operator<(const Node tmp) const{
        return dis>tmp.dis;  //优先级序列默认的是最先取出的是“最大的”。
    }
      //如果按从小到大排，则优先级队列取最大的。
    //如果从大到小排，则优先级队列取最小的。
};

void dijkstra() {
    priority_queue<Node> q;
    Node tmp,a;
    memset(dis,maxn,sizeof(dis));
    memset(vis,,sizeof(vis));
    dis[]=;
    a.dis=;
    a.u=;
    q.push(a);
    while(!q.empty()) {
        tmp=q.top();
        q.pop();
        int idx=tmp.u;
        vis[idx]=;
        for(int k=; k<link[idx].size(); k++) {
            int v=link[idx][k];
            if(v!=idx && !vis[v]) {
                if(dis[idx]+road[idx][v]<dis[v]) {
                    dis[v]=dis[idx]+road[idx][v];
                    a.dis=dis[v];
                    a.u=v;
                    q.push(a);
                }
            }
        }
    }

}
int main() {
    while(scanf("%d%d",&n,&m)!=EOF) {
        if(n== && m==) {
            break;
        }
        U.clear();
        memset(road,,sizeof(road));
        for(int i=; i<=n; i++)
            link[i].clear();
        for(int i=; i<m; i++) {
            scanf("%d%d%d",&a,&b,&c);
            road[a][b]=c;
            road[b][a]=c;
            link[a].push_back(b);
            link[b].push_back(a);
        }
        dijkstra();
        printf("%d\n",dis[n]);

    }
    return ;
}