CF916E Jamie and Tree
CF916E Jamie and Tree
题意翻译
有一棵n个节点的有根树，标号为1-n，你需要维护以下三种操作
1.给定一个点v，将整颗树的根变为v
2.给定两个点u, v，将lca(u, v)所在的子树都加上x
3.给定一个点v，你需要回答以v所在的子树的权值和
Translated by mangoyang
错误日志： 第一次 \(debug\) 是 \(jump\) 数组第二维开小了； 交了一次错了， 第二次没有特判修改/查询节点等于根的情况； 第三次 \(RE\) 又是数组开销了 。。。空间那么大我倒是把数组卡大点啊啊啊
Solution
树链剖分， 要求换根修改和查询
\(lca(u,v)\) 等于 \(lca(u, v)\ ,lca(u, root)\ ,lca(v, root)\) 里深度最大的点
修改和查询： 分三种情况考虑：
- 操作节点为根节点： 直接操作于整棵树
- 根节点在操作节点子树之外： 直接操作即可
- 根节点位于操作节点子树内： 利用容斥（最好画图看看）。设点 \(son\) 为从根节点到操作节点路径上的倒数第二个点，先整棵树更新， 再将 \(son\) 的子树减去更新值即可
（又或者常数较大的先更新整棵树， 反过来减去操作节点的子树， 再更新操作节点这一个点）
Code
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
typedef long long LL;
using namespace std;
LL RD(){
LL out = 0,flag = 1;char c = getchar();
while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
return flag * out;
}
const LL maxn = 200019,INF = 1e9 + 19;
LL head[maxn],nume = 1;
struct Node{
LL v,dis,nxt;
}E[maxn << 2];
void add(LL u,LL v,LL dis){
E[++nume].nxt = head[u];
E[nume].v = v;
E[nume].dis = dis;
head[u] = nume;
}
LL num, na;
LL dep[maxn], size[maxn], fa[maxn], wson[maxn], top[maxn], pos[maxn], ori[maxn], cnt;
LL v[maxn];
void dfs1(LL id, LL F){
size[id] = 1;
for(LL i = head[id];i;i = E[i].nxt){
LL v = E[i].v;
if(v == F)continue;
dep[v] = dep[id] + 1;
fa[v] = id;
dfs1(v, id);
size[id] += size[v];
if(size[v] > size[wson[id]])wson[id] = v;
}
}
void dfs2(LL id, LL TP){
pos[id] = ++cnt;
ori[cnt] = id;
top[id] = TP;
if(!wson[id])return ;
dfs2(wson[id], TP);
for(LL i = head[id];i;i = E[i].nxt){
LL v = E[i].v;
if(v == fa[id] || v == wson[id])continue;
dfs2(v, v);
}
}
#define lid (id << 1)
#define rid (id << 1) | 1
struct seg_tree{
LL l, r;
LL lazy, sum;
}tree[maxn << 2];
void pushup(LL id){tree[id].sum = tree[lid].sum + tree[rid].sum;}
void pushdown(LL id){
if(tree[id].lazy){
LL val = tree[id].lazy;
tree[lid].lazy += val;
tree[rid].lazy += val;
tree[lid].sum += (tree[lid].r - tree[lid].l + 1) * val;
tree[rid].sum += (tree[rid].r - tree[rid].l + 1) * val;
tree[id].lazy = 0;
}
}
void build(LL id, LL l, LL r){
tree[id].l = l, tree[id].r = r;
if(l == r){
tree[id].sum = v[ori[l]];
return ;
}
LL mid = (l + r) >> 1;
build(lid, l, mid), build(rid, mid + 1, r);
pushup(id);
}
void update(LL id, LL val, LL l, LL r){
pushdown(id);
if(tree[id].l == l && tree[id].r == r){
tree[id].sum += (tree[id].r - tree[id].l + 1) * val;
tree[id].lazy += val;
return ;
}
LL mid = (tree[id].l + tree[id].r) >> 1;
if(mid < l)update(rid, val, l, r);
else if(mid >= r)update(lid, val, l, r);
else update(lid, val, l, mid), update(rid, val, mid + 1, r);
pushup(id);
}
LL query(LL id, LL l ,LL r){
pushdown(id);
if(tree[id].l == l && tree[id].r == r){
return tree[id].sum;
}
LL mid = (tree[id].l + tree[id].r) >> 1;
if(mid < l)return query(rid, l, r);
else if(mid >= r)return query(lid, l, r);
else return query(lid, l, mid) + query(rid, mid + 1, r);
}
LL root = 1, jump[maxn][25];
void get_jump(){
for(LL i = 1;i <= num;i++)jump[i][0] = fa[i];
for(LL i = 1;i <= 19;i++){
for(LL j = 1;j <= num;j++){
jump[j][i] = jump[jump[j][i - 1]][i - 1];
}
}
}
LL LCA(LL x, LL y){
if(dep[x] < dep[y])swap(x, y);
for(LL i = 19;i >= 0;i--)if(dep[jump[x][i]] >= dep[y])x = jump[x][i];
if(x == y)return x;
for(LL i = 19;i >= 0;i--)if(jump[x][i] != jump[y][i])x = jump[x][i], y = jump[y][i];
return jump[x][0];
}
LL real_LCA(LL x, LL y){
LL lca1 = LCA(x, y), lca2 = LCA(x, root), lca3 = LCA(y, root);
LL lca = dep[lca1] > dep[lca2] ? lca1 : lca2;
return dep[lca] > dep[lca3] ? lca : lca3;
}
LL son_LCA(LL x, LL y = root){
if(dep[x] >= dep[y])return -1;
for(LL i = 19;i >= 0;i--)if(dep[jump[y][i]] >= dep[x] + 1)y = jump[y][i];
if(fa[y] == x)return y;
return -1;
}
void change_root(){root = RD();}
void uprange(){
LL x = RD(), y = RD(), val = RD();
LL lca = real_LCA(x, y);
if(lca == root){update(1, val, pos[1], pos[1] + size[1] - 1);return ;}
LL son = son_LCA(lca);
if(son == -1){update(1, val, pos[lca], pos[lca] + size[lca] - 1);return ;}
update(1, val, pos[1], pos[1] + size[1] - 1);
update(1,-val, pos[son], pos[son] + size[son] - 1);
}
void get_sum(){
LL x = RD();
if(x == root){printf("%lld\n", query(1, pos[1], pos[1] + size[1] - 1));return ;}
LL son = son_LCA(x);
if(son == -1){printf("%lld\n", query(1, pos[x], pos[x] + size[x] - 1));return ;}
printf("%lld\n", query(1, pos[1], pos[1] + size[1] - 1) - query(1, pos[son], pos[son] + size[son] - 1));
}
int main(){
num = RD();na = RD();
for(LL i = 1;i <= num;i++)v[i] = RD();
for(LL i = 1;i <= num - 1;i++){
LL u = RD(), v = RD();
add(u, v, 1), add(v, u, 1);
}
dep[1] = 1;
dfs1(1, -1), dfs2(1, 1);
build(1, 1, num);
get_jump();
for(LL i = 1;i <= na;i++){
LL cmd = RD();
if(cmd == 1)change_root();
else if(cmd == 2)uprange();
else get_sum();
}
return 0;
}
