【Learning】Link-Cut Tree 题目汇总

最新推荐文章于 2022-04-12 17:54:59 发布
最新推荐文章于 2022-04-12 17:54:59 发布
阅读量857 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ez_2016gdgzoi471/article/details/78715011
版权

这篇博客主要是记录了我Link-Cut Tree的做题记录。
推荐一个非常好的博客。orz DTZ学长 %%%%%%%
http://www.cnblogs.com/RogerDTZ/p/7436469.html
T1 bzoj2049

#include<cstdio>
#include<algorithm>
using namespace std; 
int n,m,u,v,fa[10005],ch[10005][2];
char s[20];
bool rev[10005];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return ch[fa[u]][1]==u;
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=0;
    ch[v][0]=0;
}
bool isconnect(int u,int v){
    if(u==v){
        return true;
    }
    makeroot(u);
    access(v);
    splay(v);
    return fa[u]!=0;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        scanf("%s%d%d",s,&u,&v);
        if(s[0]=='C'){
            link(u,v);
        }else if(s[0]=='D'){
            cut(u,v);
        }else{
            if(isconnect(u,v)){
                puts("Yes");
            }else{
                puts("No");
            }
        }
    }
    return 0;
}

T2 bzoj2002

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=200005;
int n,m,op,x,y,a[N],ch[N][2],fa[N],siz[N],rev[N];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    siz[u]=1;
    if(ch[u][0]){
        siz[u]+=siz[ch[u][0]];
    }
    if(ch[u][1]){
        siz[u]+=siz[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(i+a[i]<=n){
            a[i]=i+a[i];
        }else{
            a[i]=n+1;
        }
        link(i,a[i]);
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        scanf("%d%d",&op,&x);
        x++;
        if(op==1){
            makeroot(n+1);
            access(x);
            splay(x);
            printf("%d\n",siz[ch[x][0]]);
        }else{
            scanf("%d",&y);
            cut(x,a[x]);
            if(x+y<=n){
                a[x]=x+y;
            }else{
                a[x]=n+1;
            }
            link(x,a[x]);
        }
    }
    return 0;
}

T3 bzoj2631

#include<cstdio>
#include<algorithm>
using namespace std;
typedef unsigned int ui;
const int N=100005;
const ui mod=51061;
int n,q,u,v,u2,v2,c,rev[N],fa[N],ch[N][2],siz[N];
ui val[N],sumv[N],mulv[N],addv[N];
char s[5];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return ch[fa[u]][1]==u;
}
void pushup(int u){
    sumv[u]=val[u];
    siz[u]=1;
    if(ch[u][0]){
        sumv[u]=(sumv[u]+sumv[ch[u][0]])%mod;
        siz[u]+=siz[ch[u][0]];
    }
    if(ch[u][1]){
        sumv[u]=(sumv[u]+sumv[ch[u][1]])%mod;
        siz[u]+=siz[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void maintain(int u,ui mul,ui add){
    addv[u]=(addv[u]*mul%mod+add)%mod;
    mulv[u]=mulv[u]*mul%mod;
    val[u]=(val[u]*mul%mod+add)%mod;
    sumv[u]=(sumv[u]*mul%mod+siz[u]*add%mod)%mod;
}
void downtag(int u){
    if(mulv[u]!=1||addv[u]){
        if(ch[u][0]){
            maintain(ch[u][0],mulv[u],addv[u]);
        }
        if(ch[u][1]){
            maintain(ch[u][1],mulv[u],addv[u]);
        }
        mulv[u]=1;
        addv[u]=0;
    }
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
main(){
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++){
        val[i]=sumv[i]=mulv[i]=1;
    }
    for(int i=1;i<n;i++){
        scanf("%d%d",&u,&v);
        link(u,v);
    }
    for(int i=1;i<=q;i++){
        scanf("%s%d%d",s,&u,&v);
        if(s[0]=='+'){
            scanf("%d",&c);
            makeroot(u);
            access(v);
            splay(v);
            maintain(v,1,c);
        }else if(s[0]=='-'){
            scanf("%d%d",&u2,&v2);
            cut(u,v);
            link(u2,v2);
        }else if(s[0]=='*'){
            scanf("%d",&c);
            makeroot(u);
            access(v);
            splay(v);
            maintain(v,c,0);
        }else{
            makeroot(u);
            access(v);
            splay(v);
            printf("%u\n",sumv[v]);
        }
    }
    return 0;
}

T4 bzoj4530

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=100005;
int n,q,u,v,ch[N][2],fa[N],siz[N],sx[N],rev[N];
char s[10];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    siz[u]=sx[u]+1;
    if(ch[u][0]){
        siz[u]+=siz[ch[u][0]];
    }
    if(ch[u][1]){
        siz[u]+=siz[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        sx[u]+=siz[ch[u][1]]-siz[v];
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    makeroot(v);
    fa[u]=v;
    sx[v]+=siz[u];
    pushup(v);
}
int main(){
    scanf("%d%d",&n,&q);
    for(int i=1;i<=q;i++){
        scanf("%s%d%d",s,&u,&v);
        if(s[0]=='A'){
            link(u,v);
        }else{
            makeroot(u);
            access(v);
            splay(v);
            printf("%lld\n",(long long)(siz[u])*(siz[v]-siz[u]));
        }
    }
    return 0;
}

T5 bzoj2843&&bzoj1180

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=30005;
int n,m,u,v,fa[N],val[N],siz[N],sumv[N],rev[N],ch[N][2];
char s[20];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    sumv[u]=val[u];
    siz[u]=1;
    if(ch[u][0]){
        sumv[u]+=sumv[ch[u][0]];
        siz[u]+=siz[ch[u][0]];
    }
    if(ch[u][1]){
        sumv[u]+=sumv[ch[u][1]];
        siz[u]+=siz[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
bool isconnect(int u,int v){
    if(u==v){
        return true;
    }
    makeroot(u);
    access(v);
    splay(v);
    return fa[u]!=0;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&val[i]);
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++){
        scanf("%s%d%d",s,&u,&v);
        if(s[0]=='b'){
            if(isconnect(u,v)){
                puts("no");
            }else{
                puts("yes");
                link(u,v);
            }
        }else if(s[0]=='p'){
            makeroot(u);
            val[u]=v;
            pushup(u);
        }else{
            if(isconnect(u,v)){
                makeroot(u);
                access(v);
                splay(v);
                printf("%d\n",sumv[v]);
            }else{
                puts("impossible");
            }
        }
    }
    return 0;
}

T6 hdu4010

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=300005;
int n,q,u,v,w,op,cnt,fa[N],ch[N][2],val[N],rev[N],maxv[N],tag[N];
int uu[N],vv[N];
void init(){
    memset(fa,0,sizeof(fa));
    memset(ch,0,sizeof(ch));
    memset(val,0,sizeof(val));
    memset(rev,0,sizeof(rev));
    memset(maxv,0,sizeof(maxv));
    memset(tag,0,sizeof(tag));
    cnt=0;
}
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    maxv[u]=max(val[u],max(maxv[ch[u][0]],maxv[ch[u][1]]));
}
void reverse(int u){
    if(!u){
        return;
    }
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void maintain(int u,int add){
    if(!u){
        return;
    }
    val[u]+=add;
    maxv[u]+=add;
    tag[u]+=add;
}
void downtag(int u){
    if(rev[u]){
        reverse(ch[u][0]);
        reverse(ch[u][1]);
        rev[u]=0;
    }
    if(tag[u]){
        maintain(ch[u][0],tag[u]);
        maintain(ch[u][1],tag[u]);
        tag[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    if(u==v){
        return;
    }
    makeroot(u);
    fa[u]=v;
    if(u==v){
        exit(0);
    }
}
void cut(int u,int v){
    if(u==v){
        return;
    }
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
bool isconnect(int u,int v){
    if(u==v){
        return true;
    }
    makeroot(u);
    access(v);
    splay(v);
    return fa[u]!=0;
}
int main(){
    while(~scanf("%d",&n)){
        init();
        for(int i=1;i<n;i++){
            scanf("%d%d",&uu[i],&vv[i]);
        }
        for(int i=1;i<=n;i++){
            scanf("%d",&val[i]);
            maxv[i]=val[i];
        }
        for(int i=1;i<n;i++){
            link(uu[i],vv[i]);
        }
        scanf("%d",&q);
        for(int i=1;i<=q;i++){
            scanf("%d",&op);
            if(op==1){
                scanf("%d%d",&u,&v);
                if(isconnect(u,v)){
                    puts("-1");
                }else{
                    link(u,v);
                }
            }else if(op==2){
                scanf("%d%d",&u,&v);
                if(!isconnect(u,v)||u==v){
                    puts("-1");
                }else{
                    cut(u,v);
                }
            }else if(op==3){
                scanf("%d%d%d",&w,&u,&v);
                if(!isconnect(u,v)){
                    puts("-1");
                }else{
                    makeroot(u);
                    access(v);
                    splay(v);
                    maintain(v,w);
                }
            }else{
                scanf("%d%d",&u,&v);
                if(!isconnect(u,v)){
                    puts("-1");
                }else{
                    makeroot(u);
                    access(v);
                    splay(v);
                    printf("%d\n",maxv[v]);
                }
            }
        }
        puts("");
    }
    return 0;
}

T7 bzoj3282

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=300005;
int n,m,op,u,v,fa[N],ch[N][2],rev[N],val[N],sumv[N];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    sumv[u]=val[u];
    if(ch[u][0]){
        sumv[u]^=sumv[ch[u][0]];
    }
    if(ch[u][1]){
        sumv[u]^=sumv[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
bool isconnect(int u,int v){
    if(u==v){
        return true;
    }
    makeroot(u);
    access(v);
    splay(v);
    return fa[u]!=0;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&val[i]);
        sumv[i]=val[i];
    }
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&op,&u,&v);
        if(op==0){
            makeroot(u);
            access(v);
            splay(v);
            printf("%d\n",sumv[v]);
        }else if(op==1){
            if(!isconnect(u,v)){
                link(u,v);
            }
        }else if(op==2){
            if(isconnect(u,v)&&u!=v){
                cut(u,v);
            }
        }else{
            makeroot(u);
            val[u]=v;
            pushup(u);
        }
    }
    return 0;
}

T8 bzoj3669

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=150005,M=150005;
int n,m,ans=0x7f7f7f7f,fa[N],ch[N][2],rev[N];
struct edge{
    int u,v,a,b,id;
    bool operator < (const edge &a) const{
        return b<a.b;
    }
}e[M],val[N],maxv[N];
bool cmp(edge a,edge b){
    return a.a<b.a;
}
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    maxv[u]=val[u];
    if(ch[u][0]){
        maxv[u]=max(maxv[u],maxv[ch[u][0]]);
    }
    if(ch[u][1]){
        maxv[u]=max(maxv[u],maxv[ch[u][1]]);
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
bool isconnect(int u,int v){
    if(u==v){
        return true;
    }
    makeroot(u);
    access(v);
    splay(v);
    return fa[u]!=0;
}
int main(){
    scanf("%d%d",&n,&m);
    if(n==1){
        puts("0");
        return 0;
    }
    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++){
        e[i].id=i;
        val[i+n]=maxv[i+n]=e[i];
    }
    for(int i=1;i<=m;i++){
        if(!isconnect(e[i].u,e[i].v)){
            link(e[i].u,i+n);
            link(i+n,e[i].v);
        }else if(e[i].u!=e[i].v){
            makeroot(e[i].u);
            access(e[i].v);
            splay(e[i].v);
            edge tmp=maxv[e[i].v];
            if(e[i].b<maxv[e[i].v].b){
                cut(tmp.u,tmp.id+n);
                cut(tmp.id+n,tmp.v);
                link(e[i].u,i+n);
                link(i+n,e[i].v);
            }
        }
        if(isconnect(1,n)){
            makeroot(1);
            access(n);
            splay(n);
            ans=min(ans,e[i].a+maxv[n].b);
        }
    }
    printf("%d\n",ans==0x7f7f7f7f?-1:ans);
    return 0;
}

T8 bzoj3306
和遥远的国度一题很像，只不过写了Link-Cut Tree。打了一个Treap。

#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int N=100005;
int n,q,rt,f,x,y,a[N],fa[N],rev[N],minv[N],ch[N][2];
int siz[N*50],w[N*50],val[N*50],rnd[N*50],c[N*50][2],mmp[N*50];
char s[10];
struct Treap{
    int root;
    int qmin(){
        int k=root;
        while(c[k][0]){
            k=c[k][0];
        }
        return val[k];
    }
    void pushup(int u){
        siz[u]=w[u]+siz[c[u][0]]+siz[c[u][1]];
    }
    void rotate(int &y,int md){
        int x=c[y][md];
        c[y][md]=c[x][!md];
        c[x][!md]=y;
        pushup(y);
        pushup(x);
        y=x;
    }
    void insert(int &k,int x){
        if(!k){
            k=mmp[mmp[0]--];
            siz[k]=w[k]=1;
            c[k][0]=c[k][1]=0;
            val[k]=x;
            rnd[k]=rand();
            return;
        }
        siz[k]++;
        if(x==val[k]){
            w[k]++;
        }else{
            int md=x>val[k];
            insert(c[k][md],x);
            if(rnd[c[k][md]]<rnd[k]){
                rotate(k,md);
            }
        }
    }
    void remove(int &k,int x){
        siz[k]--;
        if(x==val[k]){
            if(w[k]>1){
                w[k]--;
            }else{
                if(c[k][0]*c[k][1]==0){
                    mmp[++mmp[0]]=k;
                    k=c[k][0]+c[k][1];
                }else{
                    rotate(k,rnd[c[k][0]]>rnd[c[k][1]]);
                    remove(k,x);
                }
            }
        }else{
            remove(c[k][x>val[k]],x);
        }
    }
}set[N];
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
int pushup(int u){
    minv[u]=set[u].qmin();
    if(ch[u][0]){
        minv[u]=min(minv[u],minv[ch[u][0]]);
    }
    if(ch[u][1]){
        minv[u]=min(minv[u],minv[ch[u][1]]);
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[fa[y]][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        if(ch[u][1]){
            set[u].insert(set[u].root,minv[ch[u][1]]);
        }
        ch[u][1]=v;
        if(ch[u][1]){
            set[u].remove(set[u].root,minv[ch[u][1]]);
        }
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
int cnt,head[N],to[N],nxt[N];
void adde(int u,int v){
    to[++cnt]=v;
    nxt[cnt]=head[u];
    head[u]=cnt;
}
void dfs(int u){
    int v;
    minv[u]=a[u];
    set[u].insert(set[u].root,a[u]);
    for(int i=head[u];i;i=nxt[i]){
        v=to[i];
        dfs(v);
        fa[v]=u;
        set[u].insert(set[u].root,minv[v]);
    }
    pushup(u);
}
int main(){
    for(int i=5000000;i>=1;i--){
        mmp[++mmp[0]]=i;
    }
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++){
        scanf("%d%d",&f,&a[i]);
        if(f){
            adde(f,i);
        }else{
            rt=i;
        }
    }
    dfs(rt);
    for(int i=1;i<=q;i++){
        scanf("%s%d",s,&x);
        if(s[0]=='V'){
            scanf("%d",&y);
            access(x);
            splay(x);
            set[x].remove(set[x].root,a[x]);
            a[x]=y;
            set[x].insert(set[x].root,a[x]);
            pushup(x);
        }else if(s[0]=='E'){
            makeroot(x);
        }else{
            access(x);
            splay(x);
            printf("%d\n",set[x].qmin());
        }
    }
    return 0;
}

T9 bzoj2959

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=150005;
int n,m,op,u,v,fu0,fv0,fu1,fv1,pa[N][2],fa[N],ch[N][2],rev[N],val[N],sumv[N];
int a[N];
int find(int u,int md){
    return u==pa[u][md]?u:pa[u][md]=find(pa[u][md],md);
}
bool isroot(int u){
    if(!fa[u]){
        return true;
    }
    int tmp=find(fa[u],1);
    return u!=ch[tmp][0]&&u!=ch[tmp][1];
}
int which(int u){
    return u==ch[find(fa[u],1)][1];
}
void pushup(int u){
    if(!u){
        return;
    }
    sumv[u]=val[u]+sumv[ch[u][0]]+sumv[ch[u][1]];
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    if(!isroot(u)){
        pushdown(fa[u]);
    }
    downtag(u);
}
void rotate(int x){
    int y=find(fa[x],1),z=find(fa[y],1),md=x==ch[y][1];
    if(y==ch[z][0]||y==ch[z][1]){
        ch[z][y==ch[z][1]]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    if(ch[y][md]){
        fa[ch[y][md]]=y;
    }
    ch[x][!md]=y;
    if(y){
        fa[y]=x;
    }
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=find(fa[u],1)){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
int dfs(int rt,int u){
    if(!u){
        return 0;
    }
    pa[u][1]=rt;
    return dfs(rt,ch[u][0])+dfs(rt,ch[u][1])+val[u];
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        pa[i][0]=pa[i][1]=i;
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        sumv[i]=val[i]=a[i];
    }
    for(int i=1;i<=m;i++){
        if(i==24){
            u++;
        }
        scanf("%d%d%d",&op,&u,&v);
        if(op==1){
            if((fu1=find(u,1))!=(fv1=find(v,1))){
                if((fu0=find(u,0))!=(fv0=find(v,0))){
                    makeroot(fu1);
                    fa[fu1]=fv1;
                    pa[fv0][0]=fu0;
                }else{
                    makeroot(fu1);
                    access(fv1);
                    splay(fv1);
                    val[fu1]=dfs(fu1,fv1);
                    fa[fu1]=0;
                    ch[fu1][0]=ch[fu1][1]=0;
                    pushup(fu1);
                }
            }
        }else if(op==2){
            splay(fu1=find(u,1));
            val[fu1]-=a[u];
            a[u]=v;
            val[fu1]+=a[u];
            pushup(fu1);
        }else{
            if(find(u,0)!=find(v,0)){
                puts("-1");
                continue;
            }
            fu1=find(u,1),fv1=find(v,1);
            makeroot(fu1);
            access(fv1);
            splay(fv1);
            printf("%d\n",sumv[fv1]);
        }
    }
    return 0;
}

T10 bzoj2594

#include<cstdio>
#include<algorithm>
#include<set>
using namespace std;
inline int rd(){
    char ch=getchar();
    int ret=0,f=1;
    while(ch<'0'||ch>'9'){
        if(ch=='-'){
            f=-1;
        }
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        ret=ret*10+ch-'0';
        ch=getchar();
    }
    return ret*f;
}
const int N=100005,M=1000005;
int n,m,tot,cnt,q,u,v,L[N],R[N],pa[N];
int head[N+M],to[4*N],nxt[4*N];
int fa[N+M],ch[N+M][2],rev[N+M],val[N+M],maxn[N+M],stk[N+M];
int find(int u){
    return u==pa[u]?u:pa[u]=find(pa[u]);
}
struct edge{
    int u,v,d,id;
    bool flag;
}e1[M],e2[M];
struct operation{
    int op,u,v,ans;
}op[N];
bool cmp1(edge a,edge b){
    return a.u==b.u?a.v<b.v:a.u<b.u;
}
bool cmp2(edge a,edge b){
    return a.d<b.d;
}
void adde(int u,int v){
    to[++cnt]=v;
    nxt[cnt]=head[u];
    head[u]=cnt;
}
void dfs(int u){
    int v;
    for(int i=head[u];i;i=nxt[i]){
        v=to[i];
        if(v!=fa[u]){
            fa[v]=u;
            dfs(v);
        }
    }
}
int find(int u,int v){
    int l=L[u],r=R[u],mid;
    while(l<=r){
        mid=(l+r)/2;
        if(e1[mid].v<v){
            l=mid+1;
        }else if(e1[mid].v>v){
            r=mid-1;
        }else{
            return mid;
        }
    }
}
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    if(u>n){
        maxn[u]=u-n;
    }else{
        maxn[u]=0;
    }
    if(e1[maxn[ch[u][0]]].d>e1[maxn[u]].d){
        maxn[u]=maxn[ch[u][0]];
    }
    if(e1[maxn[ch[u][1]]].d>e1[maxn[u]].d){
        maxn[u]=maxn[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
}
void pushdown(int u){
    stk[stk[0]=1]=u;
    for(;!isroot(u);u=fa[u]){
        stk[++stk[0]]=fa[u];
    }
    while(stk[0]){
        downtag(stk[stk[0]--]);
    }
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
int main(){
    n=rd(),m=rd(),q=rd();
    for(int i=1;i<=m;i++){
        e1[i].u=rd(),e1[i].v=rd(),e1[i].d=rd();
        if(e1[i].u>e1[i].v){
            e1[i].u^=e1[i].v;
            e1[i].v^=e1[i].u;
            e1[i].u^=e1[i].v;
        }
    }
    sort(e1+1,e1+m+1,cmp1);
    for(int i=1;i<=m;i++){
        e1[i].id=i;
        maxn[i+n]=i;
    }
    L[1]=1;
    R[n]=m;
    for(int i=2;i<=m;i++){
        if(e1[i].u!=e1[i-1].u){
            L[e1[i].u]=i;
            R[e1[i-1].u]=i-1;
        }
    }
    for(int i=1;i<=q;i++){
        op[i].op=rd(),op[i].u=rd(),op[i].v=rd();
        if(op[i].op==2){
            if(op[i].u>op[i].v){
                op[i].u^=op[i].v;
                op[i].v^=op[i].u;
                op[i].u^=op[i].v;
            }
            u=find(op[i].u,op[i].v);
            e1[u].flag=true;
        }
    }
    for(int i=1;i<=m;i++){
        if(!e1[i].flag){
            e2[++tot]=e1[i];
        }
    }
    sort(e2+1,e2+tot+1,cmp2);
    for(int i=1;i<=n;i++){
        pa[i]=i;
    }
    for(int i=1,j=0;i<=tot&&j!=n-1;i++){
        u=find(e2[i].u),v=find(e2[i].v);
        if(u!=v){
            j++;
            pa[v]=u;
            adde(e2[i].u,e2[i].id+n);
            adde(e2[i].id+n,e2[i].u);
            adde(e2[i].v,e2[i].id+n);
            adde(e2[i].id+n,e2[i].v);
        }
    }
    dfs(1);
    for(int i=q;i>=1;i--){
        if(op[i].op==1){
            makeroot(op[i].u);
            access(op[i].v);
            splay(op[i].v);
            op[i].ans=e1[maxn[op[i].v]].d;
        }else{
            makeroot(op[i].u);
            access(op[i].v);
            splay(op[i].v);
            u=maxn[op[i].v],v=find(op[i].u,op[i].v);
            if(e1[u].d>e1[v].d){
                cut(e1[u].u,u+n);
                cut(u+n,e1[u].v);
                link(e1[v].u,v+n);
                link(v+n,e1[v].v);
            }
        }
    }
    for(int i=1;i<=q;i++){
        if(op[i].op==1){
            printf("%d\n",op[i].ans);
        }
    }
    return 0;
}

T11 uva11994
各种乱搞之后终于过了！仍然把边变成点。
其实我的代码判断祖孙关系非常暴力，可以被卡。暂时没想到怎么在动态树中快速判断祖孙关系==

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=50005;
int n,m,op,u,v,c,cnt,ans,pa[N],rt[N];
int fa[N*2],ch[N*2][2],rev[N*2],tag[N*2],sumv[N*2],siz[N*2],val[N*2],stk[N*2]; 
int head[N*2],to[N*4],nxt[N*4];
void adde(int u,int v){
    to[++cnt]=v;
    nxt[cnt]=head[u];
    head[u]=cnt;
}
void dfs(int u){
    int v;
    for(int i=head[u];i;i=nxt[i]){
        v=to[i];
        if(v!=fa[u]){
            fa[v]=u;
            dfs(v);
        }
    }
}
bool isroot(int u){
    return ch[fa[u]][0]!=u&&ch[fa[u]][1]!=u;
}
int which(int u){
    return u==ch[fa[u]][1];
}
void pushup(int u){
    sumv[u]=1<<val[u];
    siz[u]=1;
    if(ch[u][0]){
        sumv[u]|=sumv[ch[u][0]];
        siz[u]+=siz[ch[u][0]];
    }
    if(ch[u][1]){
        sumv[u]|=sumv[ch[u][1]];
        siz[u]+=siz[ch[u][1]];
    }
}
void reverse(int u){
    rev[u]^=1;
    swap(ch[u][0],ch[u][1]);
}
void maintain(int u,int c){
    tag[u]=c;
    sumv[u]=1<<c;
    if(u>n){
        val[u]=c;
    }
}
void downtag(int u){
    if(rev[u]){
        if(ch[u][0]){
            reverse(ch[u][0]);
        }
        if(ch[u][1]){
            reverse(ch[u][1]);
        }
        rev[u]=0;
    }
    if(tag[u]){
        if(ch[u][0]){
            maintain(ch[u][0],tag[u]);
        }
        if(ch[u][1]){
            maintain(ch[u][1],tag[u]);
        }
        tag[u]=0;
    }
}
void pushdown(int u){
    stk[stk[0]=1]=u;
    for(;!isroot(u);u=fa[u]){
        stk[++stk[0]]=fa[u];
    }
    while(stk[0]){
        downtag(stk[stk[0]--]);
    }
}
void rotate(int x){
    int y=fa[x],z=fa[y],md=which(x);
    if(!isroot(y)){
        ch[z][which(y)]=x;
    }
    fa[x]=z;
    ch[y][md]=ch[x][!md];
    fa[ch[y][md]]=y;
    ch[x][!md]=y;
    fa[y]=x;
    pushup(y);
    pushup(x);
}
void splay(int u){
    pushdown(u);
    while(!isroot(u)){
        if(!isroot(fa[u])){
            rotate(which(fa[u])==which(u)?fa[u]:u);
        }
        rotate(u);
    }
}
void access(int u){
    for(int v=0;u;v=u,u=fa[u]){
        splay(u);
        ch[u][1]=v;
        pushup(u);
    }
}
void makeroot(int u){
    access(u);
    splay(u);
    reverse(u);
}
void link(int u,int v){
    makeroot(u);
    fa[u]=v;
}
void cut(int u,int v){
    makeroot(u);
    access(v);
    splay(v);
    fa[u]=ch[v][0]=0;
    pushup(v);
}
bool judge(int u,int v){
    while(v){
        if(u==v){
            return false;
        }
        v=pa[v];
    }
    return true;
}
bool isconnect(int u,int v){
    if(u==v){
        return true;
    }
    makeroot(u);
    access(v);
    splay(v);
    return fa[u]!=0;
}
int main(){
    while(~scanf("%d%d",&n,&m)){
        memset(fa,0,sizeof(fa));
        memset(ch,0,sizeof(ch));
        memset(rev,0,sizeof(rev));
        memset(tag,0,sizeof(tag));
        memset(sumv,0,sizeof(sumv));
        memset(siz,0,sizeof(siz));
        memset(val,0,sizeof(val));
        memset(head,0,sizeof(head));
        rt[0]=cnt=0;
        for(int i=1;i<=n;i++){
            scanf("%d",&pa[i]);
            if(pa[i]){
                adde(pa[i],i+n);
                adde(i+n,pa[i]);
                adde(i,i+n);
                adde(i+n,i);
            }else{
                rt[++rt[0]]=i;
            }
        }
        for(int i=1;i<=n;i++){
            scanf("%d",&val[i+n]);
            sumv[i+n]=1<<val[i+n];
            siz[i]=siz[i+n]=1;
        }
        for(int i=1;i<=rt[0];i++){
            dfs(rt[i]);
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&op,&u,&v);
            if(op==1){
                scanf("%d",&c);
                if(judge(u,v)){
                    if(pa[u]){
                        cut(pa[u],u+n);
                        cut(u+n,u);
                    }
                    pa[u]=v;
                    link(pa[u],u+n);
                    link(u+n,u);
                    splay(u+n);
                    val[u+n]=c;
                    pushup(u+n);
                }
            }else if(op==2){
                scanf("%d",&c);
                if(u!=v&&isconnect(u,v)){
                    makeroot(u);
                    access(v);
                    splay(v);
                    maintain(v,c);
                }
            }else{
                if(u==v||!isconnect(u,v)){
                    puts("0 0");
                }else{
                    makeroot(u);
                    access(v);
                    splay(v);
                    ans=0;
                    for(int j=1;j<=30;j++){
                        if(sumv[v]&(1<<j)){
                            ans++;
                        }
                    }
                    printf("%d %d\n",(siz[v]-1)/2,ans);
                }
            }
        }
    }
    return 0;
}
ez_2016gdgzoi471
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Link-Cut-Tree 学习笔记
zyf2000
03-27 2704
信仰是与心中的上帝交谈，借此积聚“天上的财富”。
link cut tree(配套代码及题目）
Free Cat~~~ 跳动的喵
08-18 603
1.bzoj 2002 弹飞绵羊 #include #include #include #include #include #include using namespace std; #define MAXN (200000+5) struct LCT{ int fa[MAXN], ch[MAXN][2], size[MAXN]; bool isroot(i
link-cut tree
Tgop_Knight的专栏
03-22 4041
自己简单研究了下动态树，就先来一发博客吧 动态树问题 link cut tree 实现的技巧
【ICPC 2022 澳门站】K题 Link-Cut Tree 题解
hanserdaisuki的博客
04-12 637
题目大意 给定一个包含nnn个点，mmm条边的图，第iii条边的长度是2i2^i2i。 求一条长度最短的环的长度和边的编号，如果没有输出−1-1−1。 题目链接 思路 可以发现，前i−1i-1i−1条边的长度加起来也比第iii条边短。所以我们尽量用前面的边来构成环。 那么如何判断是否存在环呢？我们从第一条一条地往图中加边，同时用并查集记录已经连在一起的点，一旦我们加入一条边时，发现链接的两个点已经在一个并查集中了，那就说明把这条边加进去时，就存在了一条环。我们用拓扑排序找到它即可。 代码 #include
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
Learning Tree-based Deep Model for Recommender Systems
最新发布
10-19
Learning Tree-based Deep Model for Recommender Systems 本文旨在解决大规模 Recommender Systems 中模型计算复杂度的问题。传统的基于模型的方法面临着巨大的计算成本，限制了其在大规模数据集上的应用。为了...
learning-decisiontree
06-04
作业：学习：决策树此作业的目标是为您提供一些实施监督分类器的经验，特别是决策树。 它假设您在之前的作业中已经熟悉 Git 和 Maven。获取作业模板的副本分叉存储库 。 授予您的讲师访问您的 fork 的权限。...
cn-deep-learning-vs-machine-learning-ebook(1).pdf
09-20
cn-deep-learning-vs-machine-learning-ebook(1)
Machine Learning End-to-End guide for Java developers epub
10-16
Machine Learning End-to-End guide for Java developers 英文epub 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除
deep-learning-for-signal-white-paper.pdf
08-15
Deep Learning for Signal Processing with MATLAB。Deep learning networks have been used for image classification for many years, but they are powerful tools for signal data as well. A deep learning ...
浅谈Link-Cut-Tree（[林可砍树]LCT动态树）附例题 Hdu4010
Monica
07-19 1027
其实一直对LCT很好奇，到底是个什么数据结构可以搞这么多东西，还可以动态地维护，支持加边，合并树，查询等操作，比链剖要强大很多 学过链剖的同学应该可以很快地理解LCT的思路，LCT的实现需要构造辅助树，我们通常选用splay，因为splay方便的序列操作使得LCT的实现显得得心应手，尤其是在换根的时候，只需要splay树上打上一个标记即可那么LCT到底可以干什么呢？我们来浅显地介绍这样一个神奇的数据
【用皇宫三十六计生存法则带你走进LCT(动态树)】LCT概念+模板+例题【洛谷P3690 Link Cut Tree（动态树）】
01-11 762
这样学知识那可太好玩了
LintCode 解题记录 17.5.8 (tag:二叉树)
每天完成一个小目标
05-09 549
今天主要做了一下tag二叉树的题目，题目量很大，主要是Easy的难度，现在整理一下这些题目的知识点。 还有线段树的专题没有做，以后做了之后补充。（有些题目之前做过了就不写了，主要整理今天做的题目） LintCode 67.二叉树的中序遍历 基础题。掌握 递归与非递归两种方式，其中非递归方式需要用到堆栈。 LintCode 69.二叉树的层次遍历 基础题。层次遍历也就是BFS。但是这道题返回
[编程题] LeetCode上的Tree类型的题目
notHeadache的博客
09-04 1445
继之前做完 回文 动态规划 回溯 BackTracking 的题目之后，我又做了LeetCode上关于树的题目：https://leetcode.com/tag/tree/在做的过程中有些题没有思路，于是便看了 Discuss 或者《Cracking the coding Interview》和算法导论等书籍，下面从 Easy ~ Hard 给出答案：这里二叉树的结构是：/** * Definit
算法学习之：动态树（link-cut-tree）及bzoj3282Tree例题详解
maxtir的博客
09-09 2540
算法学习之：动态树（link-cut-tree，下文简称lct） 前言： 经过大神对lct的各种狂吹之后，作为蒟蒻一只的我就来学习lct了，%了几份博客之后，大概明白了lct是怎么做。发现其实lct好像并没有想想中的那么难。当然lct的最低门槛是splay，其次当然就是树链剖分。当然理论上来说树链剖分不看的话lct其实可学，但是可能光是理解就要好久。所以想学lct的小伙伴们还是先去学学spla
【Leetcode】新手tag刷题笔记-算法简单题
浪里小飞侠的博客
03-26 761
tag分类顺序刷题-算法简单题-python/Java1、两数之和 1、两数之和 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 # 方法一 nums = [3,2,4]; print("输入的列表是：",nums); targe = 6; print("输入的targe是：",targe); for i in r
TagTree 项目总结
KazeHelloWorld的博客
04-08 1908
TATQA 利用Roberta模型，训练QA系统，我们QA的回答主要分为文段中词语和文段中数字及数字推导出的结果 数据集格式如下： { "table": { "uid": "3ffd9053-a45d-491c-957a-1b2fa0af0570", "table": [ [ "", "2019", "2018", "2017" ], [ "Fixed Price",
[置顶] 灰のNOIP总结
dianning8393的博客
11-20 95
温馨提示：本文附带bgm 没有什么特别想说的，下面也没有精彩的内容，不如听听歌吧 不太想说比赛过程，说了也没有借鉴价值，毕竟每个人都不一样 Noip酱油了，445 数了一下，在jz被14位巨神碾压，在ez被9位巨神碾压，在hf被2巨神碾压 说一下得分情况 D1： T1：100 T2：100 T3： 70 D2： T1：100 T2： 45...
先序+中序恢复二叉树，非递归
椰子的专栏
09-12 4797
二叉树的存储与恢复问题。先，中，后，任意两个序列就能完全确定一个二叉树。恢复该二叉树可用递归函数，先序的第一个节点为根节点，它把中序分成两部分，左部为该根节点的左子树，右边为右子树，因此，可递归的构造出完整的二叉树。 具体的递归实现可参考： http://www.dutor.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值