hdu2680 Choose the best route 最短路（多源转单源）

　　此题中起点有1000个，边有20000条。用链式前向星建图，再枚举起点用SPFA的话，超时了。（按理说，两千万的复杂度应该没超吧。不过一般说计算机计算速度 1~10 千万次/秒。也许拿最烂的计算机来卡时间）

　　有一个技巧，加一个超级源点。也就是加一个点，使得该点连通所有的起点，并且边的权值为0。这个技巧应用蛮多的。网络流、最小树形图都有题目这样做。

　

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 using namespace std;
 const int N = , M=;
 const int INF = 0x3f3f3f3f;
 struct node
 {
     int to, w, next;
 };
 node edge[M];
 int head[N], dist[N], outq[N];
 bool vis[N];
 int tot;
 bool SPFA(int s, int n )
 {
     int i,k;
     for(i=;i<=n;i++) dist[i]=INF;
     memset(vis,,sizeof(vis));
     memset(outq,,sizeof(outq));
     queue<int > q;
     while(!q.empty()) q.pop();
     vis[s]=;
     dist[s]=;
     q.push(s);
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         vis[u]=;
         outq[u]++;
         if(outq[u]>n) return  ;
         k=head[u];
         while(k>=)
         {
             if(dist[edge[k].to]-edge[k].w>dist[u])
             {
                 dist[edge[k].to]=dist[u]+edge[k].w;
                 if(!vis[edge[k].to])
                 {
                     vis[edge[k].to]=;
                     q.push(edge[k].to);
                 }
             }
             k=edge[k].next;
         }
     }
     return ;
 }
 void addedge(int i,int j,int w)
 {
     edge[tot].to=j;
     edge[tot].w=w;
     edge[tot].next=head[i];
     head[i]=tot++;
 }
 void init()
 {
     tot=;
     memset(head,-,sizeof(head));
 }
 int main()
 {
     //freopen("test.txt","r",stdin);
     int i,j,k,n,m,t,s;
     while(scanf("%d%d%d",&n,&m,&t)!=EOF)
     {
         init();
         while(m--)
         {
             scanf("%d%d%d",&i,&j,&k);
             addedge(i,j,k);
         }
         scanf("%d",&k);
         for(i=;i<k;i++)
         {
             scanf("%d",&s);
             addedge(n+,s,);
         }
         SPFA(n+,n+);
         if(dist[t]==INF) printf("-1\n");
         else printf("%d\n",dist[t]);
     }
     return ;
 }