CF1208 Red Blue Tree
问题分析
这是蒟蒻第一道3500！不过话说luogu上两个题解的程序都是假的可还行（2019.11.1）……
为了方便叙述，下面我们约定 ：
\([c]\) 的值为 \(1\) 当且仅当 \(c\) 为真，反之为 \(0\) 。
\(0\) 表示白色， \(1\) 表示黑色。
\(son_u\) 表示 \(u\) 的所有儿子， \(ls_u\) 表示 \(u\) 的所有轻儿子， \(hs_u\) 表示 \(u\) 的重儿子。 \(m\) 表示 \(u\) 的子节点个数。
那么实际上对于一个特定的 \(k\) ，每个点的颜色 \(C\) 都可以被这样唯一确定：
\[C_u=\left[[C_{son_u}==1]-[C_{son_u}==0]\geqslant k\right]
\]
也可以写成这样子：
\[C_u=[m-2[C_{ls_u}==0]-2[C_{hs_u}==0]-k\geqslant 0]
\]
容易发现当 \(k\) 很小时，\(C\) 一定是 \(1\) ； \(k\) 很大时， \(C\) 一定是 \(0\) 。进一步分析发现，对于每一个点 \(u\) ，总有一个 \(k'\) 满足 \(C_u=0(k\geqslant k')\) 并且 \(C_u=1(k<k')\) 。而如果我们能维护每一个节点 \(u\) 的 \(k'\) （不妨记为 \(A_u\) ），就能简单地处理询问。
考虑 \(A_u\) 的性质：
\[\begin{aligned}
C_u&=[A_u>k]\\
A_u&=\min\{k|m-2[A_{son_u}\leqslant k]-k<0\}
\end{aligned}
\]
由于每次只会改变一个叶子的颜色，那么每个 \(A\) 的值最多变化2。那么可以对每一个 \(A_u\) 的儿子，可以建一个 Binary Search Tree 来解决。每一次改变暴力往前后扫 \(k\) 变了多少。时间复杂度 \(O(n^2)\) 。当然，如果是用脚造的数据，树高很矮的话，就可以过了
（貌似变烦而且变慢了？）
其实到这里应该已经发现是动态DP了。。。
实际上这个做法花了大量的时间转移每一个父亲，那么就可以考虑用动态DP的黑科技来转移：
\[A_u=\min\{k|m-2[A_{ls_u}\leqslant k]-k-2[A_{hs_u}\leqslant k]<0\}
\]
其中前面一部分仍然是在 Binary Search Tree 上解决，后面一部分我们需要去掉这个 \([]\) 运算。（感觉思维难点就在这里。。。）
令 \(T_0\) 表示当前这条链顶为白色，且链底的重儿子为白色所需最小的 \(k\) ； \(T_1\) 表示当前这条链顶为白色，且链底的重儿子为黑色所需要最小的 \(k\) 。
这样一来，重链上的转移就满足结合律了：
现在需要从链 \(B\) 转移到链 \(A\) ，其中 \(B\) 链顶的父亲是 \(A\) 链底。那么有
\[T_0 = \min\{\max\{A_0, B_0\}, A_1\}\\ T_1 = \min\{\max\{A_0, B_1\}, A_1\} \]而最后的答案就是 \([T_0>k]\) 。（考虑一下，一定有 \(T_0\leqslant T_1\) 。）
参考程序
代码很短的，很好写的，也就几个钟头就写完了。拖个模板，写的丑一点，不删调试信息也就十几k而已
#include <cstdio>
#include <algorithm>
const int INF = 1e7 + 10;
struct node {
int Value, Priority, Size, Count;
node *LeftChild, *RightChild;
node() {
Value = Priority = Size = Count = 0;
LeftChild = RightChild = NULL;
return;
}
node(int _Value) {
Value = _Value;
Priority = rand();
Size = Count = 1;
LeftChild = RightChild = NULL;
return;
}
inline void Update();
};
struct noneRotateTreap {
node *Root;
noneRotateTreap() {
Root = NULL;
return;
}
inline std::pair<node *, node *> Split(node *Rt, int x);
inline node *Merge(node *x, node *y);
inline node *Find(int x);
inline void Update(int x, int State);
inline void Insert(int x);
inline int Delete(int x);
inline int Rank(int x);
inline int Query(int x);
inline int Precursor(int x);
inline int Successor(int x);
void Dfs(node *Rt);
void Debug();
};
inline void node::Update() {
Size = Count;
if (LeftChild != NULL)
Size += LeftChild->Size;
if (RightChild != NULL)
Size += RightChild->Size;
return;
}
inline std::pair<node *, node *> noneRotateTreap::Split(node *Rt, int x) {
if (Rt == NULL)
return std::pair<node *, node *>(NULL, NULL);
if (x < Rt->Value) {
std::pair<node *, node *> Temp = Split(Rt->LeftChild, x);
Rt->LeftChild = Temp.second;
Rt->Update();
return std::pair<node *, node *>(Temp.first, Rt);
} else {
std::pair<node *, node *> Temp = Split(Rt->RightChild, x);
Rt->RightChild = Temp.first;
Rt->Update();
return std::pair<node *, node *>(Rt, Temp.second);
}
}
inline node *noneRotateTreap::Merge(node *l, node *r) {
if (l == NULL) return r;
if (r == NULL) return l;
if (l->Priority <= r->Priority) {
l->RightChild = Merge(l->RightChild, r);
l->Update();
return l;
} else {
r->LeftChild = Merge(l, r->LeftChild);
r->Update();
return r;
}
}
inline node *noneRotateTreap::Find(int x) {
node *Rt = Root;
while (Rt) {
if (Rt->Value == x)
return Rt;
if (x < Rt->Value)
Rt = Rt->LeftChild;
else
Rt = Rt->RightChild;
}
return NULL;
}
inline void noneRotateTreap::Update(int x, int State) {
node *Rt = Root;
while (Rt) {
Rt->Size += State;
if (Rt->Value == x) {
Rt->Count += State;
return;
}
if (x < Rt->Value)
Rt = Rt->LeftChild;
else
Rt = Rt->RightChild;
}
return;
}
inline void noneRotateTreap::Insert(int x) {
node *T = Find(x);
if (T != NULL) {
Update(x, 1);
return;
}
std::pair<node *, node *> Temp = Split(Root, x);
Temp.first = Merge(Temp.first, new node(x));
Root = Merge(Temp.first, Temp.second);
return;
}
inline int noneRotateTreap::Delete(int x) {
node *T = Find(x);
if (T == NULL) return 1;
if (T->Count > 1) {
Update(x, -1);
return 0;
}
std::pair<node *, node *> Temp1 = Split(Root, x - 1);
std::pair<node *, node *> Temp2 = Split(Temp1.second, x);
delete Temp2.first;
Root = Merge(Temp1.first, Temp2.second);
return 0;
}
#define LCS (Rt->LeftChild ? Rt->LeftChild->Size : 0)
inline int noneRotateTreap::Rank(int x) {
node *Rt = Root;
int Ans = 0;
while (Rt) {
if (Rt->Value == x)
return Ans + LCS + 1;
if (x < Rt->Value)
Rt = Rt->LeftChild;
else
Ans += LCS + Rt->Count, Rt = Rt->RightChild;
}
return Ans + 1;
}
inline int noneRotateTreap::Query(int x) {
node *Rt = Root;
while (Rt) {
if (LCS < x && x <= LCS + Rt->Count)
return Rt->Value;
if (x <= LCS)
Rt = Rt->LeftChild;
else
x -= LCS + Rt->Count, Rt = Rt->RightChild;
}
return 0;
}
#undef LCS
inline int noneRotateTreap::Precursor(int x) {
int Ans = INF;
node *Rt = Root;
while (Rt) {
if (Rt->Value < x)
Ans = Rt->Value, Rt = Rt->RightChild;
else
Rt = Rt->LeftChild;
}
return Ans;
}
inline int noneRotateTreap::Successor(int x) {
int Ans = -INF;
node *Rt = Root;
while (Rt) {
if (Rt->Value > x)
Ans = Rt->Value, Rt = Rt->LeftChild;
else
Rt = Rt->RightChild;
}
return Ans;
}
void noneRotateTreap::Debug() {
Dfs(Root);
printf("\n");
return;
}
void noneRotateTreap::Dfs(node *T) {
if (T == NULL) return;
Dfs(T->LeftChild);
for (int i = 1; i <= T->Count; ++i)
printf("%d ", T->Value);
Dfs(T->RightChild);
return;
}
/*========== HEAD TEMPLATE : Binaty Search Tree -> NoneRotateTreap ==========*/
//#define DEBUG
//#define DEBUG_
//#define _DEBUG_
const int Maxn = 200010;
struct edge {
int To, Next;
edge() {}
edge(int _To, int _Next) : To(_To), Next(_Next) {}
};
edge Edge[Maxn << 1];
int Start[Maxn], Used;
int Num, N, Q, Type, C[Maxn], k;
noneRotateTreap NoneRotateTreap[Maxn];
int CountSon[Maxn];
int Size[Maxn], Father[Maxn], Deep[Maxn], Son[Maxn], Top[Maxn], Dfn[Maxn], Ref[Maxn], Bottom[Maxn];
std::pair<int, int> IntervalTree[Maxn << 2];
int TreeSize;
int Record[Maxn];
inline void AddEdge(int x, int y);
inline void CutDfs1(int u, int Fa);
inline void CutDfs2(int u, int Fa);
inline std::pair<int, int> Calc(int x);
inline std::pair<int, int> Merge(std::pair<int, int> x, std::pair<int, int> y);
inline void Update(int Index, int Left, int Right);
inline void BuildIntervalTree(int Index, int Left, int Right);
inline std::pair<int, int> Query(int Index, int Left, int Right, int L, int R);
inline std::pair<int, int> Query(int x);
inline void Modify(int Pos, int &k, int Delta);
inline bool Judge(int Pos, int k, int Delta);
inline void Change(int x, int y);
inline void Modify(int Index, int Left, int Right, int Pos);
int main() {
srand((unsigned long long)"非旋treap呀");
#ifdef DEBUG
NoneRotateTreap[0].Insert(1);
NoneRotateTreap[0].Insert(1);
NoneRotateTreap[0].Insert(3);
printf("%d %d ", NoneRotateTreap[0].Rank(2), NoneRotateTreap[0].Rank(1));
NoneRotateTreap[0].Insert(-INF);
printf("%d\n", NoneRotateTreap[0].Rank(1));
#endif
scanf("%d%d", &N, &k);
for (int i = 1; i < N; ++i) {
int x, y;
scanf("%d%d", &x, &y);
AddEdge(x, y);
AddEdge(y, x);
}
for (int i = 1; i <= N; ++i) scanf("%d", &C[i]);
scanf("%d", &Q);
CutDfs1(1, 0);
Top[1] = 1;
Dfn[1] = ++TreeSize;
Ref[TreeSize] = 1;
CutDfs2(1, 0);
for (int i = 1; i <= N; ++i) Bottom[Top[i]] = std::max(Bottom[Top[i]], Dfn[i]);
#ifdef _DEBUG_
printf("Father : ");
for (int i = 1; i <= N; ++i) printf("%d ", Father[i]); printf("\n");
printf(" Top : ");
for (int i = 1; i <= N; ++i) printf("%d ", Top[i]); printf("\n");
printf(" Dfn : ");
for (int i = 1; i <= N; ++i) printf("%d ", Dfn[i]); printf("\n");
printf("Bottom : ");
for (int i = 1; i <= N; ++i) printf("%d ", Bottom[i]); printf("\n");
#endif
BuildIntervalTree(1, 1, N);
#ifdef _DEBUG_
printf("Check Ans :\n");
for (int i = 1; i <= N; ++i) {
std::pair<int, int> Ans = Query(i);
printf("%d %d %d\n", i, Ans.first, Ans.second);
}
#endif
for (int i = 1; i <= N; ++i)
if (Top[i] == i)
Record[i] = Query(i).first;
for (int i = 1; i <= Q; ++i) {
int Opt, x, y;
scanf("%d", &Opt);
if (Opt == 1) {
scanf("%d", &x);
int Ans = Query(x).first > k ? 1 : 0;
printf("%d\n", Ans);
}
if (Opt == 2) {
scanf("%d%d", &x, &y);
Change(x, y);
}
if (Opt == 3) scanf("%d", &k);
#ifdef _DEBUG_
printf("After Opt %d (%d-th) :\n", Opt, i);
for (int j = 1; j <= N; ++j) {
std::pair<int, int> Ans = Query(j);
printf("%d %d %d\n", j, Ans.first, Ans.second);
}
#endif
}
return 0;
}
inline void AddEdge(int x, int y) {
Edge[++Used] = edge(y, Start[x]);
Start[x] = Used;
return;
}
inline void CutDfs1(int u, int Fa) {
Size[u] = 1;
Father[u] = Fa;
Deep[u] = Deep[Fa] + 1;
for (int t = Start[u]; t; t = Edge[t].Next) {
int v = Edge[t].To;
if (v == Fa) continue;
++CountSon[u];
CutDfs1(v, u);
Size[u] += Size[v];
if (Size[v] > Size[Son[u]])
Son[u] = v;
}
// if (Size[Son[u]] == 1) Son[u] = 0;
return;
}
inline void CutDfs2(int u, int Fa) {
if (Son[u]) {
Top[Son[u]] = Top[u];
Dfn[Son[u]] = ++TreeSize;
Ref[TreeSize] = Son[u];
CutDfs2(Son[u], u);
}
for (int t = Start[u]; t; t = Edge[t].Next) {
int v = Edge[t].To;
if (v == Fa || v == Son[u]) continue;
Top[v] = v;
Dfn[v] = ++TreeSize;
Ref[TreeSize] = v;
CutDfs2(v, u);
}
return;
}
inline std::pair<int, int> Merge(std::pair<int, int> x, std::pair<int, int> y) {
std::pair<int, int> Ans;
Ans.first = std::min(std::max(y.first, x.first), x.second);
Ans.second = std::min(std::max(y.second, x.first), x.second);
#ifdef _DEBUG_
printf(" Merge %d %d, %d %d, Get %d %d\n", x.first, x.second, y.first, y.second, Ans.first, Ans.second);
#endif
return Ans;
}
inline void Update(int Index, int Left, int Right) {
if (Left == Right) return;
IntervalTree[Index] = Merge(IntervalTree[Index << 1], IntervalTree[Index << 1 | 1]);
return;
}
inline void BuildIntervalTree(int Index, int Left, int Right) {
if (Left == Right) {
// IntervalTree[Index] = Calc(Ref[Left]);
Modify(1, 1, N, Left);
//Notice : 这里需要用 Modify 同时来上传。因为下面要用到 Query(Ref[Left]) 。而 Modify 至多被调用 n 次，每次 log n ，所以不会影响复杂度。
#ifdef _DEBUG_
printf("At Pos %d, Cal %d %d\n", Ref[Left], IntervalTree[Index].first, IntervalTree[Index].second);
#endif
if (Top[Ref[Left]] == Ref[Left]) {
// NoneRotateTreap[Father[Ref[Left]]].Insert(IntervalTree[Index].first);
NoneRotateTreap[Father[Ref[Left]]].Insert(Query(Ref[Left]).first);
#ifdef _DEBUG_
printf("*** %d\n", Ref[Left]);
printf("!!!CAL %d %d\n", Query(Ref[Left]).first, Query(Ref[Left]).second);
printf("Add %d To %d\n", Query(Ref[Left]).first, Father[Ref[Left]]);
NoneRotateTreap[Father[Ref[Left]]].Debug();
#endif
}
return;
}
int Mid = (Left + Right) >> 1;
BuildIntervalTree(Index << 1 | 1, Mid + 1, Right); //Right build first
//Notice ： 处理数据的时候要先处理深度深的链。通过线段树上先算右边再算左边就可以做到
BuildIntervalTree(Index << 1, Left, Mid);
Update(Index, Left, Right);
return;
}
inline std::pair<int, int> Query(int Index, int Left, int Right, int L, int R) {
#ifdef _DEBUG_
printf(" Query %d %d %d %d %d\n", Index, Left, Right, L, R);
#endif
if (L <= Left && Right <= R) return IntervalTree[Index];
int Mid = (Left + Right) >> 1;
if (R <= Mid) return Query(Index << 1, Left, Mid, L, R);
if (L > Mid) return Query(Index << 1 | 1, Mid + 1, Right, L, R);
return Merge(Query(Index << 1, Left, Mid, L, R), Query(Index << 1 | 1, Mid + 1, Right, L, R));
}
inline std::pair<int, int> Calc(int x) {
if (C[x] == 0) return std::pair<int, int>(-INF, -INF);
if (C[x] == 1) return std::pair<int, int>(INF, INF);
// std::pair<int, int> Temp = Query(Son[x]);
std::pair<int, int> Ans = std::pair<int, int>(0, 0);
#ifdef DEBUG_
printf("Son white :\n");
#endif
Modify(x, Ans.first, 2);
#ifdef DEBUG_
printf("Son black :\n");
#endif
Modify(x, Ans.second, 0);
#ifdef DEBUG_
printf("Finally get : %d %d\n", Ans.first, Ans.second);
#endif
return Ans;
}
inline std::pair<int, int> Query(int x) {
#ifdef _DEBUG_
printf(" Query %d -> %d %d\n", x, Dfn[x], Bottom[Top[x]]);
#endif
return Query(1, 1, N, Dfn[x], Bottom[Top[x]]);
}
inline void Modify(int Pos, int &k, int Delta) {
while(!Judge(Pos, k, Delta)) ++k;
while(Judge(Pos, k - 1, Delta)) --k;
return;
}
inline bool Judge(int Pos, int k, int Delta) {
int m = CountSon[Pos] - k - Delta;
int c = NoneRotateTreap[Pos].Rank(k + 1) - 1;
#ifdef DEBUG_
printf(" Judge %d %d %d -> %d %d, %d < 0 ?\n", Pos, k, Delta, m, c, m - 2 * c);
#endif
#ifdef DEBUG
printf(" Treap[%d], QueryRank %d, Get %d\n", Pos, k + 1, NoneRotateTreap[Pos].Rank(k + 1));
#endif
return m - 2 * c < 0;
}
inline void Change(int x, int y) {
C[x] = y;
while (x) {
#ifdef _DEBUG_
printf("Change Pos %d\n", x);
#endif
Modify(1, 1, N, Dfn[x]);
#ifdef _DEBUG_
printf(" Elements in Treap : ");
NoneRotateTreap[Father[Top[x]]].Debug();
#endif
NoneRotateTreap[Father[Top[x]]].Delete(Record[Top[x]]);
#ifdef _DEBUG_
printf(" NoneRotateTreap %d Delete %d\n", Father[Top[x]], Record[Top[x]]);
printf(" Elements in Treap : ");
NoneRotateTreap[Father[Top[x]]].Debug();
#endif
NoneRotateTreap[Father[Top[x]]].Insert(Record[Top[x]] = Query(Top[x]).first);
#ifdef _DEBUG_
printf(" NoneRotateTreap %d Insert %d\n", Father[Top[x]], Record[Top[x]]);
printf(" Elements in Treap : ");
NoneRotateTreap[Father[Top[x]]].Debug();
#endif
x = Father[Top[x]];
}
return;
}
inline void Modify(int Index, int Left, int Right, int Pos) {
if (Left == Right) {
IntervalTree[Index] = Calc(Ref[Pos]);
#ifdef _DEBUG_
printf(" Modify %d, Get %d %d\n", Ref[Pos], IntervalTree[Index].first, IntervalTree[Index].second);
#endif
return;
}
int Mid = (Left + Right) >> 1;
if (Pos <= Mid) Modify(Index << 1, Left, Mid, Pos);
if (Pos > Mid) Modify(Index << 1 | 1, Mid + 1, Right, Pos);
Update(Index, Left, Right);
return;
}
