2020 Multi-University Training Contest 8---- HDU--6858、Discovery of Cycles（LCT）

题目链接

题面：

题意：
给定一张图，给定 $m$ 条边，有重边但没有自环。
问区间 $[l,r]$ 的边所构成的图中有没有环。这里的环包括二元环。

题解：
我们对于任意一条边 $l_i$，求出这条边往右至少到哪一条边才能让图中存在环，记这条边为 $r_i$。如果当前边往右不能再形成一个环，我们就记这条边的能形成环的右端点为 $m+1$

我们可以发现 $r_i$ 是不减的。于是我们可以来维护左端点和右端点。对于当前左端点的边来说，如果加上当前右端点这条边还不会形成环，就加上右端点这条边，右端点继续往右扩展。
对于当前左端点的边来说，如果加上当前右端点这条边会形成环，我们就记录 $rr[l_i]=r_i$。且将左端点这条边从图中删去，往右扩展左端点。

查询：
因为我们的 $rr[i]$是不减的，对于任意的一组查询 $(x,y)$，如果 $rr[x]<=y$ 那么就说明区间 $[x,y]$ 中的边可以形成环，否则则不可以形成环。

用 lct 来维护增边删边。
时间复杂度 $O(nlogn)$

代码：

#pragma GCC optimize("Ofast","inline","-ffast-math")
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
#include<queue>
#include<bitset>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<set>
#define ui unsigned int
#define ll long long
#define llu unsigned ll
//#define ld long double
#define pr make_pair
#define pb push_back
#define lc (cnt<<1)
#define rc (cnt<<1|1)
#define len(x)  (t[(x)].r-t[(x)].l+1)
#define tmid ((l+r)>>1)
#define fhead(x) for(int i=head[(x)];i;i=nt[i])
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)>(y)?(y):(x))
using namespace std;

const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double dnf=1e18;
const double alpha=0.75;
const int mod=1e9+7;
const double eps=1e-8;
const double pi=acos(-1.0);
const int hp=13331;
const int maxn=300100;
const int maxm=100100;
const int maxp=100100;
const int up=30;
struct tree
{
    int son[2];
    int fa,rev;
}t[maxn];
int st[maxn];
int x[maxn],y[maxn],rr[maxn];

void init(int n)
{
    for(int i=1;i<=n;i++)
        t[i].son[0]=t[i].son[1]=t[i].fa=t[i].rev=0;
}

void pushup(int x)
{

}

void _reverse(int x)
{
    if(!x) return ;
    swap(t[x].son[0],t[x].son[1]);
    t[x].rev^=1;
}

void pushdown(int x)
{
    if(!x) return ;
    if(t[x].rev)
    {
        _reverse(t[x].son[0]);
        _reverse(t[x].son[1]);
        t[x].rev=0;
    }
}

bool notroot(int x)
{
    return t[t[x].fa].son[0]==x||t[t[x].fa].son[1]==x;
}

int get_son(int x)
{
    return x==t[t[x].fa].son[1];
}

void rot(int x)
{
    int y=t[x].fa,z=t[y].fa;
    int k=get_son(x),w=t[x].son[k^1];
    t[y].son[k]=w,t[w].fa=y;

    if(notroot(y))t[z].son[get_son(y)]=x;
    t[x].fa=z;

    t[x].son[k^1]=y,t[y].fa=x;
    pushup(y),pushup(x);
}

void splay(int x)
{
    int top=0;
    st[++top]=x;
    for(int pos=x;notroot(pos);pos=t[pos].fa) st[++top]=t[pos].fa;
    while(top) pushdown(st[top--]);

    while(notroot(x))
    {
        int y=t[x].fa;
        int z=t[y].fa;
        if(notroot(y))
            if(get_son(x)==get_son(y)) rot(y);
            else rot(x);
        rot(x);
    }
}

void access(int x)
{
    for(int y=0;x;y=x,x=t[x].fa)
    {
        splay(x);
        t[x].son[1]=y;
        pushup(x);
    }
}

void makeroot(int x)
{
    access(x);
    splay(x);
    _reverse(x);
}

int findroot(int x)
{
    access(x);
    splay(x);
    while(t[x].son[0]) pushdown(x),x=t[x].son[0];
    splay(x);
    return x;
}

//y变成了根
void split(int x,int y)
{
    makeroot(x);
    access(y);
    splay(y);
}

bool link(int x,int y)
{
    makeroot(x);
    if(findroot(y)==x) return false;
    t[x].fa=y;
    return true;
}

bool cut(int x,int y)
{
    makeroot(x);
    if(findroot(y)!=x||t[y].fa!=x||t[y].son[0]) return false;
    t[y].fa=t[x].son[1]=0;
    pushup(x);
    return true;
}

bool connected(int x,int y)
{
    x=findroot(x);
    y=findroot(y);
    return x==y;
}



int main(void)
{
    int tt;
    scanf("%d",&tt);
    while(tt--)
    {
        int n,m,q;
        scanf("%d%d%d",&n,&m,&q);
        init(n);
        for(int i=1;i<=m;i++)
            scanf("%d%d",&x[i],&y[i]);
        for(int l=1,r=1;l<=m;l++)
        {
            while(r<=m&&!connected(x[r],y[r]))
                link(x[r],y[r]),r++;
            rr[l]=r;
            cut(x[l],y[l]);
        }
        int l,r,last=0;
        for(int i=1;i<=q;i++)
        {
            scanf("%d%d",&l,&r);
            l=(l^last)%m+1;
            r=(r^last)%m+1;
            if(l>r) swap(l,r);
            if(rr[l]<=r) last=1,printf("Yes\n");
            else last=0,printf("No\n");
        }
    }
    return 0;
}