洛谷4899 [IOI2018] werewolf 狼人 （克鲁斯卡尔重构树+主席树）

（最近开始疯狂拖欠博客…怎么破啊）
qwq
不会用树状数组二维数点可怎么整
qwq
果然菜哭了

首先，我们来看这个题，首先对于题目中的阈值，貌似不太好处理，但是看到了只能经过大于等于/小于多少权值的点的字眼，不难相当克鲁斯卡尔重构树。

可是，我们应该怎么转点权为边权呢。
我们来考虑$L$的限制，首先，由于是只能走大于等于某一个权值的点，那么，我们对于一条边，一定要满足他的两端都大于这个要求，才可以走，也就是说，对于这个限制，我们可以将每个边的权值赋值成两个端点$val$的$min$。然后优化放大的边权，也就是最大克鲁斯卡尔重构树。对于一次询问的$L$的阈值，从$S$直接跳到最靠上的$val[x]>=l$的$x$，子树内部的叶子节点就是能到达的合法节点。

而同样的道理，我们可以对于$R$的阈值限制，把每个边的边权赋值成两个端点的$max$，然后建最小克鲁斯卡尔重构树。询问的时候，同样也是从$T$跳到对应的点。

emmmmmm
那之后应该怎么办呢？
qwq
貌似这只是统计了两个形态分别能到的范围。
那我们现在就是要确定，这两个范围存不存在交
也就是说存不存在能够切换形态的地方，如果存在，那么就能从$S$到$T$。

这是一个二维数点，qwq但是我实在是菜的没边啊。

只有一个在线的常数巨大的办法

我们通过主席树来实现这个过程，对于第一课树，按照$dfs$序的顺序建主席树，每一个点的权值是他在第二颗树的$dfn$（这里只考虑叶子节点，其他的点不新建$root$）

那么问题就转化成了，求一段区间里面有没有权值在$[l,r]$的数，直接用类似线段树的统计方式，算一算区间的权值个数就行。

qwq顺便纪念一下人生第一次因为数组开太大导致$TLE$

其实实际上的话，是因为那么向上跳的过程有点小捞。

完全可以一个$log$，$for$循环从大到小，能跳就跳的处理，qwq但是我比较sb啊

下面给一个卡过常数的代码，要是有不理解的地方，还请见谅。
qwwqq

// luogu-judger-enable-o2
// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<vector>
#include<set>
#include<cstdlib>
#define pb push_back
#define mk make_pair
#define ll long long
#define lson ch[x][0]
#define rson ch[x][1]
using namespace std;
inline int read()
{
   int x=0,f=1;char ch=getchar();
   while (!isdigit(ch)) {if (ch=='-') f=-1;ch=getchar();}
   while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
   return x*f;
}
const int maxn =  6e5+1e2;
const int maxm = 2*maxn;
int n,m,q;
int root[maxn];
int tmp;
struct Edge{
  int u,v,w;
};
struct Node{
   int l,r,val;
};
Edge e[maxn];
int val[maxn];
int fa[maxn];
struct tree{
   int point[maxn],nxt[maxm],to[maxm];
   int cnt,dfn[maxn];
   int tot,deep[maxn];
   int size[maxn];
   int back[maxn];
   int f[maxn][21];
   void addedge(int x,int y)
   {
      nxt[++cnt]=point[x];
      to[cnt]=y;
      point[x]=cnt;
   }
   void dfs(int x,int fa,int dep)
   {
     deep[x]=dep;
     dfn[x]=++tot;
     back[tot]=x;
     size[x]=1;
     for (int i=point[x];i;i=nxt[i])
     {
       int p = to[i];
       if (p==fa) continue;
       f[p][0]=x;
       dfs(p,x,dep+1);
       size[x]+=size[p];
     }
   }
   void init()
   {
     for (int j=1;j<=20;j++)
       for (int i=1;i<=3*n;i++) 
         f[i][j]=f[f[i][j-1]][j-1];
   }
   int go_up(int x,int d)
   {
      for (int i=0;i<=20;i++) 
        if ((1<<i) & d) x=f[x][i];
      return x;   
   }
};
tree a,b;
Node t[maxn*21];
int newnum;
int ymh;
bool cmp(Edge a,Edge b)
{
  return a.w<b.w;
}
bool cmp1(Edge a,Edge b)
{
  return a.w>b.w;
}
int x[maxm],y[maxm];
int find(int x)
{
  if (fa[x]!=x) fa[x]=find(fa[x]);
  return fa[x];
}
void kruskal()
{
   for (int i=1;i<=n*3;i++) fa[i]=i;
   for (int i=1;i<=m;i++) e[i].u=x[i],e[i].v=y[i],e[i].w=min(x[i],y[i]);
   sort(e+1,e+1+m,cmp1);
   for (int i=1;i<=m;i++)
   {
      int f1 = find(e[i].u);
      int f2 = find(e[i].v);
      if (f1==f2) continue;
      ++newnum;
      val[newnum]=e[i].w;
      fa[f1]=newnum;
      fa[f2]=newnum;
      a.addedge(f1,newnum);
      a.addedge(newnum,f1);
      a.addedge(f2,newnum);
      a.addedge(newnum,f2);
   }
}
void kruskal1()
{
  for (int i=1;i<=n*3;i++) fa[i]=i;
  for (int i=1;i<=m;i++) e[i].u=x[i],e[i].v=y[i],e[i].w=max(x[i],y[i]);
  sort(e+1,e+1+m,cmp);
  for (int i=1;i<=m;i++)
  {
    int f1 = find(e[i].u);
    int f2 = find(e[i].v);
    if (f1==f2) continue;
    ++newnum;
    val[newnum]=e[i].w;
    fa[f1]=newnum;
    fa[f2]=newnum;
    b.addedge(f1,newnum);
    b.addedge(newnum,f1);
    b.addedge(f2,newnum);
    b.addedge(newnum,f2);
  }
}
void up(int root)
{
  t[root].val=t[t[root].l].val+t[t[root].r].val;
}
int modify(int pre,int l,int r,int x)
{
  int now = ++tmp;
  if (l==r)
  {
     t[now].val=t[pre].val+1;
     return now;
  }
  int mid = l+r >> 1;
  if (x<=mid)
  {
    t[now].r=t[pre].r;
    t[now].l=modify(t[pre].l,l,mid,x);
  }
  else
  {
    t[now].l=t[pre].l;
    t[now].r=modify(t[pre].r,mid+1,r,x);
  }
  up(now);
  return now;
}
int query(int root1,int root2,int l,int r,int x,int y)
{
  if (x<=l && r<=y) return t[root2].val-t[root1].val;
  int mid = l+r >> 1;
  int ans=0;
  if (x<=mid) ans=ans+query(t[root1].l,t[root2].l,l,mid,x,y);
  if (y>mid) ans=ans+query(t[root1].r,t[root2].r,mid+1,r,x,y);
  return ans; 
}
void solve(int s,int e,int x,int y)
{
   int l=1,r=a.deep[s]-1;
   int scb = s,lyf=e;
   while (l<=r)
   {
     int mid = l+r >> 1;
     int now = a.go_up(s,mid);
     if (val[now]>=x) l=mid+1,scb = now;
     else r=mid-1;
   }
   l=1,r=b.deep[e]-1;
   while (l<=r) 
   {
     int mid = l+r >> 1;
     int now = b.go_up(e,mid);
     if (val[now]<=y) l=mid+1,lyf=now;
     else r=mid-1;
   }
   int k = query(root[a.dfn[scb]-1],root[a.dfn[scb]+a.size[scb]-1],1,ymh,b.dfn[lyf],b.dfn[lyf]+b.size[lyf]-1);
   if (k>0) cout<<1<<"\n" ;
   else cout<<0<<"\n";
}
int main()
{
   n=read(),m=read(),q=read();   
   newnum=n;
   for (int i=1;i<=m;i++)
   {
    x[i]=read()+1;
    y[i]=read()+1;
   }
   kruskal();
   a.dfs(newnum,0,1);
   int now = newnum;
   ymh = newnum;
   a.init();
   kruskal1();
   b.dfs(newnum,0,1);
   b.init();
   for (int i=1;i<=now;i++)
   {
     if (a.back[i]>n) root[i]=root[i-1];
     else
     {
       root[i]=modify(root[i-1],1,ymh,b.dfn[a.back[i]]);
     }
   }
   for (int i=1;i<=q;i++)
   {
       int s=read(),e=read(),l=read(),r=read();
       s++;
       e++;
       l++;
       r++;
       solve(s,e,l,r);
   }
   return 0;
}