BZOJ5415:[NOI2018]归程(可持久化并查集,最短路)

Description

Input

Output

Sample Input1

1
4 3
1 2 50 1
2 3 100 2
3 4 50 1
5 0 2
3 0
2 1
4 1
3 1
3 2

Sample Output1

0
50
200
50
150

Sample Input2

1
5 5
1 2 1 2
2 3 1 2
4 3 1 2
5 3 1 2
1 5 2 1
4 1 3
5 1
5 2
2 0
4 0

Sample Output2

0

2

3

1

HINT

Solution

会了可持久化并查集这题可能会被卡的正解就很好写了……

把边按高度大小从大到小加入，用可持久化并查集记下每一个时刻并查集的联通情况，

同时用持久化的$Min[i]$数组记录$i$点所在的连通块内到点$1$的最近距离。查询的时候二分到对应时刻的并查集直接查询就行了。

Code

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<algorithm>
#define N (200009)
using namespace std;

struct Edge{int to,next,len;}edge[N<<2];
struct Sgt{int ls,rs,v;};
struct Line
{
    int u,v,w,h;
    bool operator < (const Line &a) const {return h>a.h;}
}l[N<<1];
struct Node
{
    int num,dis;
    bool operator < (const Node &a) const {return dis>a.dis;}
};
int T,n,m,u,v,w,h,q,k,s,v0,p0,ans;
int dis[N],head[N],num_edge;
bool vis[N];
priority_queue<Node>Q;

struct Chairman_Tree
{
    Sgt a[N*40];
    int sgt_num,b[N],Root[N<<1];
    
    int Build(int l,int r)
    {
        int now=++sgt_num;
        if (l==r) {a[now].v=b[l]; return now;}
        int mid=(l+r)>>1;
        a[now].ls=Build(l,mid);
        a[now].rs=Build(mid+1,r);
        return now;
    }
    int Update(int pre,int l,int r,int x,int v)
    {
        int now=++sgt_num;
        a[now].ls=a[pre].ls;
        a[now].rs=a[pre].rs;
        if (l==r) {a[now].v=v; return now;}
        int mid=(l+r)>>1;
        if (x<=mid) a[now].ls=Update(a[now].ls,l,mid,x,v);
        else a[now].rs=Update(a[now].rs,mid+1,r,x,v);
        return now;
    }
    int Query(int now,int l,int r,int x)
    {
        if (l==r) return a[now].v;
        int mid=(l+r)>>1;
        if (x<=mid) return Query(a[now].ls,l,mid,x);
        else return Query(a[now].rs,mid+1,r,x);
    }
}Fa,Dep,Min;

inline int read()
{
    int x=0; char c=getchar();
    while (c<'0' || c>'9') c=getchar();
    while (c>='0' && c<='9') x=x*10+c-'0', c=getchar();
    return x;
}

void add(int u,int v,int w)
{
    edge[++num_edge].to=v;
    edge[num_edge].next=head[u];
    edge[num_edge].len=w;
    head[u]=num_edge;
}

int Find(int x,int t)
{
    int fa=Fa.Query(Fa.Root[t],1,n,x);
    return x==fa?x:Find(fa,t);
}

void Dijkstra(int s)
{
    memset(dis,0x7f,sizeof(dis));
    memset(vis,0,sizeof(vis));
    dis[s]=0;
    Q.push((Node){s,0});
    while (!Q.empty())
    {
        int x=Q.top().num; Q.pop();
        if (vis[x]) continue; vis[x]=1;
        for (int i=head[x]; i; i=edge[i].next)
            if (!vis[edge[i].to] && dis[x]+edge[i].len<dis[edge[i].to])
            {
                dis[edge[i].to]=dis[x]+edge[i].len;
                Q.push((Node){edge[i].to,dis[edge[i].to]});
            }
    }
}

int main()
{
    T=read();
    while (T--)
    {
        Fa.sgt_num=Dep.sgt_num=Min.sgt_num=0;
        memset(head,0,sizeof(head)); num_edge=0;
        ans=0;
        n=read(); m=read();
        for (int i=1; i<=m; ++i)
        {
            u=read(); v=read(); w=read(); h=read();
            l[i]=(Line){u,v,w,h};
            add(u,v,w); add(v,u,w);
        }
        Dijkstra(1);
        sort(l+1,l+m+1);
        for (int i=1; i<=n; ++i)
            Fa.b[i]=i, Dep.b[i]=1, Min.b[i]=dis[i];
        Fa.Root[0]=Fa.Build(1,n);;
        Dep.Root[0]=Dep.Build(1,n);
        Min.Root[0]=Min.Build(1,n);
        for (int i=1; i<=m; ++i)
        {
            Fa.Root[i]=Fa.Root[i-1];
            Dep.Root[i]=Dep.Root[i-1];
            Min.Root[i]=Min.Root[i-1];
            int fx=Find(l[i].u,i),fy=Find(l[i].v,i);
            if (fx==fy) continue;
            int dfx=Dep.Query(Dep.Root[i],1,n,fx);
            int dfy=Dep.Query(Dep.Root[i],1,n,fy);
            if (dfx>dfy) swap(fx,fy);
            Fa.Root[i]=Fa.Update(Fa.Root[i],1,n,fx,fy);
            int d1=Min.Query(Min.Root[i],1,n,fx);
            int d2=Min.Query(Min.Root[i],1,n,fy);
            Min.Root[i]=Min.Update(Min.Root[i],1,n,fy,min(d1,d2));
            if (dfx==dfy) Dep.Root[i]=Dep.Update(Dep.Root[i],1,n,fy,dfy+1);
        }
        q=read(); k=read(); s=read();
        for (int i=1; i<=q; ++i)
        {
            v0=read(); p0=read();
            v0=(v0+k*ans-1)%n+1;
            p0=(p0+k*ans)%(s+1);
            int L=1,R=m,A=-1;
            while (L<=R)
            {
                int mid=(L+R)>>1;
                if (l[mid].h>p0) A=mid,L=mid+1;
                else R=mid-1;
            }
            if (A==-1)
            {
                printf("%d
",dis[v0]);
                ans=dis[v0]; continue;
            }
            int fx=Find(v0,A);
            ans=Min.Query(Min.Root[A],1,n,fx);
            printf("%d
",ans);
        }
    }
}