【刷题】洛谷 P3613 睡觉困难综合征

题目背景

刚立完Flag我就挂了WC和THUWC。。。

时间限制0.5s，空间限制128MB

因为Claris大佬帮助一周目由乃通过了Deus的题，所以一周目的由乃前往二周目世界找雪辉去了

由于二周目世界被破坏殆尽，所以由乃和雪辉天天都忙着重建世界（其实和MC差不多吧），Deus看到了题问她，总是被告知无可奉告

Deus没办法只能去三周目世界问三周目的由乃OI题。。。

三周目的世界中，因为没有未来日记，所以一切都很正常，由乃天天认真学习。。。

因为Deus天天问由乃OI题，所以由乃去学习了一下OI

由于由乃智商挺高，所以OI学的特别熟练

她在RBOI2016中以第一名的成绩进入省队，参加了NOI2016获得了金牌保送

Deus：这个题怎么做呀？

yuno：这个不是NOI2014的水题吗。。。

Deus：那如果出到树上，多组链询问，带修改呢？

yuno：诶。。。？？？

Deus：这题叫做睡觉困难综合征哟~

虽然由乃OI很好，但是她基本上不会DS，线段树都只会口胡，比如她NOI2016的分数就是100+100+100+0+100+100。。。NOIP2017的分数是100+0+100+100+0+100

所以她还是只能找你帮她做了。。。

题目描述

由乃这个问题越想越迷糊，已经达到了废寝忘食的地步。结果她发现……晚上睡不着了！只能把自己的一个神经元（我们可以抽象成一个树形结构）拿出来，交给Deus。

这个神经元是一个有n个点的树，每个点的包括一个位运算opt和一个权值x，位运算有&,l,^三种，分别用1,2,3表示。

为了治疗失眠，Deus可以将一些神经递质放在点x上，初始的刺激值是v_0v0​ 。然后v依次经过从x到y的所有节点，每经过一个点i，v就变成v opti xi，所以他想问你，最后到y时，希望得到的刺激值尽可能大，所以最大值的v可以是多少呢？当然由于初始的神经递质的量有限，所以给定的初始值v_0v0​ 必须是在[0,z]之间。Deus每次都会给你3个数，x,y,z。

不过，Deus为了提升治疗效果，可能会对一些神经节点进行微调。在这种情况下，也会给三个数x，y，z，意思是把x点的操作修改为y，数值改为z

输入输出格式

输入格式：

第一行三个数n，m，k。k的意义是每个点上的数，以及询问中的数值z都 <2^k<2k 。之后n行，每行两个数x,y表示该点的位运算编号以及数值

之后n - 1行，每行两个数x,y表示x和y之间有边相连

之后m行，每行四个数，Q,x,y,z表示这次操作为Q(1位询问，2为更改)，x，y，z意义如题所述

输出格式：

对于每个操作1，输出到最后可以造成的最大刺激度v

输入输出样例

输入样例#1：

5 5 3
1 7
2 6
3 7
3 6
3 1
1 2
2 3
3 4
1 5
1 1 4 7
1 1 3 5
2 1 1 3
2 3 3 3
1 1 3 2

输出样例#1：

7
1
5

输入样例#2：

2 2 2
2 2
2 2
1 2
2 2 2 2
1 2 2 2

输出样例#2：

3

说明

对于30%的数据，n，m <= 1

对于另外20%的数据，k <= 5

对于另外20%的数据，位运算只会出现一种

对于100%的数据，0 <= n , m <= 100000 , k <= 64

题解

题目是起床困难综合症的升级版（症 or 征？）

采取同样的贪心策略，如果知道全0或全1跑完一遍运算后的结果，就可以知道最后答案

问题就在于怎么维护这个全0或全1跑完一遍的结果

这东西要动态修改，又是树状的，那就LCT吧（树剖）

首先看一下直接维护我们要的东西可不可以，所以对于一个节点，维护 \(r0\) ，\(r1\) 分别代表全0跑过这个节点包含的一段运算的结果，以及全1跑完这一段运算的结果

pushup怎么写？

\(x_{r0}=(\thicksim lc(x)_{r0}\&rc(x)_{r0})|(lc(x)_{r0}\&rc(x)_{r1})\)

\(x_{r1}=(\thicksim lc(x)_{r1}\&rc(x)_{r0})|(lc(x)_{r1}\&rc(x)_{r1})\)

（当然还要加上自己的权值，但是由于加上自己的有点麻烦，所以只写了左右的，大概就是这个意思，心领神会就行，加上自己权值的可见代码）

什么意思？

以第一个式子为例子，\(x_{r0}\) 是以全0开始的，那么左边的一段肯定是以全0开始的，所以两个都是 \(lc(x)_{r0}\)，然后分情况

跑完左边一段后，有的位置上是0，而有的位置上是1

那么是0的位置，最后的结果，肯定是用0跑完右边一段的运算，所以只有跑完左边一段后值为0的位置才可以留下右边用全0跑完的结果

而是1的位置，就只能留下右边用全1跑完的结果

第二个式子类似

又因为题目的位运算是有序的，那么reverse的时候就行不通了，所以每个节点都还要维护一个反向运算的结果，reverse的时候正向的和反向的swap一下就好了

然后这个东西，每次询问就只要拉链一下，贪心就可以了

#include<bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define db double
#define ld long double
#define ull unsigned long long
const int MAXN=100000+10;
int n,m,k;
struct data{
    ull r0,r1;
    inline data operator + (const data &A) const {
        data B;
        B.r0=(~r0&A.r0)|(r0&A.r1);
        B.r1=(~r1&A.r0)|(r1&A.r1);
        return B;
    };
};
#define lc(x) ch[(x)][0]
#define rc(x) ch[(x)][1]
struct LCT{
    int ch[MAXN][2],fa[MAXN],rev[MAXN],stack[MAXN],cnt;
    data f[MAXN],fR[MAXN],val[MAXN];
    inline bool nroot(int x)
    {
        return lc(fa[x])==x||rc(fa[x])==x;
    }
    inline void reverse(int x)
    {
        std::swap(lc(x),rc(x));
        std::swap(f[x],fR[x]);
        rev[x]^=1;
    }
    inline void pushup(int x)
    {
        f[x]=fR[x]=val[x];
        if(lc(x))f[x]=f[lc(x)]+f[x],fR[x]=fR[x]+fR[lc(x)];
        if(rc(x))f[x]=f[x]+f[rc(x)],fR[x]=fR[rc(x)]+fR[x];
    }
    inline void pushdown(int x)
    {
        if(rev[x])
        {
            if(lc(x))reverse(lc(x));
            if(rc(x))reverse(rc(x));
            rev[x]=0;
        }
    }
    inline void rotate(int x)
    {
        int f=fa[x],p=fa[f],c=(rc(f)==x);
        if(nroot(f))ch[p][rc(p)==f]=x;
        fa[ch[f][c]=ch[x][c^1]]=f;
        fa[ch[x][c^1]=f]=x;
        fa[x]=p;
        pushup(f);
        pushup(x);
    }
    inline void splay(int x)
    {
        cnt=0;
        stack[++cnt]=x;
        for(register int i=x;nroot(i);i=fa[i])stack[++cnt]=fa[i];
        while(cnt)pushdown(stack[cnt--]);
        for(register int y=fa[x];nroot(x);rotate(x),y=fa[x])
            if(nroot(y))rotate((lc(y)==x)==(lc(fa[y])==y)?y:x);
        pushup(x);
    }
    inline void access(int x)
    {
        for(register int y=0;x;x=fa[y=x])splay(x),rc(x)=y,pushup(x);
    }
    inline void makeroot(int x)
    {
        access(x);splay(x);reverse(x);
    }
    inline void split(int x,int y)
    {
        makeroot(x);access(y);splay(y);
    }
    inline void link(int x,int y)
    {
        makeroot(x);fa[x]=y;
    }
};
LCT T;
#undef lc
#undef rc
template<typename T> inline void read(T &x)
{
    T data=0,w=1;
    char ch=0;
    while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
    if(ch=='-')w=-1,ch=getchar();
    while(ch>='0'&&ch<='9')data=((T)data<<3)+((T)data<<1)+(ch^'0'),ch=getchar();
    x=data*w;
}
template<typename T> inline void write(T x,char c='\0')
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)write(x/10);
    putchar(x%10+'0');
    if(c!='\0')putchar(c);
}
template<typename T> inline void chkmin(T &x,T y){x=(y<x?y:x);}
template<typename T> inline void chkmax(T &x,T y){x=(y>x?y:x);}
template<typename T> inline T min(T x,T y){return x<y?x:y;}
template<typename T> inline T max(T x,T y){return x>y?x:y;}
int main()
{
    read(n);read(m);read(k);
    for(register int i=1;i<=n;++i)
    {
        int opt;
        ull x;
        read(opt);read(x);
        if(opt==1)T.val[i].r0=0,T.val[i].r1=x;
        if(opt==2)T.val[i].r0=x,T.val[i].r1=~0;
        if(opt==3)T.val[i].r0=x,T.val[i].r1=~x;
    }
    for(register int i=1;i<n;++i)
    {
        int u,v;
        read(u);read(v);
        T.link(u,v);
    }
    while(m--)
    {
        ull Q,x,y,z;
        read(Q);read(x);read(y);read(z);
        if(Q==1)
        {
            T.split(x,y);
            ull res=0,res0=T.f[y].r0,res1=T.f[y].r1,e=1;
            for(register int i=63;i>=0;--i)
                if(res0&(e<<i))res|=(e<<i);
                else if((res1&(e<<i))&&(e<<i)<=z)res|=(e<<i),z-=(e<<i);
            write(res,'\n');
        }
        if(Q==2)
        {
            T.access(x);T.splay(x);
            if(y==1)T.val[x].r0=0,T.val[x].r1=z;
            if(y==2)T.val[x].r0=z,T.val[x].r1=~0;
            if(y==3)T.val[x].r0=z,T.val[x].r1=~z;
            T.pushup(x);
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/hongyj/p/8733752.html