[SDOI2017]樹點塗色【LCT的Access函數的妙用】
2020-08-10 10:36:22
題目鏈接
有一顆有根樹，1爲根節點，有這樣的操作：我們給從1～x的節點染色成相同且未出現過的顏色，現在我們想知道u到v的簡單路徑上不同顏色的個數、或者u的子樹下到根節點顏色數最多的顏色數是多少？
其實，我一開始沒有往LCT想，但是它非要掛了個標籤，於是開始想了，如果說我們將1號節點預設成根節點，並且是整棵LCT樹上的根節點，那麼，如果一開始將所有的節點看成是獨立的Splay樹上的節點，每棵Splay樹上有且只有一個點。那麼，顏色的個數，實際上就是它到根節點需要Access的次數，並且可以換一種表述的方式，如果Access了一次，那麼它的子樹中的節點（包括它本身）都要減少一個到1號節點的顏色種類數。
所以，我們可以利用LCT的Access操作來進行維護到根節點的顏色個數了，然後操作2、3便可以求得了。
操作1
在跳Access的時候要注意，我們要給原來的右兒子放逐，但是要去除它的貢獻，又因爲它是Splay過的，所以我們需要找到它的深度最淺的節點，也就是在Splay樹上最左兒子的節點；同理，我們加上新的連線節點時候，也是需要對最淺的節點來對子樹來更新的。
操作2
![ans = col[u] + col[v] - 2 * col[lca(u, v)] + 1](https://s3.ap-northeast-1.wasabisys.com/img.tw511.com/202008/gifr4pq3bdbss2.gif)
（+1是因爲lca節點被多減去了一次）；
操作3
![ans = query(dfn[u], dfn[u] + size[u] - 1)](https://s3.ap-northeast-1.wasabisys.com/img.tw511.com/202008/gif31dtfrvwt0v.gif)
查詢子樹資訊即可。
Code
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, M, Q;
namespace Segement
{
int tree[maxN << 2], lazy[maxN << 2];
void pushdown(int rt)
{
if(lazy[rt])
{
tree[lsn] += lazy[rt];
tree[rsn] += lazy[rt];
lazy[lsn] += lazy[rt];
lazy[rsn] += lazy[rt];
lazy[rt] = 0;
}
}
void pushup(int rt)
{
tree[rt] = max(tree[lsn], tree[rsn]);
}
void update(int rt, int l, int r, int ql, int qr, int val)
{
if(ql <= l && qr >= r)
{
tree[rt] += val;
lazy[rt] += val;
return;
}
pushdown(rt);
int mid = HalF;
if(qr <= mid) update(QL, val);
else if(ql > mid) update(QR, val);
else { update(QL, val); update(QR, val); }
pushup(rt);
}
int query(int rt, int l, int r, int qx)
{
if(l == r) return tree[rt];
pushdown(rt);
int mid = HalF;
if(qx <= mid) return query(Lson, qx);
else return query(Rson, qx);
}
int query_Range(int rt, int l, int r, int ql, int qr)
{
if(ql <= l && qr >= r) return tree[rt];
pushdown(rt);
int mid = HalF;
if(qr <= mid) return query_Range(QL);
else if(ql > mid) return query_Range(QR);
else return max(query_Range(QL), query_Range(QR));
}
}
using namespace Segement;
int dfn[maxN], tot, end_tim[maxN];
namespace LCT
{
int fa[maxN], c[maxN][2];
int r[maxN];
bool isroot(int x) { return c[fa[x]][0] != x && c[fa[x]][1] != x; }
void pushup(int x)
{
}
void pushr(int x) { swap(c[x][0], c[x][1]); r[x] ^= 1; }
void pushdown(int x)
{
if(r[x])
{
if(c[x][0]) pushr(c[x][0]);
if(c[x][1]) pushr(c[x][1]);
r[x] = 0;
}
}
void Rotate(int x)
{
int y = fa[x], z = fa[y], k = c[y][1] == x;
if(!isroot(y)) c[z][c[z][1] == y] = x;
fa[x] = z;
c[y][k] = c[x][k ^ 1];
fa[c[x][k ^ 1]] = y;
c[x][k ^ 1] = y;
fa[y] = x;
pushup(y);
pushup(x);
}
int Stap[maxN];
void Splay(int x)
{
int y = x, z = 0;
Stap[++z] = y;
while(!isroot(y)) Stap[++z] = y = fa[y];
while(z) pushdown(Stap[z--]);
while(!isroot(x))
{
y = fa[x]; z = fa[y];
if(!isroot(y)) (c[z][0] == y) ^ (c[y][0] == x) ? Rotate(x) : Rotate(y);
Rotate(x);
}
}
int findroot(int x);
void Access(int x)
{
int y = 0, z;
while(x)
{
Splay(x);
if(c[x][1])
{
z = c[x][1];
while(c[z][0])
{
z = c[z][0];
}
update(1, 1, N, dfn[z], end_tim[z], 1);
}
c[x][1] = y;
if(y)
{
z = y;
while(c[z][0])
{
z = c[z][0];
}
update(1, 1, N, dfn[z], end_tim[z], -1);
}
pushup(x);
y = x;
x = fa[x];
}
}
void makeroot(int x)
{
Access(x);
Splay(x);
pushr(x);
}
int findroot(int x)
{
Access(x);
Splay(x);
while(c[x][0])
{
pushdown(x);
x = c[x][0];
}
Splay(x);
return x;
}
void Split(int x, int y)
{
makeroot(x);
Access(y);
Splay(y);
}
void link(int x, int y)
{
makeroot(x);
if(findroot(y) != x)
{
fa[x] = y;
pushup(y);
}
}
void cut(int x, int y)
{
makeroot(x);
if(findroot(y) != x || fa[y] != x || c[y][0]) return;
fa[y] = c[x][1] = 0;
pushup(x);
}
};
using namespace LCT;
namespace Graph
{
int head[maxN], cnt;
struct Eddge
{
int nex, to;
Eddge(int a=-1, int b=0):nex(a), to(b) {}
} edge[maxN << 1];
inline void addEddge(int u, int v)
{
edge[cnt] = Eddge(head[u], v);
head[u] = cnt++;
}
inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
inline void init()
{
cnt = 0;
for(int i=1; i<=N; i++) head[i] = -1;
}
};
using namespace Graph;
int root[maxN][20] = {0}, deep[maxN];
void dfs(int u, int father)
{
fa[u] = father; root[u][0] = father; deep[u] = deep[father] + 1;
dfn[u] = ++tot;
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
if(v == father) continue;
dfs(v, u);
}
end_tim[u] = tot;
update(1, 1, N, dfn[u], end_tim[u], 1);
}
void Init_LCA()
{
for(int j=1; (1 << j) < N; j++)
{
for(int i=1; i<=N; i++)
{
root[i][j] = root[root[i][j - 1]][j - 1];
}
}
}
int _LCA(int u, int v)
{
if(deep[u] < deep[v]) swap(u, v);
int det = deep[u] - deep[v];
for(int i=log2(det); i>=0; i--)
{
if((det >> i) & 1)
{
u = root[u][i];
}
}
if(u == v) return u;
for(int i=log2(N); i>=0; i--)
{
if(root[u][i] ^ root[v][i])
{
u = root[u][i];
v = root[v][i];
}
}
return root[u][0];
}
int main()
{
scanf("%d%d", &N, &Q);
init();
for(int i=1, u, v; i<N; i++)
{
scanf("%d%d", &u, &v);
_add(u, v);
}
tot = 0;
dfs(1, 0);
Init_LCA();
for(int i=1, op, x, y; i<=Q; i++)
{
scanf("%d%d", &op, &x);
switch (op)
{
case 1:
{
Access(x);
break;
}
case 2:
{
scanf("%d", &y);
int lca = _LCA(x, y);
printf("%d\n", query(1, 1, N, dfn[x]) + query(1, 1, N, dfn[y]) + 1 - 2 * query(1, 1, N, dfn[lca]));
break;
}
default:
{
printf("%d\n", query_Range(1, 1, N, dfn[x], end_tim[x]));
break;
}
}
}
return 0;
}