bzoj 3159: 决战【LCT】

只是想复健一下LCT没想到做了不得了的题……调了两天QAQ

题解是这么说的:

但是果然还不太理解……因为swap的前后问题调了好久,(所以一开始养成的习惯后面就不要再改啦……

总之大概就是把对位置lct的操作映射到权值lct上,然后权值lct可以随便转没问题,只要位置lct不动就可以……

注意reverse!!

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=50005;
int n,q,root,h[N],cnt;
char c[20];
struct qwe
{
    int ne,to;
}e[N<<1];
int read()
{
    int r=0,f=1;
    char p=getchar();
    while(p>‘9‘||p<‘0‘)
    {
        if(p==‘-‘)
            f=-1;
        p=getchar();
    }
    while(p>=‘0‘&&p<=‘9‘)
    {
        r=r*10+p-48;
        p=getchar();
    }
    return r*f;
}
void add(int u,int v)
{
    cnt++;
    e[cnt].ne=h[u];
    e[cnt].to=v;
    h[u]=cnt;
}
struct val
{
    int c[N][2],f[N],tg[N],si[N];
    long long mn[N],mx[N],sum[N],va[N];
    bool re[N];
    void rev(int x)
    {
        swap(c[x][0],c[x][1]);
        re[x]^=1;
    }
    void init(int x,int v)
    {
        si[x]=1;
        mn[x]=mx[x]=va[x]=sum[x]=v;
    }
    void add(int x,int v)
    {//////cerr<<x<<" "<<v<<endl;
        if(x)
        {
            sum[x]+=1ll*v*si[x];
            tg[x]+=v;
            mn[x]+=v;
            mx[x]+=v;
            va[x]+=v;
        }
    }
    int fdrt(int x)
    {////cerr<<"fdrt"<<x<<endl;
        while(f[x])
            x=f[x];//cerr<<x<<endl;
        return x;
    }
    void ud(int x)
    {
        si[x]=1,mn[x]=mx[x]=sum[x]=va[x];
        if(c[x][0])
        {
            si[x]+=si[c[x][0]];
            mn[x]=min(mn[x],mn[c[x][0]]);
            mx[x]=max(mx[x],mx[c[x][0]]);
            sum[x]+=sum[c[x][0]];
        }
        if(c[x][1])
        {
            si[x]+=si[c[x][1]];
            mn[x]=min(mn[x],mn[c[x][1]]);
            mx[x]=max(mx[x],mx[c[x][1]]);
            sum[x]+=sum[c[x][1]];
        }
    }
    void pd(int x)
    {
        if(re[x])
        {
            rev(c[x][0]);
            rev(c[x][1]);
            re[x]=0;
        }
        if(tg[x])
        {
            add(c[x][0],tg[x]);
            add(c[x][1],tg[x]);
            tg[x]=0;
        }
    }
    int ppd(int x)
    {
        int anc=srt(x)?x:ppd(f[x]);
        pd(x);
        return anc;
    }
    bool srt(int x)
    {
        return c[f[x]][0]!=x&&c[f[x]][1]!=x;
    }
    void zhuan(int x)
    {
        int y=f[x],z=f[y],l=c[y][0]!=x,r=l^1;
        if(!srt(y))
            c[z][c[z][0]!=y]=x;
        f[x]=z;
        c[y][l]=c[x][r];
        f[c[x][r]]=y;
        c[x][r]=y;
        f[y]=x;
        ud(y);
    }
    void splay(int x)
    {
        ppd(x);
        while(!srt(x))
        {
            int y=f[x],z=f[y];
            if(!srt(y))
            {
                if((c[y][0]==x)^(c[z][0]==y))
                    zhuan(x);
                else
                    zhuan(y);
            }
            zhuan(x);
        }
        ud(x);
    }
    int zhao(int &x,int k)
    {
        while(1)
        {
            pd(x);
            if(k<=si[c[x][0]])
                x=c[x][0];
            else if(k==si[c[x][0]]+1)
                return x;
            else
                k-=(si[c[x][0]]+1),x=c[x][1];
        }
    }
}v;
struct LCT
{
    int si[N],c[N][2],f[N],rt[N];
    bool re[N];
    void rev(int x)
    {
        swap(c[x][0],c[x][1]);
        re[x]^=1;
    }
    void ud(int x)
    {
        si[x]=si[c[x][0]]+si[c[x][1]]+1;
    }
    void pd(int x)
    {
        if(re[x])
        {
            rev(c[x][0]);
            rev(c[x][1]);
            re[x]=0;
        }
    }
    int ppd(int x)
    {
        int anc=srt(x)?x:ppd(f[x]);
        pd(x);
        return anc;
    }
    bool srt(int x)
    {
        return c[f[x]][0]!=x&&c[f[x]][1]!=x;
    }
    void zhuan(int x)
    {
        int y=f[x],z=f[y],l=c[y][0]!=x,r=l^1;
        if(!srt(y))
            c[z][c[z][0]!=y]=x;
        f[x]=z;
        c[y][l]=c[x][r];
        f[c[x][r]]=y;
        c[x][r]=y;
        f[y]=x;
        ud(y);
    }
    void splay(int x)
    {
        rt[x]=rt[ppd(x)];
        while(!srt(x))
        {////cerr<<x<<endl;
            int y=f[x],z=f[y];
            if(!srt(y))
            {
                if((c[y][0]==x)^(c[z][0]==y))
                    zhuan(x);
                else
                    zhuan(y);
            }
            zhuan(x);
        }
        ud(x);
    }
    void acc(int x)
    {////cerr<<"ACC"<<endl;
        for(int y=0;x;y=x,x=f[x])
        {//cerr<<x<<" "<<y<<endl;
            splay(x);//cerr<<"accoksplay"<<endl;
            int x2=v.fdrt(rt[x]),y2=v.fdrt(rt[y]);//cerr<<"accokflrt"<<endl;
            if(!y)
                y2=0;
            v.zhao(x2,si[c[x][0]]+1);
            v.splay(x2);
            rt[x]=x2;
            rt[c[x][1]]=v.c[x2][1];
            v.f[v.c[x2][1]]=0;
            v.c[x2][1]=y2;
            v.f[y2]=x2;
            v.ud(x2);
            c[x][1]=y;
            ud(x);
        }
    }
    void mkrt(int x)
    {
        acc(x);//cerr<<"OKACC"<<endl;
        splay(x);//cerr<<"oksplay"<<endl;
        rev(x);
        v.rev(rt[x]);
    }
    void dfs(int u,int fa)
    {
        rt[u]=u,si[u]=1,f[u]=fa;
        v.init(u,0);
        for(int i=h[u];i;i=e[i].ne)
            if(e[i].to!=fa)
                dfs(e[i].to,u);
    }
}w;
int main()
{
    n=read(),q=read(),root=read();
    for(int i=1;i<n;i++)
    {
        int x=read(),y=read();
        add(x,y);
        add(y,x);
    }
    w.dfs(root,0);
    while(q--)
    {
        scanf("%s",c);
        int x=read(),y=read();//cerr<<"read"<<endl;
        w.mkrt(x);//cerr<<"mkrt"<<endl;
        w.acc(y);//cerr<<"acc"<<endl;
        int vy=v.fdrt(w.rt[y]);
        if(c[2]==‘c‘)
        {
            int z=read();
            v.add(vy,z);
        }
        else if(c[2]==‘m‘)
            printf("%lld\n",v.sum[vy]);
        else if(c[2]==‘j‘)
            printf("%lld\n",v.mx[vy]);
        else if(c[2]==‘n‘)
            printf("%lld\n",v.mn[vy]);
        else
            v.rev(vy);
    }
    return 0;
}
/*
5 8 1
1 2
2 3
3 4
4 5
Sum 2 4
Increase 3 5 3
Minor 1 4
Sum 4 5
Invert 1 3
Major 1 2
Increase 1 5 2
Sum 1 5
*/

原文地址:https://www.cnblogs.com/lokiii/p/8619797.html

时间: 2024-10-12 01:21:44

bzoj 3159: 决战【LCT】的相关文章

BZOJ.3510.首都(LCT 启发式合并 树的重心)

题目链接 BZOJ 洛谷 详见这. 求所有点到某个点距离和最短,即求树的重心.考虑如何动态维护. 两棵子树合并后的重心一定在两棵树的重心之间那条链上,所以在合并的时候用启发式合并,每合并一个点检查sz[]大的那棵子树的重心(记为root)最大子树的sz[] * 2是否>n: 若>n,则向fa移动一次(先把合并点Splay到根).重心还一定是在sz[]大的那棵子树中,且移动次数不会超过sz[]小的子树的点数(所以总移动次数不会超过O(n)?). 复杂度 \(O(nlog^2n)\) 具体实现..

BZOJ 2631: tree( LCT )

LCT...略麻烦... -------------------------------------------------------------------------------- #include<cstdio> #include<algorithm> #include<cstring> #include<iostream> #define rep( i , n ) for( int i = 0 ; i < n ; ++i ) #define

BZOJ 3282: Tree [LCT]

3282: Tree Time Limit: 30 Sec  Memory Limit: 512 MBSubmit: 1677  Solved: 744[Submit][Status][Discuss] Description 给定N个点以及每个点的权值,要你处理接下来的M个操作.操作有4种.操作从0到3编号.点从1到N编号. 0:后接两个整数(x,y),代表询问从x到y的路径上的点的权值的xor和.保证x到y是联通的. 1:后接两个整数(x,y),代表连接x到y,若x到Y已经联通则无需连接.

数据结构&#183;树链剖分+LCT

于是两个一起搞了... 怎么说,写的是P党风格的C++,短也不会短到哪里去,跑起来也不快,常数大成狗OTL BZOJ 1036 树链的经典题吧,点修改+路经询问 [Code] BZOJ 2243 路径修改+路径询问 [Code] BZOJ 3083 路径修改+子树询问(根可变),这道题要用树链剖分求DFS序中某一段区间的值(DFS序可查子树,链剖可修改路径,两者相结合就行了) [Code] BZOJ 2049 用LCT维护森林形态 [Code] BZOJ 2631 路径修改+路径询问+形态可变

[BZOJ 3531] [Sdoi2014] 旅行 【离线+LCT】

题目链接:BZOJ - 3531 题目分析 题目询问一条路径上的信息时,每次询问有某种特定的文化的点. 每个点的文化就相当于一种颜色,每次询问一条路径上某种颜色的点的信息. 可以使用离线算法, 类似于“郁闷的小 J ” 那道题目.将各种操作和询问按照颜色为第一关键字,时间为第二关键字排序. 那么修改颜色的操作就相当于在原颜色中是删点,在新颜色中是加点. 处理完一种颜色的操作后,要将这个颜色的点都做一次删除操作,这样,对于处理下一种颜色,树就又是空的了. 这种题,思考的时候有点晕,写代码的时候非常

[BZOJ 2049] [Sdoi2008] Cave 洞穴勘测 【LCT】

题目链接:BZOJ - 2049 题目分析 LCT的基本模型,包括 Link ,Cut 操作和判断两个点是否在同一棵树内. Link(x, y) : Make_Root(x); Splay(x); Father[x] = y; Cut(x, y) : Make_Root(x); Access(y); 断掉 y 和 Son[y][0]; 注意修改 Son[y][0] 的 isRoot 和 Father 判断 x, y 是否在同一棵数内,我们就看两个点所在树的根是否相同,使用 Find_Root()

bzoj 2631 LCT

/************************************************************** Problem: 2631 User: wangyucheng Language: C++ Result: Accepted Time:18408 ms Memory:9252 kb ****************************************************************/ #include<iostream> #include

[BZOJ 3669] [Noi2014] 魔法森林 【LCT】

题目链接:BZOJ - 3669 题目分析 如果确定了带 x 只精灵A,那么我们就是要找一条 1 到 n 的路径,满足只经过 Ai <= x 的边,而且要使经过的边中最大的 Bi 尽量小. 其实就是一个按照 Bi 建立的 MST 上 1 到 n 的路径.只能使用 Ai <= x 的边. 那么,如果我们从小到大枚举 x ,这样可以使用的边就不断增加,就是在加边的同时维护 MST ,用 LCT 来做就可以了. 如果新加入一条边 (u, v, w) ,并且原 MST 上 u 到 v 的路径中边权最大

[BZOJ 3282] Tree 【LCT】

题目链接:BZOJ - 3282 题目分析 这道题是裸的LCT,包含 Link , Cut 和询问两点之间的路径信息. 写代码时出现的错误:Access(x) 的循环中应该切断的是原来的 Son[x][1] ,然而我写成了 Son[x][0] ! 代码 #include <iostream> #include <cstdlib> #include <cstdio> #include <cstring> #include <cmath> #incl