【51 Nod 1743】 雪之国度

Description

雪之国度有N座城市，依次编号为1到N，又有M条道路连接了其中的城市，每一条道路都连接了不同的2个城市，任何两座不同的城市之间可能不止一条道路。雪之女王赋予了每一座城市不同的能量，其中第i座城市被赋予的能量为Wi。
如果城市u和v之间有一条道路，那么只要此刻雪之女王的能量不小于|Wu-Wv|，这条道路就是安全的。如果城市u和v之间存在两条没有重复道路的安全路径（其中每一段道路都是安全的），则认为这两座城市之间有着良好的贸易关系。
最近，雪之女王因为情感问题，她的能量产生巨大的波动。为了维持雪之国度的经济贸易，她希望你能帮忙对Q对城市进行调查。对于第j对城市uj和vj，她希望知道在保证这两座城市之间有着良好贸易关系的前提之下，自己最少需要保持多少的能量。

Solution

一开始还以为是二分，结果……
首先，要求最大边最小，那么明显是最小生成树。
然后，对原图造一个最小生成树之后，那么两两点之间的一条路径就已经知道了。
现在把原来不是最小生成树的边，从小到大逐个插入，那么当形成一个环之后，那么这个环上的所有点对的值，肯定都是答案。那么现在的问题就是，这两个点对第一次在环上的时候是什么时候。
那么有一个很经典的套路，首先维护环肯定是并查集，那么要求最早的一次合并那么明显是按秩合并。
那么两个点在按秩合并的并查集中的lca，他们之间的最大值就是答案。

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fod(i,a,b) for(i=a;i>=b;i--)
#define rep(i,a) for(i=first[a];i;i=next[i])
using namespace std;
const int maxn=500007;
int i,j,k,l,t,n,m,ans,q,x,y,u,v,p,tot;
int w[maxn],fa[maxn],f[maxn],c1[maxn],c2[maxn];
int first[maxn],last[maxn],next[maxn],chang[maxn],num;
int g[maxn][21],pp[maxn][21];
int o,deep[maxn];
bool az[maxn],cz[maxn];
int ba[maxn];
bool bz[maxn];
struct node{
    int a,b,c;
}a[maxn],b[maxn];
bool cmp(node x,node y){return x.c<y.c;}
void add(int x,int y,int z){
    last[++num]=y,next[num]=first[x],first[x]=num,chang[num]=z;
    last[++num]=x,next[num]=first[y],first[y]=num,chang[num]=z;
}
int agf(int x){return (!fa[x])?x:agf(fa[x]);}
int bgf(int x){return (!f[x])?x:bgf(f[x]);}
void merge1(int x,int y,int xx,int yy,int z){
    if(c1[x]<c1[y])swap(x,y),swap(xx,yy);
    add(xx,yy,z);
    c1[x]++,fa[y]=x;
}
int getlca(int x,int y){
    int f1=bgf(x),f2=bgf(y);
    while(f1!=f2){
        if(deep[f1]<deep[f2])swap(f1,f2),swap(x,y);
        x=fa[f1];
        f1=bgf(x);
    }
    return f1;
}
void merge2(int x,int y,int z){
    if(c2[x]<c2[y])swap(x,y);
    c2[x]++;
    int ber=getlca(x,y);
    int f1=bgf(x),f2=bgf(y);
    while(f1!=f2){
        if(deep[f1]<deep[f2])swap(f1,f2),swap(x,y);
        add(ber,f1,z);
        f[f1]=ber,ba[f1]=z,x=fa[f1];
        f1=bgf(x);
    }
}
void dfs(int x,int y){
    int i;deep[x]=deep[y]+1;fa[x]=y;
    rep(i,x)if(last[i]!=y)dfs(last[i],x);
}
int lca(int x,int y){
    int u=0,i;if(deep[x]<deep[y])swap(x,y);
    fod(i,20,0)if(deep[g[x][i]]>deep[y])u=max(u,pp[x][i]),x=g[x][i];
    if(deep[x]!=deep[y])u=max(u,pp[x][0]),x=g[x][0];
    fod(i,20,0)if(g[x][i]!=g[y][i])u=max(u,pp[x][i]),u=max(u,pp[y][i]),x=g[x][i],y=g[y][i];
    if(x!=y)u=max(pp[x][0],u),u=max(u,pp[y][0]);
    return u;
}
int main(){
//  freopen("fan.in","r",stdin);
//  freopen("fan.out","w",stdout);
    freopen("city.in","r",stdin);
    freopen("city.out","w",stdout);
    scanf("%d%d%d",&n,&m,&q);
    fo(i,1,n)scanf("%d",&w[i]),c1[i]=c2[i]=1;
    fo(i,1,m){
        scanf("%d%d",&a[i].a,&a[i].b);
        a[i].c=abs(w[a[i].a]-w[a[i].b]);
    }
    sort(a+1,a+1+m,cmp);
    fo(i,1,m){
        x=a[i].a,y=a[i].b;
        u=agf(x),v=agf(y);
        if(u!=v)merge1(u,v,a[i].a,a[i].b,a[i].c),p++,bz[i]=1;    
        if(p==n-1)break;
    }
    memset(fa,0,sizeof(fa));
    dfs(1,0);
    memset(first,0,sizeof(first));num=0;p=0;
    fo(i,1,m){
        if(bz[i])continue;
        u=bgf(a[i].a),v=bgf(a[i].b);
        if(u!=v)merge2(u,v,a[i].c),p++;
    }
    memset(deep,0,sizeof(deep));
    fo(i,1,n)if(!deep[bgf(i)])dfs(bgf(i),0);
    fo(i,1,n)g[i][0]=f[i],pp[i][0]=ba[i];
    fo(j,1,20){
        fo(i,1,n)g[i][j]=g[g[i][j-1]][j-1],pp[i][j]=max(pp[i][j-1],pp[g[i][j-1]][j-1]);
    }
    while(q--){
        scanf("%d%d",&x,&y);
        u=bgf(x),v=bgf(y);
        if(u!=v){
            printf("infinitely\n");
            continue;
        }
        o=lca(x,y);
        printf("%d\n",o);
    }
}