BZOJ-4811: [Ynoi2017]由乃的OJ (树链剖分 线段树维护区间操作值 好题)

4811: [Ynoi2017]由乃的OJ

Time Limit: 6 Sec  Memory Limit: 256 MB
Submit: 366  Solved: 118

[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

#include <bits/stdc++.h>
using namespace std;
#define maxn 100005
vector<vector<int> >g(maxn);
struct point{
int op;
unsigned long long v;
}a[maxn];
struct tree{
unsigned long long v0, v1;
tree() {};
friend tree operator + (tree x, tree y){    //重载+方便后面合并操作
tree z;
z.v0 = (x.v0 & y.v1) | ((~x.v0) & y.v0);
z.v1 = (x.v1 & y.v1) | ((~x.v1) & y.v0);
return z;
}
tree (int op, unsigned long long v){  //构造函数
if(op == 1){
v0 = 0 & v;
v1 = (~0) & v;
}
if(op == 2){
v0 = 0 | v;
v1 = (~0) | v;
}
if(op == 3){
v0 = 0 ^ v;
v1 = (~0) ^ v;
}
}
}cl[maxn << 2], cr[maxn << 2]; //因为从结点x走到y，链剖后的分段路径会有从上到下和从下到上的区别，这里需要区分
int sz[maxn], id[maxn], dep[maxn], son[maxn], top[maxn],  pre[maxn], val[maxn], tot;
void dfs(int x, int fa, int d){
sz[x] = 1;
pre[x] = fa;
dep[x] = d;
son[x] = 0;
int cur;
for(int i = 0; i < g[x].size(); ++i){
cur = g[x][i];
if(cur == fa) continue;
dfs(cur, x, d + 1);
sz[x] += sz[cur];
if(sz[son[x]] < sz[cur]){
son[x] = cur;
}
}
}
void dfs1(int x, int tp){
id[x] = ++tot;
top[x] = tp;
if(son[x]) dfs1(son[x], tp);
int cur;
for(int i = 0; i < g[x].size(); ++i){
cur = g[x][i];
if(cur == pre[x] || cur == son[x]) continue;
dfs1(cur, cur);
}
}
void build(int o, int l, int r){
if(l == r){
cl[o] = cr[o] = tree(a[val[l]].op, a[val[l]].v);
return;
}
int mid = l + r >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
cl[o] = cl[o << 1] + cl[o << 1 | 1];
cr[o] = cr[o << 1 | 1] + cr[o << 1];   //合并上的区别，值得注意
}
void add(int o, int l, int r, int pos, int op, unsigned long long z){
if(l == r){
cl[o] = cr[o] = tree(op, z);
return;
}
int mid = l + r >> 1;
if(pos <= mid) add(o << 1, l, mid, pos, op, z);
else add(o << 1 | 1, mid + 1, r, pos, op, z);
cl[o] = cl[o << 1] + cl[o << 1 | 1];   //注意合并的顺序
cr[o] = cr[o << 1 | 1] + cr[o << 1];
}
tree query(int o, int l, int r, int L, int R, int kind){
if(l >= L && r <= R){
if(kind == 1) return cl[o];
return cr[o];
}
int mid = l + r >> 1;
if(mid >= R) return query(o << 1, l, mid, L, R, kind);
else if(mid < L) return query(o << 1 | 1, mid + 1, r, L, R, kind);
else{
if(kind == 1) return query(o << 1, l, mid, L, R, kind) + query(o << 1 | 1, mid + 1, r, L, R, kind);
else return query(o << 1 | 1, mid + 1, r, L, R, kind) + query(o << 1, l, mid, L, R, kind);    //注意合并的顺序
}
}
unsigned long long getsm(int x, int y, unsigned long long z, int k){
int tp1 = top[x], tp2 = top[y];
tree ansx = tree(3, 0), ansy = tree(3, 0);
while(tp1 != tp2){
if(dep[tp1] < dep[tp2]){
ansy = query(1, 1, tot, id[tp2], id[y], 1) + ansy;   //还是注意顺序。。。。
y = pre[tp2];
tp2 = top[y];
}
else{
ansx = ansx + query(1, 1, tot, id[tp1], id[x], 2);
x = pre[tp1];
tp1 = top[x];
}
}
if(dep[x] < dep[y]){
ansx = ansx + query(1, 1, tot, id[x], id[y], 1) + ansy;   //注意合并的顺序
}
else{
ansx = ansx + query(1, 1, tot, id[y], id[x], 2) + ansy;
}
unsigned long long res = 0, cost = 0;
for(int i = k - 1; i >= 0; --i){   //这里一定全程unsigned long long！！！！
if((ansx.v0 >> i) & 1ULL * 1){
res |= 1ULL * 1 << i;
}
else if((ansx.v1 >> i) & 1ULL * 1){
if((cost | (1ULL * 1 << i)) <= z){
res |= 1ULL * 1 << i;
cost |= 1ULL * 1 << i;
}
}
}
return res;
}
int main(){
int n, m, k, u, v, q;
unsigned long long z;
scanf("%d %d %d", &n, &m, &k);
for(int i = 1; i <= n; ++i){
scanf("%d %llu", &a[i].op, &a[i].v);
}
for(int i = 1; i < n; ++i){
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
tot = 0;
dfs(1, 0, 1);
dfs1(1, 1);
for(int i = 1; i <= n; ++i){
val[id[i]] = i;
}
build(1, 1, tot);
for(int i = 1; i <= m; ++i){
scanf("%d %d %d %llu", &q, &u, &v, &z);
if(q == 2){
add(1, 1, tot, id[u], v, z);
}
else{
printf("%llu\n", getsm(u, v, z, k));
}
}
}

/*
题意：一棵树，1e5个结点，每个结点一个操作(&,|,^)和一个数值。1e5次操作 ，每次操作要么修改每个结点的操作和
数值，要么询问路径x到y上，在[0,z]中找个数对和每个结点上的数字进行一次该结点上的操作，使得最终答案最大。

思路：一开始想可以直接把操作和数字合并啊，然后直接树链剖分然后线段树维护区间值，然后发现naive了，&,|,^这三个
位运算没办法用一个数搞定，那么就用两个数好了。。。。v0,v1分别状压(这三种位运算是位独立的，位和位互不影响)表示每一位
原本是0经过操作后得到什么，和原本是1经过操作后得到什么。所以操作&和数字可以合并为v0 = 0 & v; v1 = (~0) & v， 其余的类推，然后我们
就不用管操作符了。之后就可以用线段树维护区间的值了，这里我们得讨论合并操作，就是v0在经过x，再经过y后怎么表示。
首先v0在经过x后，有些位变成1了，这个时候我们用v1.y更新这些位，很容易理解吧，即 (x.v0 & y.v1)；还有一些位没有变成0，还
保持着0怎么办，当然用v0.y更新这些位了- -||.即((~x.v0) & y.v0)，x.v0取非的原因是还保持0的那些位直接&的话一定是0，无法体现
y.v0的作用，实际上这里如果单独考虑还是0的位直接用y.v0就好了，但是避免不是0的位的影响，所以用~x.v0，这样非0的变成0，不考虑这些位，
为0的变成1，和y.v0 &，保留y.v0对这些位的贡献。然后 | 一下就好了，合并两者各自位的贡献。

注意：从x到y后操作的先后顺序，这样我们需要区分合并区间的顺序，这个很简单，用两个数组存就好了，合并的时候注意一下。然后由于最大64
位，全程都用unsigned long long!!!WA了多次才意识到。。。。
*/