汕头市赛srm8 C-3

n<=100000个点m<=300000条边有权无向联通图，给出K<=10000个特殊点求K个点中任意两点最短路的最小值。

方法一：K小，随便搞。先构造最短路树，在最短路树上Dijkstra，遇到第一个特殊点就返回。代码如下：

如下个头。首先时间复杂度显然超了，其次建树时要考虑重边，比较难搞。

方法二：多源最短路。

插播：多源最短路方法：把每个源加进初始队列即可。

（1）利用多源最短路求出每个特殊点到其它点的最短路和次短路，利用两个的和来更新。一位大神在比赛中用该方法A过。

（2）直接求每个特殊点到其它点的最短路，把Dijkstra中的vis数组去掉，就是凡是松弛过的点都扔进优先队列里，然后，在松弛前，如果该点已经有最短路了，（我认为）现在访问的这条路径是次短路，直接更新答案。

注意不能用  来自同个特殊点的最短路  更新答案，所以记每个点的最短路来自哪个特殊点。

（3）随机化。把K分成两部分S，T，求S到T的最短路，这样得到正确答案的概率为1/2，多分几次就可以把错误概率降到极低。

代码为方法二（2）。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cstdlib>
 #include<queue>
 //#include<iostream>
 using namespace std;

 int n,m,K;
 #define maxn 100011
 #define maxm 600011
 const int inf=0x7fffffff;
 struct Edge{int to,v,next;};
 struct Graph
 {
     Edge edge[maxm];int le;
     int first[maxn],dis[maxn],id[maxn],start[maxn];bool vis[maxn];
     Graph()
     {
         memset(first,,sizeof(first));
         le=;
     }
     void add_edge(int x,int y,int v)
     {
         Edge &e=edge[le];
         e.to=y;e.v=v;
         e.next=first[x];
         first[x]=le++;
     }
     void insert(int x,int y,int v)
     {
         add_edge(x,y,v);
         add_edge(y,x,v);
     }
     struct heapnode
     {
         int x,v;
         bool operator < (const heapnode &b) const {return v<b.v;}
         bool operator > (const heapnode &b) const {return v>b.v;}
     };
     priority_queue<heapnode,vector<heapnode>,greater<heapnode> > q;
     int ans;
     int dijkstra()
     {
         for (int i=;i<=n;i++) dis[i]=inf;
         memset(id,,sizeof(id));
         for (int i=;i<=K;i++)
         {
             dis[start[i]]=;
             id[start[i]]=start[i];
             q.push((heapnode){start[i],});
         }
         ans=inf;
         while (!q.empty())
         {
             const int now=q.top().x,d=q.top().v;
             q.pop();
             if (d!=dis[now]) continue;
             for (int i=first[now];i;i=edge[i].next)
             {
                 const Edge &e=edge[i];
                 if (dis[e.to]!=inf && id[now]!=id[e.to])
                     ans=min(ans,dis[e.to]+d+e.v);
                 if (dis[e.to]>d+e.v)
                 {
                     dis[e.to]=d+e.v;
                     id[e.to]=id[now];
                     q.push((heapnode){e.to,dis[e.to]});
                 }
             }
         }
         return ans;
     }
 }G;
 int x,y,v;
 int main()
 {
     scanf("%d%d%d",&n,&m,&K);
     for (int i=;i<=K;i++) scanf("%d",&G.start[i]);
     for (int i=;i<=m;i++)
     {
         scanf("%d%d%d",&x,&y,&v);
         G.insert(x,y,v);
     }
     printf("%d\n",G.dijkstra());
     return ;
 }