2019牛客暑期多校训练营（第八场）E Explorer —— 搜索型线段树，LCT

This way

题意：

给你一张图，每条边都有能通过的数组范围，问你有多少种数字能够从1到n

题解：

这个主要有线段树和LCT两种各做法，然而我在比赛的时候一种都没做出来。。
这个是LCT的时间复杂度以及空间复杂度：

这是线段树：

可以看出LCT还是很优秀的（虽然可能是有各种优化的原因）

这是线段树的做法：

线段树就像前两天查中位数那道题一样的建树方法，也就是用r+1代替r，这样的话b[r+1]-b[l]代替b[r]-b[l]+1，省下可能出现的错误。虽然这里没有push_down。之后我们用vector记录每个区间所拥有的边，这样我们查询这个区间所拥有的边的时候就可以利用并查集来看1与n是否联通。

#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
struct node
{
    int x,y,l,r;
}e[N];
int b[N*2];
vector<int>vec[N*5];
void update(int l,int r,int root,int ql,int qr,int x)
{
    if(l>=ql&&r<=qr)
    {
        vec[root].push_back(x);
        return ;
    }
    int mid=l+r>>1;
    if(mid>=ql)
        update(l,mid,root<<1,ql,qr,x);
    if(mid<qr)
        update(mid+1,r,root<<1|1,ql,qr,x);
}
int fa[N];
int finds(int x){return x==fa[x]?fa[x]:finds(fa[x]);}
int ans,n,m,siz[N];
void query(int l,int r,int root)
{
    vector<int>v;
    for(int i=0;i<vec[root].size();i++)
    {
        int x=vec[root][i];
        int fax=finds(e[x].x),fay=finds(e[x].y);
        if(fax!=fay)
        {
            if(siz[fax]<siz[fay])
                swap(fax,fay);
            fa[fay]=fax;
            v.push_back(fay);
            siz[fax]+=siz[fay];
        }
    }
    if(finds(1)==finds(n))
        ans+=b[r+1]-b[l];
    else if(l<r)
    {
        int mid=l+r>>1;
        query(l,mid,root<<1);
        query(mid+1,r,root<<1|1);
    }
    for(int i=0;i<v.size();i++)
        fa[v[i]]=v[i];
    v.clear();
}
int main()
{

    for(int i=1;i<N;i++)
        fa[i]=i,siz[i]=1;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
        scanf("%d%d%d%d",&e[i].x,&e[i].y,&e[i].l,&e[i].r),b[i*2-1]=e[i].l,b[i*2]=e[i].r+1;
    sort(b+1,b+1+m*2);
    int all=unique(b+1,b+1+m*2)-b-1;
    for(int i=1;i<=m;i++)
        update(1,all,1,lower_bound(b+1,b+1+all,e[i].l)-b,lower_bound(b+1,b+1+all,e[i].r+1)-b-1,i);
    query(1,all,1);
    printf("%d\n",ans);
    return 0;
}

This is LCT

这也是从别人那里看来的做法：LCT维护最小生成树
首先将所有边从大到小排序，为什么？因为新进来的边的右边界一定小于等于原来的右边界，这样的话我们只需要考虑左边界即可，那么如果当前两个点不在一棵树内，就连接，至于为什么是link(i,m+x),因为我们后面修改的时候需要知道边的信息，从而将这条边删掉，然后再加入新的边。
至于我们要删掉那条边，当然是左边界最大的边，因为右边界定了，是当前的最小，那么有多种1-n的可能时，我们当然是选择左边界最小的可能性，这样我们LCT维护1-m链上的左边界最大值即可。
当1-n联通时，查询链上最大左边界是否小于当前边的右边界，再加入答案。
最后是枚举所有的区间，取其不相交部分。

#include<bits/stdc++.h>
#define G if(++ip==ie)if(fread(ip=buf,1,SZ,stdin))
#define pa pair<int,int>
#define ri register int
#define ii inline int
#define ib inline bool
#define iv inline void
using namespace std;
const int N=3e5+5;
int f[N],ch[N][2],rev[N],siz[N];
const int SZ=1<<19;
char buf[SZ],*ie=buf+SZ,*ip=ie-1;
ii in(){
    G;while(*ip<'-')G;
    ri x=*ip&15;G;
    while(*ip>'-'){x*=10;x+=*ip&15;G;}
    return x;
}
struct node
{
    int x,y,l,r;//struct do not suppose ri
    bool operator< (const node& a)const
    {
        return r>a.r;
    }
}e[N];
int mx[N];
ib is_rt(ri x)
{
    return ch[f[x]][0]==x||ch[f[x]][1]==x;
}
int ans[N],a[N];
iv push_up(ri x)
{
    mx[x]=x;
    ch[x][0]&&e[mx[ch[x][0]]].l>e[mx[x]].l&&(mx[x]=mx[ch[x][0]]);
    ch[x][1]&&e[mx[ch[x][1]]].l>e[mx[x]].l&&(mx[x]=mx[ch[x][1]]);
}
iv reverse(ri x)
{
    swap(ch[x][0],ch[x][1]);
    rev[x]^=1;
}
iv push_down(ri x)
{
    if(!rev[x])
        return ;
    if(ch[x][0])
        reverse(ch[x][0]);
    if(ch[x][1])
        reverse(ch[x][1]);
    rev[x]=0;
}
iv rotate(ri x){//一次旋转
    int y=f[x],z=f[y],k=ch[y][1]==x,w=ch[x][!k];
    if(is_rt(y))ch[z][ch[z][1]==y]=x;ch[x][!k]=y;ch[y][k]=w;//额外注意if(nroot(y))语句，此处不判断会引起致命错误（与普通Splay的区别2）
    if(w)f[w]=y;f[y]=x;f[x]=z;
    push_up(y);
}
int st[N];
iv splay(ri x){//只传了一个参数，因为所有操作的目标都是该Splay的根（与普通Splay的区别3）
    ri y=x,z=0;
    st[++z]=y;//st为栈，暂存当前点到根的整条路径，pushdown时一定要从上往下放标记（与普通Splay的区别4）
    while(is_rt(y))st[++z]=y=f[y];
    while(z)push_down(st[z--]);
    while(is_rt(x)){
        y=f[x];z=f[y];
        if(is_rt(y))
            rotate((ch[y][0]==x)^(ch[z][0]==y)?x:y);
        rotate(x);
    }
    push_up(x);
}
/*当然了，其实利用函数堆栈也很方便，代替上面的手工栈，就像这样
I pushall(R x){
    if(is_rt(x))pushall(f[x]);
    pushdown(x);
}*/
iv access(ri x){//访问
    for(ri y=0;x;x=f[y=x])
        splay(x),ch[x][1]=y,push_up(x);
}
iv makeroot(ri x){//换根
    access(x);splay(x);
    reverse(x);
}
ii findroot(ri x){//找根（在真实的树中的）
    access(x);splay(x);
    while(ch[x][0])push_down(x),x=ch[x][0];
    splay(x);
    return x;
}
iv split(ri x,ri y){//提取路径
    makeroot(x);
    access(y);splay(y);
}
iv link(ri x,ri y){//连边
    makeroot(x);
    if(findroot(y)!=x)f[x]=y;
    //splay(x);
    push_up(x);
}
iv cut(ri x,ri y){//断边
    makeroot(x);
    if(findroot(y)==x&&f[y]==x&&!ch[y][0]){
        f[y]=ch[x][1]=0;
        push_up(x);
    }
}
ii finds(ri x)
{
    access(x),splay(x);
    while(ch[x][0])
        x=ch[x][0];
    return x;
}
ii query(ri x,ri y)
{
    makeroot(y);
    access(x),splay(x);
    return mx[x];
}
vector<pa>vec;
int main()
{
    ri n,m;
    n=in(),m=in();
    for(ri i=1;i<=m;i++)
        e[i].x=in(),e[i].y=in(),e[i].l=in(),e[i].r=in();
    sort(e+1,e+1+m);
    for(ri i=1;i<=m;i++)
    {
        ri x=e[i].x,y=e[i].y;
        if(finds(m+x)!=finds(m+y))
            link(i,m+x),link(i,m+y);
        else
        {
            ri mm=query(m+x,m+y);
            //printf("mm: %d\n",mm);
            if(e[mm].l>e[i].l)
                cut(mm,m+e[mm].y),cut(mm,m+e[mm].x),link(i,m+x),link(i,m+y);
        }
        if(finds(m+1)==finds(m+n))
        {
            ri mm=query(m+1,m+n);
            if(e[mm].l<=e[i].r)
                vec.push_back({e[mm].l,e[i].r});
        }
    }
    sort(vec.begin(),vec.end());
    ri ans=0,j;
    for(ri i=0;i<vec.size();i=j)
    {
        int rig=vec[i].second;
        for(j=i+1;j<vec.size()&&vec[j].first<=rig;j++)
            rig=max(rig,vec[j].second);
        ans+=rig-vec[i].first+1;
    }
    printf("%d\n",ans);
    return 0;
}