NOI2018 D1T1 題解

傳送門

首先，預處理每個點到1號點的最短距離$dist$（它等於1號點到每個點的最短距離）。注意：**SPFA死了！**可以用堆優化Dijkstra。

然後我們就把問題轉換成了：從一個點出發，只經過海拔大於某個值的邊，能到達的點中$dist$的最小值。

這個問題怎麼解決呢？有請Kruksal重構樹出場！

什麼是Kruskal重構樹？

有點像並查集，但不同的是在Kruskal求最小生成樹時，每次加邊成功時就建一個新點代表這條邊，這條邊的兩個端點所在集合的根的父親連向這條邊代表的點。如下圖：（借用了別人的圖）

![1.png](1.png

可以看出最小生成樹的Kruskal重構樹有以下性質：

• 二叉樹
• 一個方點代表的邊權$\le$它父親代表的邊權
• 兩個點之間的最小瓶頸路（路徑上邊權最大值最小的路）=它們在Kruskal重構樹上lca的邊權

在本題中，起點可以到達某一個點當且僅當它們的lca的邊權可以行走。

所以可以預處理每個點子樹中的$dist$中最小值，查詢時從起點向上走，走到最上面的可以走的邊代表的點，那個點子樹中的$dist$中最小值就是答案。

走可以改成倍增跳。

//sro zbw ak noi2018 orz o(*￣▽￣*)o
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define clr(a) memset(a,0,sizeof(a))
const int N=500005,N2=N<<1,inf=0x3f3f3f3f;
int n,m,d[N2],mn[N2],vis[N],t,fa[N2][20],uf[N2],lust,Q,k,s;
struct node{int d,n;};
bool operator<(node a,node b){return b.d<a.d;}
priority_queue<node>q;
vector<int>e[N],f[N];
struct edge{int u,v,w,x;}ed[N2];
bool cmp(edge a,edge b){return b.x<a.x;}
void init();
int find(int a){if(uf[a])return uf[a]=find(uf[a]);return a;}
void build(){clr(fa),clr(uf),clr(mn);
    for(int i=1;i<=n;i++)mn[i]=inf;
    for(int i=0,j=n;i<m;i++){
        int v=find(ed[i].v),u=find(ed[i].u);
        if(v==u)continue;
        uf[v]=uf[u]=++j,fa[v][0]=fa[u][0]=j,d[j]=inf,mn[j]=ed[i].x;
    }n=(n<<1)-1;
    for(int i=1;i<=n;i++)
        d[fa[i][0]]=min(d[fa[i][0]],d[i]),mn[fa[i][0]]=min(mn[fa[i][0]],mn[i]);
    for(int k=1;k<20;k++)for(int i=1;i<=n;i++)fa[i][k]=fa[fa[i][k-1]][k-1];
}
void solve(){lust=0;
    scanf("%d%d%d",&Q,&k,&s);
    while(Q--){
        int a,b;scanf("%d%d",&a,&b);
        a=(a+(long long)k*lust-1)%((n+1)>>1)+1,b=(b+(long long)k*lust)%(s+1);
        for(int k=19;~k;k--)if(b<mn[fa[a][k]])a=fa[a][k];
        printf("%d\n",lust=d[a]);
    }
}
int main(){
    scanf("%d",&t);while(t--){
        init();
        build();
        solve();
    }return 0;
}
void init(){clr(vis),clr(d);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)e[i].clear(),f[i].clear();
    for(int i=0;i<m;i++){
        int a,b,c,d;scanf("%d%d%d%d",&a,&b,&c,&d);
        e[a].pb(b),f[a].pb(c);
        e[b].pb(a),f[b].pb(c);
        ed[i]=(edge){a,b,c,d};
    }sort(ed,ed+m,cmp);
    for(int i=2;i<=n;i++)d[i]=inf;
    q.push((node){0,1});
    while(!q.empty()){
        node nod=q.top();q.pop();
        int v=nod.n;
        if(vis[v])continue;vis[v]=1;
        for(int i=0;i<(int)e[v].size();i++){
            int u=e[v][i],w=d[v]+f[v][i];
            if(!vis[u]&&w<d[u])d[u]=w,q.push((node){w,u});
        }
    }
}