洛谷P4768 [NOI2018]归程（克鲁斯卡尔重构树+最短路）

传送门

 

前置技能，克鲁斯卡尔重构树

我们按道路的高度建一个最大生成树，然后建好克鲁斯卡尔重构树

那么我们需要知道一颗子树内到1点距离最近是多少（除此之外到子树内任何一个点都不需要代价）

可以一开始直接跑一个dijkstra（关于SPFA，他死了）

然后一遍树形dp就可以了

//minamoto
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
using namespace std;
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++)
char buf[1<<21],*p1=buf,*p2=buf;
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
inline int read(){
    #define num ch-'0'
    char ch;bool flag=0;int res;
    while(!isdigit(ch=getc()))
    (ch=='-')&&(flag=true);
    for(res=num;isdigit(ch=getc());res=res*10+num);
    (flag)&&(res=-res);
    #undef num
    return res;
}
char sr[1<<21],z[20];int C=-1,Z;
inline void Ot(){fwrite(sr,1,C+1,stdout),C=-1;}
inline void print(int x){
    if(C>1<<20)Ot();if(x<0)sr[++C]=45,x=-x;
    while(z[++Z]=x%10+48,x/=10);
    while(sr[++C]=z[Z],--Z);sr[++C]='\n';
}
const int N=800005;
struct EE{
    int u,v,h;
    EE(){}
    EE(int u,int v,int h):u(u),v(v),h(h){}
    inline bool operator <(const EE &b)const
    {return h>b.h;}
}E[N];
struct node{
    int u,dis;
    node(){}
    node(int u,int dis):u(u),dis(dis){}
    inline bool operator <(const node &b)const
    {return dis>b.dis;}
};
int head[N],Next[N],ver[N],edge[N],tot;
int hc[N],nc[N],vc[N],tc;
int val[N],f[N][25],fa[N],dis[N],vis[N],mn[N],bin[25];
int n,m,ans,k;
priority_queue<node> q;
inline void clear(){
    memset(head,0,sizeof(head)),tot=0;
    memset(hc,0,sizeof(hc)),tc=0;
    memset(mn,0x3f,sizeof(mn));
    memset(f,0,sizeof(f));
}
inline void add(int u,int v,int e){
    ver[++tot]=v,Next[tot]=head[u],head[u]=tot,edge[tot]=e;
}
inline void addc(int u,int v){
    vc[++tc]=v,nc[tc]=hc[u],hc[u]=tc;
}
inline int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
inline void mission(int u){
    for(int i=1;bin[i]<=n;++i)
    f[u][i]=f[f[u][i-1]][i-1];
}
void dijkstra(int s=1){
    memset(vis,0,sizeof(vis));
    memset(dis,0x3f,sizeof(dis));
    q.push(node(s,0)),dis[s]=0;
    while(!q.empty()){
        int u=q.top().u;q.pop();
        if(vis[u]) continue;
        vis[u]=1;
        for(int i=head[u];i;i=Next[i]){
            int v=ver[i];
            if(cmin(dis[v],dis[u]+edge[i])) q.push(node(v,dis[v]));
        }
    }
    memcpy(mn+1,dis+1,sizeof(int)*(n));
}
void dfs(int u){
    mission(u);
    for(int i=hc[u];i;i=nc[i]){
        int v=vc[i];
        dfs(v),cmin(mn[u],mn[v]);
    }
}
inline int query(int u,int x){
    for(int i=19;~i;--i)
    if(f[u][i]&&val[f[u][i]]>x) u=f[u][i];
    return mn[u];
}
void kruskal(){
    int cnt=n;
    for(int i=1;i<=(n<<1);++i) fa[i]=i;
    sort(E+1,E+1+m);
    for(int i=1;i<=m;++i){
        int u=find(E[i].u),v=find(E[i].v);
        if(u!=v){
            val[++cnt]=E[i].h;
            f[u][0]=f[v][0]=cnt,fa[u]=fa[v]=cnt;
            addc(cnt,u),addc(cnt,v);
            if(cnt-n==n-1) break;
        }
    }
    dfs(cnt);
}
int main(){
//    freopen("testdata.in","r",stdin);
    int T=read();
    bin[0]=1;for(int i=1;i<=23;++i) bin[i]=bin[i-1]<<1;
    while(T--){
        n=read(),m=read(),ans=0;
        clear();
        for(int i=1,u,v,e,h;i<=m;++i){
            u=read(),v=read(),e=read(),h=read(),E[i]=EE(u,v,h);
            add(u,v,e),add(v,u,e);
        }
        dijkstra();
        kruskal();
        int q=read(),k=read(),s=read();
        while(q--){
            int u=(k*ans+read()-1)%n+1,v=(k*ans+read())%(s+1);
            print(ans=query(u,v));
        }
    }
    Ot();
    return 0;
}