OSU! on tree

dsu on tree

好吧，这个毒瘤......

树剖和启发式合并的杂合体。

用于解决静态子树问题，复杂度O(nlogn * insert时间)

因为dsu是并查集的意思所以算法名字大概就是什么树上并查集之类的鬼东西。

因为dsu是并查集的意思所以函数名字看起来会很奇怪......

主要思想是这样的：

首先仿照树剖搞出轻重子节点。

dsu到一个点的时候，dsu所有的轻子树并消除影响。

dsu重子树并保留影响，从重子节点那里继承答案。

计算自己的贡献。

插入所有轻子树并更新自己的答案。

如果自己是轻子树的话，消除自己的影响。

回溯。

可知每个点最多经过logn个重链就能到达根，所以每个点最多插入logn次。

---

例题：

给你一棵树以1号节点为根的树，每个节点上有一个体积为v，价值为w的物品。现
在要你统计，对于所有点i，如果只能取子树i中的物品，则容积为m的背包

至多能装总价值多少的物品。 n <= 50000 m <= 300

跟大部分dsu on tree有点区别，因为是树形背包变种所以不用消除轻子树影响。

首先考虑正常背包：

计算完子节点后merge子节点和自己，复杂度V²

总共nV²会超时。

然后考虑dsu on tree：

把重儿子memcpy给自己，然后依次insert每个轻儿子，虽然看起来比之前那个慢但是实际上...

复杂度mnlogn，显得十分之快...

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 const int N = , M = ;
 struct Edge {
     int v, nex;
 }edge[N]; int t;
 int e[N], son[N], siz[N];
 int f[N][M], cost[N], val[N], V;

 inline void add(int x, int y) {
     t++;
     edge[t].v = y;
     edge[t].nex = e[x];
     e[x] = t;
     return;
 }

 void DFS_1(int x) {
     siz[x] = ;
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         DFS_1(y);
         siz[x] += siz[y];
         if(siz[y] > siz[son[x]]) {
             son[x] = y;
         }
     }
     return;
 }

 void insert(int x, int p) {
     for(int i = V; i >= cost[x]; i--) {
         f[p][i] = std::max(f[p][i], f[p][i - cost[x]] + val[x]);
     }
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         insert(y, p);
     }
     return;
 }

 void dsu(int x) {
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y == son[x]) {
             continue;
         }
         dsu(y);
     }
     if(son[x]) {
         dsu(son[x]);
         memcpy(f[x], f[son[x]], sizeof(f[x]));
     }
     for(int i = V; i >= cost[x]; i--) {
         f[x][i] = std::max(f[x][i], f[x][i - cost[x]] + val[x]);
     }
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y == son[x]) {
             continue;
         }
         insert(y, x);
     }
     return;
 }

 int main() {
     int n;
     scanf("%d%d", &n, &V);
     for(int i = ; i <= n; i++) {
         scanf("%d%d", &cost[i], &val[i]);
     }
     for(int i = , x; i <= n; i++) {
         scanf("%d", &x);
         add(x, i);
     }
     DFS_1();
     dsu();
     for(int i = ; i <= n; i++) {
         printf("%d ", f[i][V]);
     }
     return ;
 } 

AC代码

---

CF 600E Lomsat gelral

题意：求树上每个子树中出现次数最多的颜色。如果有相同次数就颜色相加。

套路：先走轻儿子，传清空标记。

然后走重儿子，不清空。继承答案。

统计自己的贡献。

insert轻儿子并统计答案。

如果有清空标记就清空。

 #include <cstdio>
 const int N = ;
 typedef long long LL;
 struct Edge {
     int v, nex;
 }edge[N << ]; int top;
 int e[N], val[N], bin[N], large[N], son[N], siz[N];
 LL ans[N];

 inline void add(int x, int y) {
     top++;
     edge[top].v = y;
     edge[top].nex = e[x];
     e[x] = top;
     return;
 }

 void DFS_1(int x, int f) {
     siz[x] = ;
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y == f) {
             continue;
         }
         DFS_1(y, x);
         siz[x] += siz[y];
         if(siz[y] > siz[son[x]]) {
             son[x] = y;
         }
     }
     return;
 }

 void insert(int x, int f, int p) {
     bin[val[x]]++;
     if(bin[val[x]] > large[p]) {
         large[p] = bin[val[x]];
         ans[p] = val[x];
     }
     else if(bin[val[x]] == large[p]) {
         ans[p] += val[x];
     }

     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y != f) {
             insert(y, x, p);
         }
     }
     return;
 }

 void erase(int x, int f) {
     bin[val[x]]--;
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y != f) {
             erase(y, x);
         }
     }
     return;
 }

 void dsu(int x, int f, int k) {
     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y == f || y == son[x]) {
             continue;
         }
         dsu(y, x, );
     }
     if(son[x]) {
         dsu(son[x], x, );
         ans[x] = ans[son[x]];
         large[x] = large[son[x]];
     }

     bin[val[x]]++;
     if(bin[val[x]] > large[x]) {
         large[x] = bin[val[x]];
         ans[x] = val[x];
     }
     else if(bin[val[x]] == large[x]) {
         ans[x] += val[x];
     }

     for(int i = e[x]; i; i = edge[i].nex) {
         int y = edge[i].v;
         if(y == f || y == son[x]) {
             continue;
         }
         insert(y, x, x);
     }
     if(!k) {
         erase(x, f);
     }
     return;
 }

 int main() {
     int n;
     scanf("%d", &n);
     for(int i = ; i <= n; i++) {
         scanf("%d", &val[i]);
     }
     for(int i = , x, y; i < n; i++) {
         scanf("%d%d", &x, &y);
         add(x, y);
         add(y, x);
     }
     DFS_1(, );
     dsu(, , );
     for(int i = ; i <= n; i++) {
         printf("%I64d ", ans[i]);
     }
     return ;
 }

AC代码

一开始WA了第25个点，没找出错来，仔细思考发现答案可能是n²级别的，爆int了，开long long之后A掉。