LCT例题

最新推荐文章于 2018-12-22 10:27:00 发布
最新推荐文章于 2018-12-22 10:27:00 发布
阅读量270 收藏
点赞数 1
分类专栏： lct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36799943/article/details/79506455
版权

P3690 【模板】Link Cut Tree （动态树）

#include<cstdio>
#include<iostream>
using namespace std;
const int N=320000; 
int w[N],n,m,opt,x,y;
struct LCT{
    int ch[N][2],f[N],val[N],flag[N],tot,tmp[N];
    int get(int x){
        return ch[f[x]][1]==x;
    }
    void pushdown(int x){int l=ch[x][0],r=ch[x][1];
        if(flag[x]){
            flag[l]^=1;flag[r]^=1;flag[x]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    void update(int x){
        val[x]=val[ch[x][0]]^val[ch[x][1]]^w[x];
    }
    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
        update(old);update(x);
    }
    void splay(int x){tot=1;tmp[1]=x;
        for(int now=x;!isroot(now);now=f[now]) tmp[++tot]=f[now];
        for(;tot;tot--) pushdown(tmp[tot]);
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) splay(x),ch[x][1]=y,update(x);}
    void makeroot(int x){access(x);splay(x);flag[x]^=1;} 
    int oldroot(int x){access(x),splay(x);while(ch[x][0]) x=ch[x][0];return x;} 
    void split(int x,int y){makeroot(x);access(y);splay(y);}
    void cut(int y,int x){split(x,y);if(x==ch[y][0]) ch[y][0]=0,f[x]=0;}
    void link(int x,int y){makeroot(x);f[x]=y;}
    int query(int x,int y){split(x,y);return val[y];}
}T;

int main(){scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&w[i]),T.val[i]=w[i];
    while(m--){scanf("%d%d%d",&opt,&x,&y);
        if(!opt) printf("%d\n",T.query(x,y));
        else if(opt==1) {if(T.oldroot(x)!=T.oldroot(y)) T.link(x,y);}
        else if(opt==2) {if(T.oldroot(x)==T.oldroot(y)) T.cut(x,y);}
        else T.access(x),T.splay(x),w[x]=y,T.update(x);
    }
}
P2147 [SDOI2008]Cave 洞穴勘测
#include<cstdio>
#include<iostream>
using namespace std;
const int N=20000; 
int w[N],n,m,opt,x,y;char s[20];
struct LCT{
    int ch[N][2],f[N],flag[N],tot,tmp[N];
    int get(int x){
        return ch[f[x]][1]==x;
    }
    void pushdown(int x){int l=ch[x][0],r=ch[x][1];
        if(flag[x]){
            flag[l]^=1;flag[r]^=1;flag[x]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
    }
    void splay(int x){tot=1;tmp[1]=x;
        for(int now=x;!isroot(now);now=f[now]) tmp[++tot]=f[now];
        for(;tot;tot--) pushdown(tmp[tot]);
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) splay(x),ch[x][1]=y;}
    void makeroot(int x){access(x);splay(x);flag[x]^=1;} 
    int oldroot(int x){access(x),splay(x);while(ch[x][0]) x=ch[x][0];return x;} 
    void split(int x,int y){makeroot(x);access(y);splay(y);}
    void cut(int y,int x){split(x,y);if(x==ch[y][0]) ch[y][0]=0,f[x]=0;}
    void link(int x,int y){makeroot(x);f[x]=y;}
}T;

int main(){scanf("%d%d",&n,&m);

    while(m--){cin>>s;
        scanf("%d%d",&x,&y);
        if(s[0]=='Q') {if(T.oldroot(x)==T.oldroot(y))printf("Yes\n");else printf("No\n");}
        else if(s[0]=='C') {if(T.oldroot(x)!=T.oldroot(y)) T.link(x,y);}
        else if(s[0]=='D') {if(T.oldroot(x)==T.oldroot(y)) T.cut(x,y);}
    }
}

P3703 [SDOI2017]树点涂色
这个题转化一下，一操作就是把他们弄到一棵树里，因为，多了一个颜色吗，这样虚子树的权值要+1,子树要减一
而每次都加修改1，差最大值，就是权值，所以树剖线段树维护

#include<cstdio>
#include<iostream>
using namespace std;
const int M=110000; 
int n,m,to[2*M],nex[M*2],head[M],tot,f[M],dep[M],top[M],cnt,size[M],son[M],id[M],low[M];
void add(int x,int y){
    nex[++tot]=head[x];
    to[tot]=y;head[x]=tot;
}
struct xianduantree{
    int maxn[4*M],ad[4*M];
    void update(int x){
        maxn[x]=max(maxn[x<<1],maxn[x<<1|1]);
    }
    void built(int o,int l,int r){
    if(l==r) maxn[o]=0,ad[o]=0;
    else {
        int mid=(l+r)>>1;
        built(o<<1,l,mid);
        built(o<<1|1,mid+1,r);
        update(o);  
        }
    }
    void pushdown(int o){
        ad[o<<1]=(ad[o<<1]+ad[o]);
        ad[o<<1|1]=(ad[o<<1|1]+ad[o]);
        maxn[o<<1]=maxn[o<<1]+ad[o];
        maxn[o<<1|1]=maxn[o<<1|1]+ad[o];
        ad[o]=0;
    }
    void add(int o,int l,int r,int ql,int qr,int ins){
        if(l>qr||r<ql) return ;
        if(l>=ql&&r<=qr) {
            ad[o]=(ad[o]+ins);
            maxn[o]=maxn[o]+ins;
            return ;
        }
        int mid=(l+r)>>1;
        pushdown(o);
        add(o<<1,l,mid,ql,qr,ins);
        add(o<<1|1,mid+1,r,ql,qr,ins);
        update(o);
    }
    int ask(int o,int l,int r,int ql,int qr){
        if(l>qr||r<ql) return 0;
        if(l>=ql&&r<=qr) return maxn[o];
        int mid=(l+r)>>1;
        pushdown(o);
        return max(ask(o<<1,l,mid,ql,qr),ask(o<<1|1,mid+1,r,ql,qr));
    }
}tr;
struct LCT{
    int ch[M][2],f[M];
    int get(int x){
        return ch[f[x]][1]==x;
    }

    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
    }
    void splay(int x){
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) {
        splay(x);int t=ch[x][1];
        while(ch[t][0]) t=ch[t][0];
        tr.add(1,1,cnt,id[t],low[t],1);t=y;
        while(ch[t][0]) t=ch[t][0];
        tr.add(1,1,cnt,id[t],low[t],-1);
        ch[x][1]=y;
    }}
}T;
int dfs1(int x){
    size[x]=1;dep[x]=dep[f[x]]+1;
    int maxsi=0;
    for(int i=head[x];i;i=nex[i]){
        int tmp=to[i];
        if(tmp!=f[x]){
            f[tmp]=x;
            int siz=dfs1(tmp);
            size[x]+=siz;
            if(maxsi<siz)
            son[x]=tmp,maxsi=siz;
        }
    }
    return size[x];
}
void dfs2(int x,int topx){
    top[x]=topx;
    id[x]=++cnt;
    if(!son[x]){low[x]=cnt;return ;}
    dfs2(son[x],topx);
    for(int i=head[x],tmp;i;i=nex[i])
    if(!id[tmp=to[i]])
    dfs2(tmp,tmp);
    low[x]=cnt;
}
int lca(int x,int y){
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]])swap(x,y);
        x=f[top[x]];
    } 
    return dep[x]>dep[y]?y:x;
}
int main(){scanf("%d%d",&n,&m);
    for(int i=1,x,y;i<n;i++) scanf("%d%d",&x,&y),add(x,y),add(y,x);
    dfs1(1);dfs2(1,1);
    tr.built(1,1,cnt);
    for(int i=1;i<=n;i++) T.f[i]=f[i],tr.add(1,1,cnt,id[i],low[i],1);
    while(m--){int x,y,opt;
        scanf("%d%d",&opt,&x);
        if(opt==1) T.access(x);
        else if(opt==2) scanf("%d",&y),opt=lca(x,y),printf("%d\n",tr.ask(1,1,cnt,id[x],id[x])
        +tr.ask(1,1,cnt,id[y],id[y])-2*tr.ask(1,1,cnt,id[opt],id[opt])+1);
        else  printf("%d\n",tr.ask(1,1,cnt,id[x],low[x]));
    }

}

P3203 [HNOI2010]弹飞绵羊

#include<cstdio>
#include<iostream>
using namespace std;
const int N=420000; 
int w[N],n,m,opt,x,y;
struct LCT{
    int ch[N][2],f[N],val[N],flag[N],tot,tmp[N];
    int get(int x){
        return ch[f[x]][1]==x;
    }
    void pushdown(int x){int l=ch[x][0],r=ch[x][1];
        if(flag[x]){
            flag[l]^=1;flag[r]^=1;flag[x]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    void update(int x){
        val[x]=val[ch[x][0]]+val[ch[x][1]]+1;
    }
    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
        update(old);update(x);
    }
    void splay(int x){tot=1;tmp[1]=x;
        for(int now=x;!isroot(now);now=f[now]) tmp[++tot]=f[now];
        for(;tot;tot--) pushdown(tmp[tot]);
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) splay(x),ch[x][1]=y,update(x);}
    void makeroot(int x){access(x);splay(x);flag[x]^=1;} 
    int oldroot(int x){access(x),splay(x);while(ch[x][0]) x=ch[x][0];return x;} 
    void split(int x,int y){makeroot(x);access(y);splay(y);}
    void cut(int y,int x){split(x,y);if(x==ch[y][0]) ch[y][0]=0,f[x]=0;}
    void link(int x,int y){makeroot(x);f[x]=y;}
    int query(int x){makeroot(n+1);access(x);splay(x);return val[ch[x][0]];}
}T;

int main(){scanf("%d",&n);
    for(int i=1;i<=n+1;i++) T.val[i]=1;
    for(int i=1;i<=n;i++) {
        scanf("%d",&w[i]);
         T.f[i]=(i+w[i]<=n)?i+w[i]:(n+1);
    }
    scanf("%d",&m);
    while(m--){scanf("%d%d",&opt,&x);x++;
        if(opt==1) printf("%d\n",T.query(x));
        else if(opt==2) {
            scanf("%d",&y);T.cut(x,(w[x]+x<=n)?x+w[x]:(n+1));T.link(x,(y+x<=n)?x+y:(n+1));w[x]=y;
        }
    }
}
P2387 [NOI2014]魔法森林

这个题是一个二维问题，没有修改，直接用扫描线，降维
然后LCA维护最小生成树和最大边；

// luogu-judger-enable-o2
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=320000,INF=510000; 
int w[N],n,m,opt,x,y,s[N],t[N],id,ans=INF;
struct node{
    int u,v,a,b;
}e[N];
struct LCT{
    int ch[N][2],f[N],val[N],flag[N],tot,tmp[N],maxs[N];
    int get(int x){
        return ch[f[x]][1]==x;
    }
    void pushdown(int x){int l=ch[x][0],r=ch[x][1];
        if(flag[x]){
            flag[l]^=1;flag[r]^=1;flag[x]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    void update(int x){
        maxs[x]=x;
       if(val[maxs[ch[x][0]]]>val[maxs[x]]) maxs[x]=maxs[ch[x][0]];
       if(val[maxs[ch[x][1]]]>val[maxs[x]]) maxs[x]=maxs[ch[x][1]];
    }
    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
        update(old);update(x);
    }
    void splay(int x){tot=1;tmp[1]=x;
        for(int now=x;!isroot(now);now=f[now]) tmp[++tot]=f[now];
        for(;tot;tot--) pushdown(tmp[tot]);
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) splay(x),ch[x][1]=y,update(x);}
    void makeroot(int x){access(x);splay(x);flag[x]^=1;} 
    int oldroot(int x){access(x),splay(x);while(ch[x][0]) x=ch[x][0];return x;} 
    void split(int x,int y){makeroot(x);access(y);splay(y);}
    void cut(int y,int x){split(x,y);if(x==ch[y][0]) ch[y][0]=0,f[x]=0;}
    void link(int x,int y){makeroot(x);f[x]=y;}
    void add(int x,int y,int z){
        if(oldroot(x)^oldroot(y)){id++;
            s[id]=x,t[id]=y;
            val[id]=z,maxs[id]=id;
            link(x,id),link(y,id);
        }
        else{
            split(x,y);
            int v=maxs[y];
            if(val[v]<z) return;
            cut(s[v],v),cut(t[v],v);id++;
            s[id]=x,t[id]=y;
            val[id]=z,maxs[id]=id;
            link(x,id),link(y,id);
        }
    }
    int query(int x,int y){if(oldroot(x)^oldroot(y)) return INF;split(x,y);
    return val[maxs[y]];}
}T;
bool cmp(node x,node y){
    return x.a!=y.a?x.a<y.a:x.b<y.b;
}
int main(){scanf("%d%d",&n,&m);id=n;
    for(int i=1;i<=m;i++)
     scanf("%d%d%d%d",&e[i].u,&e[i].v,&e[i].a,&e[i].b);
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=m;i++){
        T.add(e[i].u,e[i].v,e[i].b);
         ans=min(ans,e[i].a+T.query(1,n));
    }
    printf("%d\n",ans==INF?-1:ans);
}

P4172 [WC2006]水管局长
这个题离线做，把删边弄成加边
LCT维护最小生成树和最大边

#include<algorithm>
#include<iostream>
#define N 1500000
#include<cstdio>
using namespace std;
struct LCT{
    int ch[N][2],f[N],val[N],flag[N],tot,tmp[N],maxs[N];
    int get(int x){
        return ch[f[x]][1]==x;
    }
    void pushdown(int x){int l=ch[x][0],r=ch[x][1];
        if(flag[x]){
            flag[l]^=1;flag[r]^=1;flag[x]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    void update(int x){
        maxs[x]=x;
       if(val[maxs[ch[x][0]]]>val[maxs[x]]) maxs[x]=maxs[ch[x][0]];
       if(val[maxs[ch[x][1]]]>val[maxs[x]]) maxs[x]=maxs[ch[x][1]];
    }
    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
        update(old);update(x);
    }
    void splay(int x){tot=1;tmp[1]=x;
        for(int now=x;!isroot(now);now=f[now]) tmp[++tot]=f[now];
        for(;tot;tot--) pushdown(tmp[tot]);
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) splay(x),ch[x][1]=y,update(x);}
    void makeroot(int x){access(x);splay(x);flag[x]^=1;} 
    int oldroot(int x){access(x),splay(x);while(ch[x][0]) x=ch[x][0];return x;} 
    void split(int x,int y){makeroot(x);access(y);splay(y);}
    void cut(int y,int x){split(x,y);if(x==ch[y][0]) ch[y][0]=0,f[x]=0;}
    void link(int x,int y){makeroot(x);f[x]=y;}
    int query(int x,int y){split(x,y);return maxs[y];}
}T;
struct eage{
    int u,v,l,id;
    bool f;
}e[N],q[N];
int n,m,Q;int f[N],ans[N];
bool comp1(eage aa,eage bb){
    return aa.u==bb.u?aa.v<bb.v:aa.u<bb.u;
}
bool comp2(eage aa,eage bb){
    return aa.l<bb.l;
}
bool comp3(eage aa,eage bb){
    return aa.id<bb.id;
}
int findit(int u,int v){
    int l=1,r=m;
    while(l<=r){
        int mid=(l+r)>>1;
        if(e[mid].u<u||(e[mid].u==u&&e[mid].v<v))l=mid+1;
        else if(e[mid].u==u&&e[mid].v==v)return mid;
        else r=mid-1;
    }
}

int get_f(int x){
    return x==f[x]?f[x]:f[x]=get_f(f[x]);
}
void KUSCER(){
    for(int i=1;i<=n;++i) f[i]=i;
    sort(e+1,e+m+1,comp3);int tot=0;
    for(int i=1;i<=m;++i){
        if(e[i].f) continue; 
        int x=get_f(e[i].u),y=get_f(e[i].v);
        if(x==y) continue;tot++;
        f[x]=y;
        T.link(e[i].u,i+n);
        T.link(e[i].v,i+n);
        if(tot==n-1) return;
    }
}
int main()
{
    scanf("%d%d%d",&n,&m,&Q);
    for(int i=1;i<=m;++i){
        scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].l);
        if(e[i].u>e[i].v) swap(e[i].u,e[i].v);
    }

    sort(e+1,e+m+1,comp2);
    for(int i=1;i<=m;++i){
        e[i].id=i;
        T.val[n+i]=e[i].l;
        T.maxs[n+i]=n+i;
    }

    sort(e+1,e+m+1,comp1);
    for(int i=1,www;i<=Q;++i){
        scanf("%d%d%d",&www,&q[i].u,&q[i].v);www--;q[i].f=www;
        if(q[i].f==1){
            if(q[i].u>q[i].v) swap(q[i].u,q[i].v);
            int id=findit(q[i].u,q[i].v);
            q[i].id=e[id].id;e[id].f=1;
        }
    }
    KUSCER();
    for(int i=Q;i;--i) {
        if(q[i].f==0) ans[i]=T.val[T.query(q[i].u,q[i].v)];
        else{
            int bi=T.query(q[i].u,q[i].v);
            if(T.val[bi]>T.val[q[i].id+n]){
                T.cut(e[bi-n].u,bi);T.cut(e[bi-n].v,bi);
                T.link(q[i].u,q[i].id+n);T.link(q[i].v,q[i].id+n);
            }
        }
    }
    for(int i=1;i<=Q;++i) if(q[i].f==0) printf("%d\n",ans[i]);
    return 0;
}

P4219 [BJOI2014]大融合
我们发现这个题其实就是求虚子树个数的乘积
直接lct维护子树信息

#include<algorithm>
#include<iostream>
#define N 1500000
#include<cstdio>
using namespace std;
struct LCT{
    int ch[N][2],f[N],size[N],flag[N],tot,tmp[N],sise[N];
    int get(int x){
        return ch[f[x]][1]==x;
    }
    void pushdown(int x){int l=ch[x][0],r=ch[x][1];
        if(flag[x]){
            flag[l]^=1;flag[r]^=1;flag[x]^=1;
            swap(ch[x][0],ch[x][1]);
        }
    }
    void update(int x){
        size[x]=size[ch[x][0]]+size[ch[x][1]]+1+sise[x];
    }
    bool isroot(int x){return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;}
    void retoto(int x){
        int old=f[x],old2=f[old],opt=get(x),opt2=get(old);
        if(!isroot(old)) ch[old2][opt2]=x;f[x]=old2;
        f[old]=x;f[ch[x][opt^1]]=old;
        ch[old][opt]=ch[x][opt^1];ch[x][opt^1]=old;
        update(old);update(x);
    }
    void splay(int x){tot=1;tmp[1]=x;
        for(int now=x;!isroot(now);now=f[now]) tmp[++tot]=f[now];
        for(;tot;tot--) pushdown(tmp[tot]);
        for(int fa;(fa=f[x])&&(!isroot(x));retoto(x))
        if(!isroot(fa))retoto(get(x)==get(fa)?fa:x);
    }//认父不认子 
    void access(int x){for(int y=0;x;y=x,x=f[x]) splay(x),sise[x]+=size[ch[x][1]],sise[x]-=size[ch[x][1]=y],update(x);}
    void makeroot(int x){access(x);splay(x);flag[x]^=1;} 
    int oldroot(int x){access(x),splay(x);while(ch[x][0]) x=ch[x][0];return x;} 
    void split(int x,int y){makeroot(x);access(y);splay(y);}
    void cut(int y,int x){split(x,y);if(x==ch[y][0]) ch[y][0]=0,f[x]=0;}
    void link(int x,int y){split(x,y);f[x]=y;sise[y]+=size[x];update(y);}
}T;
int n,Q;

int main()
{
    scanf("%d%d%d",&n,&Q);
    for(int i=1;i<=n;i++) T.size[i]=1;
    while(Q--){char s[10];int x,y;
        scanf("%s%d%d",s,&x,&y);
        if(s[0]=='A') T.link(x,y);
        else {T.split(x,y);
            printf("%lld\n",1ll*(T.sise[x]+1)*(T.sise[y]+1));
        }
    }

    return 0;
}
wspl654321
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态树LCT BySemiWaker
03-05
动态树LCT
元器件应用中的LCT型陷波器
11-23
LCT型陷波器在电子工程领域中是一种重要的滤波元件，主要用于消除特定频率范围内的干扰信号，确保信号传输的纯净度。这种陷波器的设计和应用涉及到许多关键的电气特性，包括频率响应、带宽、插入损耗以及选择性等。 ...
LCT总结——应用篇（附题单）（LCT）
a83229442的博客
08-18 331
为了优化体验（其实是强迫症），蒟蒻把总结拆成了两篇，方便不同学习阶段的Dalao们切换。 LCT总结——概念篇戳这里 题单 灰常感谢XZY巨佬提供的强力资磁！（可参考XZY巨佬的博客总结） 题单对于系统地学习一个知识点还是有好处的。 所以蒟蒻搜集了各处的LCT题目（其实作为近年新兴的知识点，现有的好题不是很多，有些题树剖也可做） 大概按细化分类进行整理（类比下面的几个细化知识点，会有重复...
Link-Cut Tree(LCT) 模板总结 & 水题/模板题 动态树
とある黄鱼のOIブログ
11-21 2775
1036: [ZJOI2008]树的统计Count Time Limit: 10 Sec  Memory Limit: 162 MB Submit: 9352  Solved: 3783 [Submit][Status][Discuss] Description 一棵树上有n个节点，编号分别为1到n，每个节点都有一个权值w。我们将以下面的形式来要求你对这棵树完成一些操作： I. CH
GDSOI2017 中学生数据结构题(Lct练习)
Cold_Chair的博客
06-16 742
题目大意：给出一棵树。 要求维护：一条路径上的点权和。 修改1：一条路径上的点的点权全部加上一个数。 修改2：shift 假设一个路径上的点是ax,ak1,ak2,…ay 就把ax的点权放到ak1上，把ak1的点权放到ak2上，…… 把ay的点权放到ax上。
LCTの题表
08-26 115
像我这种彩笔就别想着这题表有多少666的题了..刷完还想刷的话请出门右转黄学长那有好多呢~~~ 不得不吐槽最后那题（好吧是我zz），这道题让我的电脑死机了两遍，还好我机智(?)的发现是内存爆了而导致的死机调了快一天。最后中午的时候还说如果还不A就去吃饭堂(饭堂：我招谁惹谁了？？？)，结果它终于、感人地AC了QWQ撒花~~~ ...
LCT动态树学习笔记--基本操作（带详细注释）
caoyang1123的博客
07-15 592
一些LCT最基本也是最核心的操作，其他一些维护树链信息的可以直接参照树链剖分。 #include<bits/stdc++.h> using namespace std; namespace LCT{ struct gg{ int ch[2],fa; bool rev; }node[10010]; void init() {for(int i=0;i<=1000...
lct_LCT_
09-29
标题中的“lct_LCT_”很可能代表“Link-Cut Tree”，这是一项在计算机科学领域，特别是算法设计中广泛使用的数据结构。Link-Cut Tree（链接切割树）是一种自顶向下的动态树数据结构，主要用于解决与树相关的操作，如...
lct.zip_LCT
09-19
【标题】"lct.zip_LCT" 涉及到的是一个名为 "lct.zip" 的压缩文件，其中包含了与"LCT"相关的资料。LCT通常代表“逻辑控制技术”（Logical Control Technology）或者“线性电流变换器”（Linear Current Transformer...
lct.zip_lct文件
09-24
标题中的“lct.zip_lct文件”指的是一个压缩包，其中包含了名为“lct”的文件。这个“lct”文件可能是一个库文件，用于在特定的编程环境或项目中提供预定义的功能，使得开发者能够更方便地进行软件开发，而无需从零...
LCT模板 LCT题型大荟萃
snowy_smile的博客
01-21 1077
以HDU4010为例，写了LCT相关的一些题目的做法 #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; void fre() { freopen("c://test//in
LCT模板题
BUFF_JEFF的博客
04-01 650
bzoj3779. 重组病毒LCT模板题（虚）前方高能，你需要（看一些线段树+dfs序+splay涨姿势）题目大意：给定一棵树，初始每个点都有一个颜色，支持三种操作： 1.将某个点到根的路径上所有点染上一种新的颜色 2.将某个点到根的路径上所有点染上一种新的颜色，然后把根设为这个点 3.定义一个点的代价为这个点到根路径上颜色的种类数，求某个点子树中所有点代价的平均值答记者问答什么答，抄别
LCT（Link-Cut Tree）详解（蒟蒻自留地）
热门推荐
Saramanda的博客
02-16 2万+
最近自学了LCT，发现网上的资料讲解不是很全面，像我这样的蒟蒻一时半会根本理解不了。我弄了很久总算是理解了LCT，打算总结一下LCT的基本操作，还请诸位神牛来找找茬。   如果你还没有接触过LCT，你可以先看一看这里： （看不懂没关系，先留个大概的印像）http://www.cnblogs.com/BLADEVIL/p/3510997.html 看完之后我们知道，LCT和静态的树链剖分很像
LCT 题目总结
EM LGH
12-22 340
首先，LCT 的概念真的不是很难：用  $splay$ 维护森林，每棵 $splay$ 的根节点的父亲指向 $splay$ 中最靠前的点的父亲 ，解释完毕，你应该会了. 当然，只看到这句话还是很难学会的，这就要你去翻阅别人的详细讲解来进一步学习动态树，不过上面的那一句话一定要牢牢记住，因为据笔者经验，很多博客将LCT讲的抽象难懂，所以一定要记住 LCT 是一个十分简单的数据结构. 很多...
从《NOI2014 魔法森林》看动态树(LCT)的简单应用
Akakii的博客
01-01 2238
题目大意 给定一个n个结点，m条边的的无向图，每条边有两个权值ai,bi。 现在从1出发，要到达n，出发时带上任意多的A,B，每次只能沿着ai≤A且bi≤B的边走，问至少要带多少的A,B使得能从1到n。 Data Constraint n≤50000,m≤200000
html css js网页设计
07-12
HTML、CSS和JavaScript是构建网页和网站的基本技术，它们共同工作来创建和设计用户界面。下面是关于这三种技术的详细介绍： ### HTML (HyperText Markup Language) - **定义**：HTML是构建网页内容的标准标记语言。 - **作用**：用于创建网页的结构和内容，如段落、链接、图片、表格等。 - **语法**：使用标签（如 `<p>`, `<div>`, `<a>`, `<img>` 等）来定义网页元素。 ### CSS (Cascading Style Sheets) - **定义**：CSS是一种样式表语言，用于描述HTML文档的呈现方式。 - **作用**：用于设置网页的布局、颜色、字体和其他视觉元素。 - **语法**：通过选择器（如 `p`, `.myclass`, `#myid` 等）应用样式规则。 ### JavaScript - **定义**：JavaScript是一种脚本语言，通常用于网页上实现交互功能。 - **作用**：允许网页与用户进行交互，如响应用户操作、动态更新内容、动画效果等。 - **语法**：Java
2023年数字乡村建设解决方案PPT(34页).pptx
最新发布
07-12
数字乡村建设解决方案旨在通过数字化转型促进乡村振兴和农业农村现代化。该方案强调了数字乡村建设的战略机遇，以"1+3+5"工程为总体框架，即一个大数据中心、三大服务平台和五类主题应用。方案着重于乡村治理、产业发展和公共服务三大问题，通过完善治理体系、升级治理能力、强化产业链条和改善资源配置来推动乡村全面振兴。 方案中提出的数字乡村大数据中心是信息资源的集散地，依托大数据、AI、物联网等新技术，实现数据驱动的决策支持。三大服务平台包括产业服务、民生服务和治理服务，旨在提升农业生产智能化、经营网络化，同时优化乡村治理结构和提升服务效能。五类主题应用覆盖生产管理、流通营销、行业监管、公共服务和乡村治理，通过具体业务应用体系，实现农业全产业链的数字化管理和服务。 预期建设效益包括通过信息技术促进乡村优势产业发展，形成城郊融合型数字乡村治理新模式，以及创新服务方式，提升服务能力，保障农民权益。整体而言，该方案以数字化为手段，推动乡村经济、治理、文化等多方面的全面升级和发展。
脉冲强光技术在灭菌烧结固化应用解决方案
07-12
脉冲强光技术在灭菌烧结固化应用解决方案，已经得到厂家授权，可以对外公示。
2024年欧洲辣椒素市场主要企业市场占有率及排名.docx
07-12
2024年欧洲辣椒素市场主要企业市场占有率及排名.docx
lct动态维护最小生成树
08-05
要动态维护最小生成树，可以使用以下算法： 1. 初始化：开始时，将最小生成树设置为一个空集合。 2. 添加边：当有新的边添加到图中时，检查该边是否会形成环路。如果形成环路，则舍弃该边；否则，将该边加入最小生成树。 3. 删除边：当一条边被删除时，检查最小生成树是否仍然连通。如果不连通，则需要找到一条新的边来连接两个不连通的部分，使得最小生成树仍然有效。 4. 更新权重：当一条边的权重发生变化时，需要重新计算最小生成树。可以使用Kruskal或Prim算法来重新构建最小生成树。 这些步骤可以在实际应用中进行优化，例如使用并查集来判断是否形成环路，使用堆来快速找到新的边等。通过动态维护最小生成树，可以在图的结构发生变化时快速更新最小生成树，以保持其有效性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值