汕头市赛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,0,sizeof(first));
        le=2;
    }
    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=1;i<=n;i++) dis[i]=inf;
        memset(id,0,sizeof(id));
        for (int i=1;i<=K;i++)
        {
            dis[start[i]]=0;
            id[start[i]]=start[i];
            q.push((heapnode){start[i],0});
        }
        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=1;i<=K;i++) scanf("%d",&G.start[i]);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&v);
        G.insert(x,y,v);
    }
    printf("%d
",G.dijkstra());
    return 0;
}