洛谷P4768 [NOI2018]归程（可持久化并查集，最短路）

闲话

一个蒟蒻，在网络同步赛上进行了这样的表演——

T2组合计数不会，T3字符串数据结构不会，于是爆肝T1

一开始以为整个地图都有车，然后写了2h+的树套树，终于发现样例过不去

然后写可持久化并查集Debug到13:20过了前4个样例，然后第5个T飞了。

FST？

。。。。。。

FST！

完美收获50分暴力分。

原来是按秩合并那里咕咕了。

从50到100的蜕变，只需一行，你值的拥有。

思路

不会kruscal重构树

容易发现，假设我们确定了水位线，那么就确定了图中有哪些边是连通的。这时候的答案该如何确定呢？因为车可以在一个连通块里随便开，所以同一个连通块里的点的答案都是一样的，为连通块内离\(1\)最近的点到\(1\)的距离。

那当然要首先把单源最短路求出来。SPFA死了？被固定了？（参考生物必修3），还好蒟蒻写的是dijkstra。

因为并查集只能合并，所以我们要按高度从大到小排序依次加边。如果是离线那好办了，把询问也按高度排个序，每在并查集里加一条边就可以完成若干个询问。

那强制在线？当然要把合并过程中的每个版本都存起来啦！用可持久化并查集（蒟蒻之前写过一篇blog）

当然，高度要离散化，为了让每个询问通过二分找到对应版本。

复杂度\(O(n\log m+(m+q)\log^2n)\)，当然这里写的有点丑，在倒序合并的过程中可以在外面放并查集，祖先到并查集里跳，比在可持久化并查集里跳快多了，复杂度\(O(n\log m+m\log n+q\log^2n)\)。

#include
#include
#include
#include
#define UI unsigned int
#define RG register
#define I inline
#define R RG UI
#define G c=getchar()
using namespace std;
const int N=2e5+9,M=8e5+9,S=2e7;
struct NODE{
    UI u,d;
    I bool operator<(RG NODE x)const{return d>x.d;}
};//堆优化dijkstra的节点
struct EDGE{
    UI u,v,a;
    I bool operator<(RG EDGE x)const{return aq;
UI n,L,p,he[N],ne[M],to[M],l[M],a[M],b[M],d[N],rt[M],lc[S],rc[S],f[S],mn[S],dep[S];
bool vis[N];
I UI in(){
    RG char G;
    while(c<'-')G;
    R x=c&15;G;
    while(c>'-')x*=10,x+=c&15,G;
    return x;
}
void build(R&u,R l,R r){//建初始并查集
    u=++p;
    if(l==r){mn[u]=d[f[u]=l];return;}
    R m=(l+r)>>1;
    build(lc[u],l,m);
    build(rc[u],m+1,r);
}
UI ins(R*u,R v,R t){//插入
    R l=1,r=n,m;
    while(l!=r){
        *u=++p;m=(l+r)>>1;
        if(t<=m)r=m,rc[*u]=rc[v],u=lc+*u,v=lc[v];
        else  l=m+1,lc[*u]=lc[v],u=rc+*u,v=rc[v];
    }
    return *u=++p;
}
UI getf(R rt,R t){//跳祖先
    R u,l,r,m;
    while(1){
        u=rt;l=1;r=n;
        while(l!=r){
            m=(l+r)>>1;
            if(t<=m)r=m,u=lc[u];
            else  l=m+1,u=rc[u];
        }
        if(t==f[u])break;
        t=f[u];
    }
    return u;
}
int main(){
    freopen("return.in","r",stdin);
    freopen("return.out","w",stdout);
    R T=in(),m,i,j,u,v,w;
    while(T--){
        p=0;n=in();m=in();//时刻注意清空变量！
        for(i=1;i<=m;++i){
            u=in();v=in();
            ne[++p]=he[u];to[he[u]=p]=v;
            ne[++p]=he[v];to[he[v]=p]=u;
            l[p]=l[p-1]=in();
            e[i]=(EDGE){u,v,a[p]=a[p-1]=in()};
        }
        memset(d,-1,(n+1)<<2);//dijkstra开始
        p=d[1]=0;q.push((NODE){1,0});
        while(!q.empty()){
            RG NODE cur=q.top();q.pop();
            if(vis[u=cur.u])continue;
            vis[u]=1;
            for(i=he[u];i;i=ne[i])
                if(d[to[i]]>d[u]+l[i])
                    q.push((NODE){to[i],d[to[i]]=d[u]+l[i]});
        }
        R q=in(),k=in(),s=in(),lans=0;
        sort(e+1,e+m+1);
        for(i=1;i<=m;++i)b[i]=e[i].a;
        b[m+1]=s+1;L=unique(b+1,b+m+2)-b-1;//离散化，注意加入s+1
        build(rt[L],1,n);
        for(i=L-1,j=m;i;--i){
            rt[i]=rt[i+1];
            for(;j&&e[j].a==b[i];--j){
                if((u=getf(rt[i],e[j].u))==(v=getf(rt[i],e[j].v)))continue;//可优化的地方
                if(dep[u]>dep[v])swap(u,v);//按秩合并
                f[ins(&rt[i],rt[i],f[u])]=f[v];
                w=ins(&rt[i],rt[i],f[v]);
                f[w]=f[v];mn[w]=min(mn[u],mn[v]);//因为按秩合并所以min必须要记
                dep[w]=dep[v]+(dep[u]==dep[v]);//50分就是因为这一行！
            }
        }
        while(q--){
            v=(in()+k*lans-1)%n+1;u=(in()+k*lans)%(s+1);
            printf("%u\n",lans=mn[getf(rt[upper_bound(b+1,b+L+1,u)-b],v)]);
        }//谨慎选择lower_bound和upper_bound
        memset(vis,0,n+1);
        memset(he,0,(n+1)<<2);
        memset(rt,0,(L+1)<<2);
        memset(lc,0,(p+1)<<2);
        memset(rc,0,(p+1)<<2);
        memset(f,0,(p+1)<<2);
        memset(mn,0,(p+1)<<2);
        memset(dep,0,(p+1)<<2);//该清空的都要清空
    }
    return 0;
}

转载于:https://www.cnblogs.com/flashhu/p/9332935.html