NOI 2018 归程 (Kruskal重构树)

题目大意：太长了，略

Kruskal重构树，很神奇的一个算法吧

如果两个并查集被某种条件合并，那么这个条件作为一个新的节点连接两个并查集

那么在接下来的提问中，如果某个点合法，它的所有子节点也都合法，即子节点的限制少于父节点

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#define inf 0x3f3f3f3f
#define ll long long 
#define il inline
#define N 400100
#define M 800100
using namespace std;
//re
int T,cte,ctb,n,m,tot;
int head[N],hbt[M],fa[M],ff[M][21],dis[N],use[N],mi[M],hei[M];
struct EDGE{int to,nxt,val;}edge[M];
struct Krs{int x,y,alt;}krs[N];
struct BT{int to,nxt;}bt[M*2];
struct node{int id,dis;};
int cmpk(Krs s1,Krs s2){return s1.alt>s2.alt;}
il node ins(int x1,int x2){node kk;kk.id=x1,kk.dis=x2;return kk;}
bool operator<(const node &s1,const node &s2){return s1.dis>s2.dis;}
int find_fa(int x){
    int fx=fa[x],pre;while(fx!=fa[fx])fx=fa[fx];
    while(fa[x]!=fx){pre=fa[x],fa[x]=fx,x=pre;}
    return fx;
}
int gc(){
    int rett=0,fh=1;char p=getchar();
    while(p<'0'||p>'9') {if(fh=='-')fh=-1;p=getchar();}
    while(p>='0'&&p<='9') {rett=(rett<<3)+(rett<<1)+p-'0';p=getchar();}
    return rett*fh;
}
void clr()
{
    cte=ctb=tot=0;
    memset(fa,0,sizeof(fa));memset(ff,0,sizeof(ff));
    memset(krs,0,sizeof(krs));memset(bt,0,sizeof(bt));
    memset(mi,0x3f,sizeof(mi));memset(edge,0,sizeof(edge));
    memset(head,-1,sizeof(head));memset(hbt,-1,sizeof(hbt));
}
void abt(int u,int v){
    ctb++;bt[ctb].to=v;
    bt[ctb].nxt=hbt[u],hbt[u]=ctb;
}
void ae(int u,int v,int w){
    cte++;edge[cte].to=v,edge[cte].val=w;
    edge[cte].nxt=head[u],head[u]=cte;
}
void dfs_bt(int x)
{
    mi[x]=dis[x];
    for(int j=hbt[x];j!=-1;j=bt[j].nxt){
        int v=bt[j].to;
        if(v==ff[x][1]) continue;
        ff[v][0]=v,ff[v][1]=x;
        dfs_bt(v);
        mi[x]=min(mi[x],min(mi[v],dis[v]));
    }
}
void get_multip(){
    for(int j=2;j<=19;j++)
        for(int i=1;i<=tot;i++)
            ff[i][j] = ff[ ff[i][j-1] ][j-1];
}
int multi(int x,int p){
    for(int j=19;j>=0;j--){
        if(hei[ff[x][j]]>p) x=ff[x][j];
    }return x;
}
void dijkstra()
{
    priority_queue<node>que;
    memset(dis,0x3f,sizeof(dis));
    memset(use,0,sizeof(use));
    dis[1]=0,que.push(ins(1,0));
    while(!que.empty()){
        node ss=que.top();que.pop();
        if(use[ss.id]) continue;
        use[ss.id]=1;int x=ss.id;
        for(int j=head[x];j!=-1;j=edge[j].nxt){
            int v=edge[j].to;
            if(dis[v]>dis[x]+edge[j].val){
                dis[v]=dis[x]+edge[j].val;
                if(!use[v]) que.push(ins(v,dis[v]));
            }
        }
    }
}
void Kruskal()
{
    int fx,fy,sum=0;tot=n;
    for(int i=1;i<=2*n;i++) fa[i]=i;
    sort(krs+1,krs+m+1,cmpk);
    for(int i=1;i<=m;i++){
        fx=find_fa(krs[i].x),fy=find_fa(krs[i].y);
        if(fx==fy) continue;
        abt(++tot,fx),abt(tot,fy);
        hei[tot]=krs[i].alt,sum++;
        fa[fx]=tot,fa[fy]=tot;
        if(sum==n-1) break;
    }hei[0]=-1;
    dfs_bt(tot);
    get_multip();
}
int solve(int x,int p)
{
    int fx=multi(x,p);
    return mi[fx];
}

int main()
{
    //freopen("data.in","r",stdin);
    scanf("%d",&T);
    while(T--)
    {
    
    n=gc(),m=gc();clr();
    int x,y,w,z,lst=0;
    for(int i=1;i<=m;i++)
    {
        x=gc(),y=gc(),w=gc(),z=gc();
        ae(x,y,w),ae(y,x,w);
        krs[i].x=x,krs[i].y=y,krs[i].alt=z;
    }
    dijkstra();
    Kruskal();
    int q,k,s;
    q=gc(),k=gc(),s=gc();
    for(int i=1;i<=q;i++)
    {
        x=gc(),w=gc();
        x=(x+k*lst-1)%n+1;
        w=(w+k*lst)%(s+1);
        lst=solve(x,w);
        printf("%d\n",lst);
    }
    
    }
    return 0;
}