这种不怎么难写的东西,我学得快忘得也快,也是给自己加深印象,同时留个自己(大概)能看懂的讲解好复习……qwq
先说是什么
dsu on tree中的dsu就是Disjoint Set Union,虽然整个算法跟并茶几(话说并茶几名字好多啊……)没有任何关系……硬要说就是借用了启发式合并的思想吧……
这个算法是拿来解决树上对子树内答案的询问的,当然它并不支持修改
它在暴力的基础上,借助轻重链剖分的性质把复杂度降低到了(O(n log n))
大致过程
遍历每一个节点,先递归解决轻儿子,完成后消除递归产生的影响
然后解决重儿子,但不消除影响
将轻儿子的答案合并上来
消除上一个过程中轻儿子产生的影响
拿一个例题来说:CF600E
题意:树上每个节点有一个颜色,求每棵子树中出现次数最多的颜色(可能有多个)之和
首先是轻重链剖分,处理出每个节点的重儿子
void dfs(int u, int fa) {
size[u] = 1;
for (int i = G.head[u]; ~i; i = G[i].next) {
int v = G[i].v;
if (v == fa) continue;
dfs(v, u);
size[u] += size[v];
if (!heavy[u] || size[v] > size[heavy[u]]) heavy[u] = v;
}
}
然后遍历节点,按上面的流程来(具体看注释)
void update(int u, int fa, int val, const int &hvy) {//val为1暴力合并统计轻儿子的答案,为-1清除对cnt的影响
cnt[col[u]] += val;
if (val > 0 && cnt[col[u]] >= max_cnt) {
if (cnt[col[u]] > max_cnt) sum = 0, max_cnt = cnt[col[u]];
sum += (LL)col[u];
}
for (int i = G.head[u]; ~i; i = G[i].next) {
int v = G[i].v;
if (v == fa || v == hvy) continue;
update(v, u, val, hvy);
}
}
void dfs(int u, int fa, int opt) {//opt为0表示需要清除掉u的影响,为1表示不需要
for (int i = G.head[u]; ~i; i = G[i].next) {
int v = G[i].v;
if (v == fa || v == heavy[u]) continue;
dfs(v, u, 0);//递归解决轻儿子,完成后清除影响
}
if (heavy[u]) dfs(heavy[u], u, 1);//解决重儿子,保留影响
update(u, fa, 1, heavy[u]);//合并轻儿子的答案
ans[u] = sum;
if (!opt) update(u, fa, -1, 0), sum = 0, max_cnt = 0;//清除影响
}
最后是完整代码:
PS.怎么网上的博客代码个个不一样啊……,蒟蒻我懵逼了好长时间才看明白qwq
#include <cstdio>
#include <cstring>
#include <iostream>
#define MAXN 100005
typedef long long LL;
struct Graph {
struct Edge {
int v, next;
Edge(int _v = 0, int _n = 0):v(_v), next(_n) {}
} edge[MAXN << 1];
int head[MAXN], cnt;
void init() { memset(head, -1, sizeof head); cnt = 0; }
void add_edge(int u, int v) { edge[cnt] = Edge(v, head[u]); head[u] = cnt++; }
void insert(int u, int v) { add_edge(u, v); add_edge(v, u); }
Edge & operator [](int x) { return edge[x]; }
} G;
int col[MAXN], size[MAXN], heavy[MAXN], val[MAXN], cnt[MAXN], N;
LL sum, max_cnt, ans[MAXN];
void dfs(int, int);
void dfs(int, int, int);
void update(int, int, int, const int &);
int main() {
G.init();
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", col + i);
for (int i = 1; i < N; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G.insert(u, v);
}
dfs(1, 0);
dfs(1, 0, 0);
for (int i = 1; i <= N; ++i) printf("%I64d ", ans[i]);
return 0;
}
void dfs(int u, int fa) {
size[u] = 1;
for (int i = G.head[u]; ~i; i = G[i].next) {
int v = G[i].v;
if (v == fa) continue;
dfs(v, u);
size[u] += size[v];
if (!heavy[u] || size[v] > size[heavy[u]]) heavy[u] = v;
}
}
void update(int u, int fa, int val, const int &hvy) {
cnt[col[u]] += val;
if (val > 0 && cnt[col[u]] >= max_cnt) {
if (cnt[col[u]] > max_cnt) sum = 0, max_cnt = cnt[col[u]];
sum += (LL)col[u];
}
for (int i = G.head[u]; ~i; i = G[i].next) {
int v = G[i].v;
if (v == fa || v == hvy) continue;
update(v, u, val, hvy);
}
}
void dfs(int u, int fa, int opt) {
for (int i = G.head[u]; ~i; i = G[i].next) {
int v = G[i].v;
if (v == fa || v == heavy[u]) continue;
dfs(v, u, 0);
}
if (heavy[u]) dfs(heavy[u], u, 1);
update(u, fa, 1, heavy[u]);
ans[u] = sum;
if (!opt) update(u, fa, -1, 0), sum = 0, max_cnt = 0;
}
//Rhein_E
最后是复杂度证明
轻重链剖分保证了每个节点到根的路径上轻边条数不超过(log n)
每个节点被访问一次,要么是它的祖先节点暴力统计轻儿子/消除影响的时候,要么是它自己统计答案的时候
前者(O(log n))次,后者(1)次
所以总复杂度是(O(n log n))的