uoj407 【IOI2018】狼人

link

题意：

给一张n个点m条边的无向图，有q个询问，每次询问给出s,t,l,r，问你能否从s走到t，并且初始为人形，结束时必须为狼形，你是人形的时候必须避开$[1,l)$的节点，狼形的时候必须避开$(r,n]$的节点，你只能在$[L,R]$的节点处变身？

$n,q\leq  2\times 10^5,m\leq 4\times 10^5.$

题解：

get技能——Kruskal重构树

重构树是一个类似堆的结构，节点u比它的所有儿子v的权都要来的小/大（在这题中都有用到），可以用并查集建树。

考虑题中s~t有合法路径相当于，s只经过L~N的点能到达的点集和t只经过1~R的点能到达的点集有交。

那么考虑建出Kruskal最大/小重构树，那么两个点集分别对应到两棵树上的一个子树，求出dfs序转化成两个区间。

把每个点对应到一个坐标$[dfn1,dfn2]$（在两棵树中dfs序上的位置），原问题等价于询问一个矩形$x∈[l1,r1],y∈[l2,r2]$中是否有点，离线树状数组即可。

复杂度$\mathcal{O}(n\log n)$。

code:

 #include<bits/stdc++.h>
 #include "werewolf.h"
 #define rep(i,x,y) for (int i=(x);i<=(y);i++)
 #define per(i,x,y) for (int i=(x);i>=(y);i--)
 #define ll long long
 #define VI vector<int>
 using namespace std;
 const int N=2e5+;
 int u,v,n,m,Q,top,bit[N]; VI ans,G[N];
 struct node{
     int x,y,ty,op,id;
     node(){}
     node(int x,int y,int ty,int op,int id):x(x),y(y),ty(ty),op(op),id(id){}
 }q[N*];
 bool cmp(node x,node y){ return x.x<y.x||x.x==y.x&&x.ty<y.ty; }
 struct Kruskal_rebuild_tree{
     int cnt,head[N],fa[N],clk,in[N],out[N],f[N][];
     struct edge{ int to,nxt; }e[N];
     void adde(int x,int y){ e[++cnt].to=y; e[cnt].nxt=head[x]; head[x]=cnt; }
     int getfa(int x){ return x==fa[x]?x:fa[x]=getfa(fa[x]); }
     void dfs(int u,int ty){
         rep (i,,) f[u][i]=f[f[u][i-]][i-];
         in[u]=++clk;
         for (int i=head[u];i;i=e[i].nxt) f[e[i].to][]=u,dfs(e[i].to,ty);
         out[u]=clk;
     }
     void build(int ty){
         cnt=; rep (x,,n) fa[x]=x,head[x]=;
         if (!ty){
             per (x,n,)
                 for (auto y:G[x])
                     if (x<y&&getfa(x)!=(y=getfa(y))) adde(x,y),fa[y]=x;
         } else{
             rep (x,,n)
                 for (auto y:G[x])
                     if (x>y&&getfa(x)!=(y=getfa(y))) adde(x,y),fa[y]=x;
         }
         rep (i,,n) if (getfa(i)==i) dfs(i,ty);
     }
     int qry(int x,int lim,int ty){
         per (i,,)
             if (f[x][i]&&(!ty?f[x][i]>=lim:f[x][i]<=lim)) x=f[x][i];
         return x;
     }
 }T[];
 void add(int x){ for (;x<=n;x+=x&-x) bit[x]++; }
 int qry(int x){ int s=; for (;x;x-=x&-x) s+=bit[x]; return s; }
 VI check_validity(int _n,VI x,VI y,VI s,VI t,VI l,VI r){
     n=_n; m=x.size(),Q=s.size();
     rep (i,,m-) G[++x[i]].push_back(++y[i]),G[y[i]].push_back(x[i]);
     T[].build(); T[].build();
     rep (i,,n) q[++top]=node(T[].in[i],T[].in[i],,,);
     rep (i,,Q-){
         ++s[i],++t[i],++l[i],++r[i];
         int u=T[].qry(s[i],l[i],),v=T[].qry(t[i],r[i],);
         int l1=T[].in[u],r1=T[].out[u],l2=T[].in[v],r2=T[].out[v];
         q[++top]=node(r1,r2,,,i);
         if (l1>) q[++top]=node(l1-,r2,,-,i);
         if (l2>) q[++top]=node(r1,l2-,,-,i);
         if (l1>&&l2>) q[++top]=node(l1-,l2-,,,i);
     }
     sort(q+,q++top,cmp); ans.resize(Q);
     rep (i,,top)
         if (!q[i].ty) add(q[i].y); else ans[q[i].id]+=qry(q[i].y)*q[i].op;
     rep (i,,Q-) ans[i]=!!ans[i];
     return ans;
 }