[Tkey] [IOI 2018] werewolf

注意看，我耗时五个小时 AK 了 IOI

题意

给你一个图，每次给定若干询问 \((s,t,l,r)\)，请你完成下述要求：

• 定义 \(S\) 为到 \(s\) 的最短路径不小于 \(l\) 的点构成的子图，\(T\) 为到 \(t\) 的最短路径不大于 \(r\) 的点构成的子图
• 请你判断 \(S\) 与 \(T\) 是否有交集

解法

当询问次数不大时做法显然，每次对 \(s,t\) 跑 dfs 即可

但是此题询问量大，考虑如何预处理

一 寻找子图

路径最小最大，容易想到使用 Kruskal 生成树. 我们尝试对整张图建立 Kruskal 最小和最大生成树，根据其性质在树上跑 LCA 来 \(\log\) 解决这部分问题.

但是在实际实现的时候会遇到一些问题：我们仍然还需要枚举所有点，因此最坏情况下需要单次 \(n\log n\) 求解，复杂度不够优秀.

现在转化问题：注意到我们求解出来的子图一定是树结构，由 dfs 序的性质，最终这颗子树一定是原树 dfs 序上连续的一段，因此我们将问题抽象成这样：

给定两个序列 \(S,T\)，询问是否存在 \(i\in[l,n]\)，使得存在 \(T_{j}=S_{i},j\in[1,r]\)

其中 \(S\) 是我们建立的 Kruskal 最小生成树的 dfs 序，\(T\) 是建立的 Kruskal 最大生成树的 dfs 序，这样我们就通过两遍 Kruskal+LCA 转化了这个问题

二 求解交集

注意到我们可以建立一个数组 \(f_{i}\) 表示 \(i\) 在 \(S\) 中的位置，这样建立一个映射是为了方便后续操作：我们可以通过调用 \(f_{T_{i}}\) 来查看 \(T_{i}\) 在 \(S\) 中的位置

因此，我们可以进一步转化这个问题：

给定两个序列 \(S,T\)，询问是否存在 \(i\in[1,r]\)，使得 \(f_{T_{i}}\in[l,n]\)

注意到我们现在把问题转化成了一种类似求值域的东西，因此考虑对 \(f_{T_{i}}\) 开可持久化线段树，维护前缀和，每次把 \(r,l-1\) 两颗可持久化线段树传下去作差维护答案，这个问题即可求解.

下面是这一部分，可持久化线段树内的 ask() 函数代码

bool ask(int p,int q,int l,int r,int L,int R){ //存在则返回 true
    if(l>R or L>r) return false;
    if(L<=l and r<=R) return t[q].cnt-t[p].cnt; //满足[1,r]条件后还需要作差
    int mid(l,r);
    return ask(t[q].l,t[p].l,l,mid,L,R) or ask(t[q].r,t[p].r,mid+1,r,L,R);
}

比较简单。

三 整合

那我们刚才弄出来的 Kruskal 生成树显然就是用来找，我们需要的 dfs 序的左右端点（也即哪两颗可持久化线段树需要被传下去）了，这一部分暴力倍增即可。

注意事项

• 在 loj 版里，需要引用 "werewolf.h"
• 求端点的倍增别弄反了，应该是先大再小
• 因为用了 Kruskal 生成树，因此空间需要开到 \(2n\)

代码

#include<bits/stdc++.h>
#include"werewolf.h"
using namespace std;
const int inf=0x7fffffff;
int n,m,q;
struct edge{
    int from,to;
};
edge ed[400001];
int a[400001],b[400001];
int cnt=0;
bool cmp1(const edge &A,const edge &B){
    return max(A.from,A.to)<max(B.from,B.to);
}
bool cmp2(const edge &A,const edge &B){
    return min(A.from,A.to)>min(B.from,B.to);
}
int mp[400001],t[400001],root[400001];
class dsu{
    private:
    int fa[400001];
    public:
    void clear(){
        for(int i=1;i<=2*n;++i){
            fa[i]=i;
        }
    }
    int find(int id){
        if(id==fa[id]) return id;
        fa[id]=find(fa[id]);
        return fa[id];
    }
    void join(int x,int y){ //add x to y (fa[x]=y)
        int fx=find(x),fy=find(y);
        if(fx!=fy){
            fa[fx]=fy;
        }
    }
};
class kruskal{
    public:
    int tot,treecnt;
    int fa[20][400001],w[400001],l[400001],r[400001];
    vector<int>e[400001];
    dsu d;
    void clear(){
        tot=n;
        d.clear();
        memset(l,0x3f,sizeof l);
    }
    void dfs(int now,int type){
        if(now<=n){
            if(type==1){
                a[++treecnt]=now;
            }
            else{
                b[++treecnt]=now;
            }
            l[now]=r[now]=treecnt;
            return;
        }
        for(int i:e[now]){
            if(i==fa[0][now]) continue;
            fa[0][i]=now;
            dfs(i,type);
            l[now]=min(l[now],l[i]);
            r[now]=max(r[now],r[i]);
        }
    }
    void build(int type){
        clear();
        if(type==1){
            sort(ed+1,ed+m+1,cmp1);
        }
        else{
            sort(ed+1,ed+m+1,cmp2);
        }
        for(int i=1;i<=m;++i){
            if(d.find(ed[i].from)!=d.find(ed[i].to)){
                e[++tot].push_back(d.find(ed[i].from));
                e[tot].push_back(d.find(ed[i].to));
                e[d.find(ed[i].from)].push_back(tot);
                e[d.find(ed[i].to)].push_back(tot);
                d.join(ed[i].from,tot);
                d.join(ed[i].to,tot);
                if(type==1){
                    w[tot]=max(ed[i].from,ed[i].to);
                }
                else{
                    w[tot]=min(ed[i].from,ed[i].to);
                }
            }
        }
        if(type==1) w[0]=inf;
        else w[0]=-inf;
        dfs(tot,type);
        for(int j=1;j<=19;++j){
            for(int i=1;i<=tot;++i){
                fa[j][i]=fa[j-1][fa[j-1][i]];
            }
        }
    }
    int get_version(int now,int l,int r){
        for(int i=19;~i;--i){
            if(w[fa[i][now]]>=l and w[fa[i][now]]<=r){
                now=fa[i][now];
            }
        }
        return now;
    }
}t1,t2;
class HIST_Stree{
    public:
    #define mid(l,r) mid=((l)+(r))/2
    int tot=0;
    struct tree{
        int l,r;
        int cnt;
    }t[400001*25];
    int clone(int id){
        t[++tot]=t[id];
        return tot;
    }
    int insert(int id,int l,int r,int pos){
        int q=clone(id);
        if(l==r){
            t[q].cnt++;
            return q;
        }
        int mid(l,r);
        if(pos<=mid){
            t[q].l=insert(t[id].l,l,mid,pos);
        }
        else{
            t[q].r=insert(t[id].r,mid+1,r,pos);
        }
        t[q].cnt=t[t[q].l].cnt+t[t[q].r].cnt;
        return q;
    }
    bool ask(int p,int q,int l,int r,int L,int R){
        if(l>R or L>r) return false;
        if(L<=l and r<=R) return t[q].cnt-t[p].cnt;
        int mid(l,r);
        return ask(t[q].l,t[p].l,l,mid,L,R) or ask(t[q].r,t[p].r,mid+1,r,L,R);
    }
}hist;
vector<int> check_validity(int N, vector<int> X, vector<int> Y, vector<int> U, vector<int> V, vector<int> L, vector<int> R) {
	n=N,m=X.size(),q=U.size();
    vector<int>ans;
    for(int i=1;i<=m;++i){
        ed[i]={X[i-1]+1,Y[i-1]+1};
    }
    t1.build(1);
    t2.build(2);
    for(int i=1;i<=n;++i){
        t[a[i]]=i;
    }
    for(int i=1;i<=n;++i){
        mp[i]=t[b[i]];
    }
    for(int i=1;i<=n;++i){
        root[i]=hist.insert(root[i-1],1,n,mp[i]);
    }
    for(int i=1;i<=q;++i){
        int s=U[i-1]+1,t=V[i-1]+1;
        int l=L[i-1]+1,r=R[i-1]+1;
        swap(s,t);
        s=t1.get_version(s,1,r);
        t=t2.get_version(t,l,n);
        if(hist.ask(root[t2.r[t]],root[t2.l[t]-1],1,n,t1.l[s],t1.r[s])){
            ans.push_back(1);
        }
        else{
            ans.push_back(0);
        }
    }
    return ans;
}
// vector<int> X,Y,U,V,L,R;
// int main(){
//     cin>>n>>m>>q;
//     for(int i=1;i<=m;++i){
//         int a,b;
//         cin>>a>>b;
//         X.push_back(a);Y.push_back(b);
//     }
//     for(int i=1;i<=q;++i){
//         int s,e,l,r;
//         cin>>s>>e>>l>>r;
//         U.push_back(s);
//         V.push_back(e);
//         L.push_back(l);
//         R.push_back(r);
//     }
//     vector<int> ans=check_validity(n,X,Y,U,V,L,R);
//     for(int i:ans){
//         cout<<i<<endl;
//     }
// }