4811: [Ynoi2017]由乃的OJ

4811: [Ynoi2017]由乃的OJ

Time Limit: 6 Sec   Memory Limit: 256 MB
Submit: 188   Solved: 70
[ Submit][ Status][ Discuss]

Description

由乃正在做她的OJ。现在她在处理OJ上的用户排名问题。OJ上注册了n个用户，编号为1～"，一开始他们按照编号

排名。由乃会按照心情对这些用户做以下四种操作，修改用户的排名和编号：然而由乃心情非常不好，因为Deus天

天问她题。。。因为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所以她还是只能找你帮她做了。。。

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

每次询问包含三个数x,y,z,初始选定一个数v。然后v依次经过从x到y的所有节点，每经过一个点i，v就变成v opti

 xi，所以他想问你，最后到y时，希望得到的值尽可能大，求最大值？给定的初始值v必须是在[0,z]之间。每次修

改包含三个数x,y,z，意思是把x点的操作修改为y，数值改为z

Input

第一行三个数n，m，k。k的意义是每个点上的数，以及询问中的数值z都 <2^k。之后n行

每行两个数x,y表示该点的位运算编号以及数值

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

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

0 <= n , m <= 100000 , k <= 64

Output

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

Sample Input

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

Sample Output

7
1
5

HINT

Source

By 佚名提供

[ Submit][ Status][ Discuss]



在查询答案的时候，不妨从高到低逐位处理

每次枚举这一位填0还是1(要能填)，然后查询这一位填这个数字对答案的贡献

如果填0的贡献大于等于填1的贡献，那么这一位肯定填0

否则贪心地想，这一位填1肯定也是最优的

那么需要支持快速修改和查询一个数字在树上走了一段路后的答案

先对这棵树进行树链剖分操作

每次询问，等于是在线段树上走log个区间(一整段重链单独提出来作一个区间)

那么维护一个二元组(x,y)其中x,y为两个二进制数码，x的第i位表示第i位填0的返回值，y类似

这样合并用位运算就能做到O(1)

剩下都是数据结构的问题了。。。。

#include<iostream>
#include<cstring>
#include<vector>
#include<cstdio>
//#include<ctime>
using namespace std;
 
const int T = 4;
const int M = 17;
const int N = 64;
const int maxn = 1E5 + 10;
typedef unsigned long long u64;
 
int n,m,k,tot,dfs_clock,tp,siz[maxn],Nex[maxn],dfn[maxn],pos[maxn],DP[maxn]
    ,fa[maxn][M],bel[maxn],len[maxn],ft[maxn],lt[maxn],typ[maxn],Name[maxn];
u64 Max,A[maxn],mi[N]; bool Huge[maxn];
 
struct data{
    u64 v0,v1;
    data operator + (const data &B)
    {
        data c;
        c.v0 = (v0 & B.v1) | (~v0 & B.v0);
        c.v1 = (v1 & B.v1) | (~v1 & B.v0);
        return c;
    }
}Left[maxn*T],Right[maxn*T],L[maxn],R[maxn],stk[maxn],s2[maxn],Val[maxn];
 
vector <int> v[maxn];
 
inline u64 Opt(u64 x,u64 y,int com)
{
    return com == 1 ? x & y : (com == 2 ? x | y : x ^ y);
}
 
inline u64 Read()
{
    char ch = getchar(); u64 ret = 0;
    while (ch < '0' || '9' < ch) ch = getchar();
    while ('0' <= ch && ch <= '9')
        ret = ret * (u64)(10) + (u64)(ch - '0'),ch = getchar();
    return ret;
}
 
char s[22];
inline void Print(u64 x)
{
    if (!x) {puts("0"); return;} int len = 0;
    while (x) s[++len] = x % (u64)(10),x /= (u64)(10);
    for (int i = len; i; i--) putchar(s[i] + '0'); puts("");
}
 
inline int Quickfa(int x,int y)
{
    for (int now = 0; y; y >>= 1,now++)
        if (y & 1) x = fa[x][now];
    return x;
}
 
inline int LCA(int p,int q)
{
    if (DP[p] < DP[q]) swap(p,q);
    for (int i = M - 1; i >= 0; i--)
        if (DP[p] - (1 << i) >= DP[q]) p = fa[p][i];
    if (p == q) return p;
    for (int i = M - 1; i >= 0; i--)
        if (fa[p][i] != fa[q][i]) p = fa[p][i],q = fa[q][i];
    return fa[p][0];
}
 
inline void Dfs1(int x,int from)
{
    int Max = 0; siz[x] = 1;
    for (int i = 1; i < M; i++) fa[x][i] = fa[fa[x][i-1]][i-1];
    for (int i = 0; i < v[x].size(); i++)
    {
        int to = v[x][i]; if (to == from) continue;
        fa[to][0] = x; DP[to] = DP[x] + 1; Dfs1(to,x);
        siz[x] += siz[to]; if (siz[to] > Max) Max = siz[to],Nex[x] = to;
    }
}
 
inline void Dfs2(int x,int from)
{
    dfn[x] = ++dfs_clock; Name[dfs_clock] = x;
    if (Nex[x])
    {
        int to = Nex[x]; Huge[to] = 1;
        if (Huge[x]) bel[to] = bel[x],pos[to] = pos[x] + 1;
        else pos[to] = 1,bel[to] = ++tot,ft[bel[to]] = dfs_clock + 1;
        Dfs2(to,x);
    }
    else if (Huge[x]) lt[bel[x]] = dfn[x],len[bel[x]] = pos[x];
    for (int i = 0; i < v[x].size(); i++)
    {
        int to = v[x][i];
        if (to == from || to == Nex[x]) continue;
        Dfs2(to,x);
    }
}
 
inline void Build(int o,int l,int r)
{
    if (l == r)
    {
        Left[o] = Right[o] = Val[Name[l]]; return;
    }
    int mid = l + r >> 1;
    Build(o<<1,l,mid); Build(o<<1|1,mid+1,r);
    Left[o] = Left[o<<1] + Left[o<<1|1];
    Right[o] = Right[o<<1|1] + Right[o<<1];
}
 
inline void Search_Left(int o,int l,int r,int ql,int qr)
{
    if (ql <= l && r <= qr)
    {
        stk[++tp] = Left[o]; return;
    }
    int mid = l + r >> 1;
    if (ql <= mid) Search_Left(o<<1,l,mid,ql,qr);
    if (qr > mid) Search_Left(o<<1|1,mid+1,r,ql,qr);
}
 
inline void Search_Right(int o,int l,int r,int ql,int qr)
{
    if (ql <= l && r <= qr)
    {
        stk[++tp] = Right[o]; return;
    }
    int mid = l + r >> 1;
    if (ql <= mid) Search_Right(o<<1,l,mid,ql,qr);
    if (qr > mid) Search_Right(o<<1|1,mid+1,r,ql,qr);
}
 
inline data Query_Left(int l,int r)
{
    tp = 0; Search_Left(1,1,n,l,r);
    data ret; ret.v0 = 0; ret.v1 = Max;
    for (int i = 1; i <= tp; i++) ret = ret + stk[i]; return ret;
}
 
inline data Query_Right(int l,int r)
{
    tp = 0; Search_Right(1,1,n,l,r);
    data ret; ret.v0 = 0; ret.v1 = Max;
    for (int i = tp; i > 0; i--) ret = ret + stk[i]; return ret;
}
 
inline void Modify(int o,int l,int r,int pos)
{
    if (l == r)
    {
        Left[o] = Right[o] = Val[Name[l]]; return;
    }
    int mid = l + r >> 1;
    if (pos <= mid) Modify(o<<1,l,mid,pos);
    else Modify(o<<1|1,mid+1,r,pos);
    Left[o] = Left[o<<1] + Left[o<<1|1];
    Right[o] = Right[o<<1|1] + Right[o<<1];
}
 
inline data Walk_Left(int x,int y)
{
    int TP = 0; data ret; ret.v0 = 0; ret.v1 = Max;
    for (; DP[x] >= DP[y]; x = fa[x][0])
        if (!Huge[x]) s2[++TP] = Val[x];
        else
        {
            if (dfn[x] == lt[bel[x]] && DP[Name[ft[bel[x]]]] >= DP[y])
                s2[++TP] = L[bel[x]],x = Quickfa(x,pos[x] - 1);
            else
            {
                if (DP[x] - pos[x] + 1 >= DP[y])
                {
                    s2[++TP] = Query_Left(dfn[x] - pos[x] + 1,dfn[x]);
                    x = Quickfa(x,pos[x] - 1);
                }
                else s2[++TP] = Query_Left(dfn[y],dfn[x]),x = y;
            }
        }
    for (int i = TP; i > 0; i--) ret = ret + s2[i]; return ret;
}
 
inline data Walk_Right(int x,int y)
{
    int TP = 0; data ret; ret.v0 = 0; ret.v1 = Max;
    for (; DP[x] >= DP[y]; x = fa[x][0])
        if (!Huge[x]) s2[++TP] = Val[x];
        else
        {
            if (dfn[x] == lt[bel[x]] && DP[Name[ft[bel[x]]]] >= DP[y])
                s2[++TP] = R[bel[x]],x = Quickfa(x,pos[x] - 1);
            else
            {
                if (DP[x] - pos[x] + 1 >= DP[y])
                {
                    s2[++TP] = Query_Right(dfn[x] - pos[x] + 1,dfn[x]);
                    x = Quickfa(x,pos[x] - 1);
                }
                else s2[++TP] = Query_Right(dfn[y],dfn[x]),x = y;
            }
        }
    for (int i = 1; i <= TP; i++) ret = ret + s2[i]; return ret;
}
 
int main()
{
    #ifdef DMC
        freopen("DMC.txt","r",stdin);
        freopen("t1.txt","w",stdout);
    #endif
     
    n = Read(); m = Read(); k = Read(); Max = mi[0] = 1;
    for (int i = 1; i < k; i++) mi[i] = mi[i - 1] << (u64)(1),Max += mi[i];
    for (int i = 1; i <= n; i++)
    {
        typ[i] = Read(); A[i] = Read();
        Val[i].v0 = Opt(0,A[i],typ[i]);
        Val[i].v1 = Opt(Max,A[i],typ[i]);
    }
    for (int i = 1; i < n; i++)
    {
        int x = Read(),y = Read();
        v[x].push_back(y); v[y].push_back(x);
    }
    DP[1] = 1; Dfs1(1,0); Dfs2(1,0); Build(1,1,n);
    for (int i = 1; i <= tot; i++)
    {
        L[i] = Query_Left(ft[i],lt[i]);
        R[i] = Query_Right(ft[i],lt[i]);
    }
     
    while (m--)
    {
        u64 com = Read(),x,y,z;
        x = Read(); y = Read(); z = Read();
        if (com == 1)
        {
            int lca = LCA(x,y); data now;
            if (lca == x) now = Walk_Left(y,x);
            else if (lca == y) now = Walk_Right(x,y);
            else now = Walk_Right(x,lca) + Walk_Left(y,Quickfa(y,DP[y] - DP[lca] - 1));
             
            u64 Ans,sum; Ans = sum = 0;
            for (int i = k - 1; i >= 0; i--)
            {
                u64 A,B; B = now.v0 & mi[i];
                A = ((sum | mi[i]) <= z) ? now.v1 & mi[i] : 0;
                if (B >= A) Ans |= B; else Ans |= A,sum |= mi[i];
            }
            Print(Ans);
        }
        else
        {
            typ[x] = y; A[x] = z;
            Val[x].v0 = Opt(0,A[x],typ[x]);
            Val[x].v1 = Opt(Max,A[x],typ[x]);
            Modify(1,1,n,dfn[x]);
            if (Huge[x])
            {
                L[bel[x]] = Query_Left(ft[bel[x]],lt[bel[x]]);
                R[bel[x]] = Query_Right(ft[bel[x]],lt[bel[x]]);
            }
        }
    }
     
    //cerr << (double)(clock()) / CLOCKS_PER_SEC << endl;
    return 0;
}