hdu2066 最短路 dijkstra

  建立超级源点和超级汇点，家是超级源点s=0，超级汇点t=所有城市最大值+1，超级源点s到相连的城市的边权=想去的城市到超级汇点t的边权=0。只需要求出超级源点到超级汇点的最短路即可。用邻接矩阵的dijkstar1()耗时57ms，用了优先队列+邻接表的dijkstra2()耗时0ms，优化还是很明显的。

#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<string>
#include<map>
#include<set>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<sstream>
#define LL long long
#define OJ_DEBUG 0
#define READ_FILE 1
using namespace std;
const int NN_MAX = 1010;
const int MM_MAX = NN_MAX*NN_MAX;
const int INF = 0x3f3f3f3f;
struct Edge{
    int from,to,dis;
    Edge(int a1=0,int a2=0,int a3=0):from(a1),to(a2),dis(a3){};
    bool operator < (const Edge& ohe) const {return dis > ohe.dis;}
};
/**********************************************************/
int n,m,s,t,lenEdge;
int d[NN_MAX],paths[NN_MAX][NN_MAX];
bool vis[NN_MAX];
vector<Edge>theEdge;
vector<int>G[NN_MAX];
/**********************************************************/
int min_2 (int x,int y) {return x<y?x:y;}
int max_2 (int x,int y) {return x>y?x:y;}
void dijkstra1();
void dijkstra2();
/**********************************************************/
int main()
{
    if (READ_FILE) freopen ("in.txt","r",stdin);
    int tt,ss,dd;
    while(scanf("%d %d %d",&tt,&ss,&dd)!=EOF)
    {
        //memset(paths,0x3f,sizeof(paths));
        //for(int i=0;i<NN_MAX;i++) paths[i][i]=0;
        theEdge.clear(); lenEdge=0;
        for(int i=0;i<NN_MAX;i++) G[i].clear();
        t=0,s=0;
        int a1,a2,a3;
        for(int i=0;i<tt;i++){
            scanf("%d %d %d",&a1,&a2,&a3);
            t=(t<a1?a1:t); t=(t<a2?a2:t);
            //if(paths[a1][a2]>a3)
                //paths[a1][a2]=paths[a2][a1]=a3;
            theEdge.push_back(Edge(a1,a2,a3)); G[a1].push_back(lenEdge++);
            theEdge.push_back(Edge(a2,a1,a3)); G[a2].push_back(lenEdge++);
        }
        ++t;
        for(int i=0;i<ss;i++){
            scanf("%d",&a1);
            //paths[0][a1]=0;
            theEdge.push_back(Edge(0,a1,0)); G[0].push_back(lenEdge++);
        }
        for(int i=0;i<dd;i++){
            scanf("%d",&a1);
            //paths[a1][t]=0;
            theEdge.push_back(Edge(a1,t,0)); G[a1].push_back(lenEdge++);
        }
        //dijkstra1();
        dijkstra2();
        printf("%d\n",d[t]);
    }
    return 0;
}
void dijkstra1()
{
    for(int i=0;i<=t;i++) d[i]=(i==s?0:INF);
    memset(vis,0,sizeof(vis));
    for(int i=0;i<=t;i++){
        int x,mm=INF;
        for(int i=0;i<=t;i++)
            if(!vis[i] && d[i]<mm)
                mm=d[x=i];
        vis[x]=1;
        for(int i=0;i<=t;i++){
            if(!vis[i] && d[i]>d[x]+paths[x][i])
                d[i]=d[x]+paths[x][i];
        }
    }
}
struct HeapNode {
    int u,d;
    HeapNode(int a1=0, int a2=0):u(a1),d(a2){};
    bool operator < (const HeapNode& rhs) const {return d>rhs.d;}
};
void dijkstra2()
{
    for(int i=0;i<=t;i++) d[i]=(i==s?0:INF);
    memset(vis,0,sizeof(vis));
    priority_queue<HeapNode> pq;
    pq.push(HeapNode(s,0));
    while(!pq.empty())
    {
        HeapNode x = pq.top(); pq.pop();
        if(vis[x.u]) continue;
        vis[x.u]=1;
        for(int i=0;i<G[x.u].size();i++){
            Edge& e = theEdge[G[x.u][i]];
            if(!vis[e.to] && d[e.to]>d[x.u]+e.dis){
                d[e.to]=d[x.u]+e.dis;
                pq.push(HeapNode(e.to,d[e.to]));
            }
        }
    }
}