树上启发式合并CF600E

最新推荐文章于 2023-05-04 19:57:04 发布
最新推荐文章于 2023-05-04 19:57:04 发布
阅读量251 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 树上操作 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zenith_Habitant/article/details/105613624
本文深入解析了树链剖分与DsuOnTree算法的原理及实现，详细介绍了如何通过树链剖分进行重儿子的处理，以及DsuOnTree算法在树上启发式合并的应用。文章通过具体的代码示例，展示了如何利用这两种算法解决树形结构上的信息统计问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define INF 0x3f3f3f3f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define p_queue priority_queue

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
ll n , col[100005];
int head[100005] , cnt;
struct e{
    int t, next;
}edge[200005];
ll size[100005] , son[100005], fa[100005];
ll flag, sum , maxc ,ans[100005], tot[100005];
void add(int f , int t)
{
    edge[cnt].t = t;
    edge[cnt].next = head[f];
    head[f] = cnt ++;
}
void dfs(int root)
{
    size[root] = 1;
    for(int i = head[root] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if(v != fa[root])
        {
            fa[v] = root;
            dfs(v);
            size[root] += size[v];
            if(size[v] > size[son[root]])
                son[root] = v;
        }
    }
}
void count(int root, int val)
{
    tot[col[root]] += val;
    if(tot[col[root]] > maxc)
    {
        maxc = tot[col[root]];
        sum = col[root];
    }
    else if(tot[col[root]] == maxc)
        sum += col[root];
    //除了重儿子子树所有轻儿子子树全部重新统计
    for(int i = head[root] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if(v == fa[root] || v == flag) continue;
        count(v,val);
    }
}
void dsu(int root, int keep)
{
    //处理当前结点的所有轻儿子构成的子树
    for(int i = head[root] ; i != -1 ; i = edge[i].next)
    {
        int v = edge[i].t;
        if(v == fa[root] || v == son[root]) continue;
        dsu(v,0); //keep == 0 ，不保留轻儿子子树贡献
    }
    //如果存在重儿子，则计算重儿子贡献，并且保留
    if(son[root])
    {
        dsu(son[root],1);
        flag = son[root];
    }
    //统计该结点的整体信息
    count(root,1);
    flag = 0;
    ans[root] = sum;
    if(!keep)
    {
        //删除贡献
        count(root,-1);
        sum = maxc = 0;
    }
}
int main(void)
{
    mem(head,-1);
    cin>>n;
    for(int i = 1; i <= n ; i ++)
        cin>>col[i];
    for(int i = 1 ; i < n ; i ++)
    {
        int u , v;
        cin>>u>>v;
        add(u,v);
        add(v,u);
    }
    dfs(1);//简单的树链剖分一阶段处理出重儿子
    dsu(1,0); //树上启发式合并
    for(int i = 1 ; i <= n ; i ++)
        cout<<ans[i]<<" ";
    cout<<endl;
}

因为每一个结点最多只需要遍历LogN+1次 所以 整体复杂度为N*(LogN+1），因为某结点到达根节点最多存在LogN次轻边，自身统计一次，每存在一条轻边就意味着要遍历一次轻边链接的子树的所有的结点，重子树的结点只用遍历一次

以上是旧版本的

 

新版本Dsu On Tree

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)

template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
const int N = 1e5 + 5;
int n, maxCnt;
int c[N], siz[N], son[N], vis[N], cnt[N];
ll ans[N], sum;
vector <int> edge[N];
void dfs1 (int u, int fa)
{
    siz[u] = 1;
    for (auto v : edge[u])
    {
        if (v != fa)
        {
            dfs1 (v, u);
            siz[u] += siz[v];
            if (siz[v] > siz[son[u]])
                son[u] = v;
        }
    }
}
void count (int u , int fa, int k)
{
    cnt[c[u]] += k;
    if (k > 0)
    {
        if (cnt[c[u]] > maxCnt) sum = c[u] , maxCnt = cnt[c[u]];
        else if (cnt[c[u]] == maxCnt) sum += c[u];
    }
    for (auto v : edge[u])
    {
        if (v != fa && !vis[v])
            count(v , u , k);
    }
}
void dfs2 (int u , int fa , int opt)
{
    for (auto v : edge[u])
        if (v != fa && v != son[u])
            dfs2 (v , u , 0);
    if (son[u])
    {
        dfs2 (son[u], u, 1);
        vis[son[u]] = 1;
    }
    count (u , fa, 1);
    ans[u] = sum;
    if (son[u]) vis[son[u]] = 0;
    if (!opt) count (u , fa , -1) , sum = maxCnt = 0;

}
int main()
{
    read (n);
    for (int i = 1 ; i <= n ; i ++)
        read (c[i]);
    for (int i = 1 ; i < n  ; i ++)
    {
        int u , v;
        read (u , v);
        edge[u].pb(v);
        edge[v].pb(u);
    }
    dfs1 (1, 0);
    dfs2 (1 , 0 , 1);
    for (int i = 1 ; i <= n ; i ++)
        cout << ans[i] << ' ';
    cout << endl;
}

线段树合并+动态开点

//#define LOCAL
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mem(a, b) memset(a,b,sizeof(a))
#define sz(a) (int)a.size()
#define INF 0x3f3f3f3f
#define DNF 0x7f
#define DBG printf("this is a input\n")
#define fi first
#define se second
#define mk(a, b) make_pair(a,b)
#define pb push_back
#define LF putchar('\n')
#define SP putchar(' ')
#define p_queue priority_queue
#define CLOSE ios::sync_with_stdio(0); cin.tie(0)

template<typename T>
void read(T &x) {x = 0;char ch = getchar();ll f = 1;while(!isdigit(ch)){if(ch == '-')f *= -1;ch = getchar();}while(isdigit(ch)){x = x * 10 + ch - 48; ch = getchar();}x *= f;}
template<typename T, typename... Args>
void read(T &first, Args& ... args) {read(first);read(args...);}
template<typename T>
void write(T arg) {T x = arg;if(x < 0) {putchar('-'); x =- x;}if(x > 9) {write(x / 10);}putchar(x % 10 + '0');}
template<typename T, typename ... Ts>
void write(T arg, Ts ... args) {write(arg);if(sizeof...(args) != 0) {putchar(' ');write(args ...);}}
using namespace std;

ll gcd(ll a, ll b) {
    return b == 0 ? a : gcd(b, a % b);
}

ll lcm(ll a, ll b) {
    return a / gcd(a, b) * b;
}
const int N = 1e5 + 5;
int n , c[N], tot;
vector <int> edge[N];
int root[N * 32] , lc[N * 32] , rc[N * 32];
ll val[N * 32], cnt[N * 32];
ll ans[N * 32];
void push_up (int x)
{
    if (cnt[lc[x]] > cnt[rc[x]])
    {
        cnt[x] = cnt[lc[x]];
        val[x] = val[lc[x]];
    }
    else if (cnt[lc[x]] < cnt[rc[x]])
    {
        cnt[x] = cnt[rc[x]];
        val[x] = val[rc[x]];
    }
    else
    {
        cnt[x] = cnt[lc[x]];
        val[x] = val[lc[x]] + val[rc[x]];
    }
}
void insert (int& rt , int l , int r , int x , int add)
{
    if (!rt) rt = ++ tot;
    if (l == r)
    {
        cnt[rt] = 1;
        val[rt] = l;
        return ;
    }
    int mid = (l + r) >> 1;
    if (x <= mid)
        insert (lc[rt], l , mid , x , add);
    else
        insert (rc[rt], mid + 1, r , x , add);
    push_up(rt);
}
int merge(int x , int y , int l , int r)
{
    if (!x || !y) return x + y;
    if (l == r)
    {
        cnt[x] += cnt[y];
        val[x] = l;
        return x;
    }
    int mid = (l + r) >> 1;
    lc[x] = merge(lc[x], lc[y], l, mid);
    rc[x] = merge(rc[x], rc[y], mid+1, r);
    push_up(x);
    return x;

}
void dfs (int u , int fa)
{
    insert (root[u] ,1 , n , c[u] , 1);
    for (auto v : edge[u])
    {
        if (v != fa)
        {
            dfs (v , u);
            root[u] = merge (root[u], root[v], 1, n);
        }
    }
    ans[u] = val[root[u]];
}
int main()
{
    read (n);
    for (int i = 1 ; i <= n ; i ++)
        read (c[i]);
    for (int i = 1 ; i < n  ; i ++)
    {
        int u , v;
        read (u , v);
        edge[u].pb(v);
        edge[v].pb(u);
    }
    dfs (1 , 1);
    for (int i = 1 ; i <= n ; i ++)
        cout << ans[i] << ' ';
    cout << endl;
}

 

CF600E(dsu on tree)
Ordinarv
11-21 328
题意: 给你一棵n个点的有根树，以1为根，每个点有一个颜色。对于一颗以v为根的子树，其出现次数最多的颜色，为dominating顶点v这个子树的颜色，可能有多个这样的颜色。求以n个顶点分别为根的子树中，dominating 的颜色和。 思路： 一个很好想的暴力思路就是，dfs n个点，统计该点为根的子树中出现的颜色次数。时间、空间都是O(N^2)的。 我们可以每次统计完一个点后清空cnt数组...
【学习笔记】树上启发式合并
繁凡さん的博客
07-26 675
整理的算法模板合集： ACM模板 点我看算法全家桶系列！！！ 实际上是一个全新的精炼模板整合计划 Problem 给定一棵有根树，每条边的权值是 ['a','v'] 的一个字母。现对于每个树上点，求出最长的一条 “回文” 路径。“回文” 路径的含义是将路径上所有的字母取出，可以组成一个回文串。 1≤n≤5×1051\le n\le 5\times 10^51≤n≤5×105 Solution Code ...
CF600E（树上启发式合并）
lcl1234567890lcl的博客
09-16 318
CF600E Lomsat gelral 第一次写启发式合并，其实就是一种思想，想处理小的（轻儿子），每次处理好后要删除掉他们的贡献，最后处理大的（重儿子）,这时就不要删除大的贡献了，然后再加上其他小的的贡献，回溯回去就是所有的贡献。 遵循先小后大的原则，同时启发式合并是不带修的 时间复杂度极为玄学是O(nlogn)O(nlogn)O(nlogn) 最后感谢AgOH大佬的讲解 #pragma GCC optimize(2) #pragma GCC optimize(3,"Ofast","inline") #
cf600E
binarycopycode
11-15 603
一开始用sb方法，时间没超然而内存爆了，之后又换了操作，启发式合并可证明最坏情况是合并的复杂度一共是nlognlogn的复杂度。map还是好容易在dfs里面炸内存啊。然而他swap两个map和swap两个map的下标最后的时间差别只有一点点。据说swap(map[1],map[2])是只交换指针的，不用遍历整个map[1],map[2]种的元素，神奇。 #include<cstdi...
CF 600E(Lomsat gelral-dfs)
nike0good |Oier&ACMer | 熟能生巧
12-01 1261
一棵树n (1 ≤ n ≤ 300 000)个节点，已知点权ci≤ nc_i≤ n，根为1 对于每个节点，求出对应子树中，出现次数最多（或之一）的点权的和用一个map暴力存，每次从最大那个合并#include<bits/stdc++.h> using namespace std; #define For(i,n) for(int i=1;i<=n;i++) #define Fork(i,k,n)
[CF600E]Lomsat gelral
weixin_30732487的博客
11-30 134
题意翻译 一棵树有n个结点，每个结点都是一种颜色，每个颜色有一个编号，求树中每个子树的最多的颜色编号的和。 线段树合并板子题，没啥难度，注意开long long 不过这题$dsu$ $on$ $tree$确实更快 代码： 1 #include<iostream> 2 #include<cstdio> 3 #define ls ch[node][0] ...
dsu on tree(树上启发式合并)算法总结+习题
mumei的博客
02-03 2941
前几天补了一下在camp中没学到的算法，树上启发式合并，一个O(nlogn)处理树上查询问题比较好的算法（其实就是暴力） 前置知识 学习这个算法之前需要知道一些树链剖分中的概念，不知道也没问题，下面我会给出 节点的大小：以当前节点为根的子树中的节点个数 重儿子：所有儿子节点中大小最大的那个节点 轻儿子：除重儿子之外的儿子节点 至于节点的深度等常见概念就不解释了。 算法思想 先拿一...
【图论】树上启发式合并
Rainfoo的博客
06-07 354
树上启发式合并(DSU on Tree)，是一个在O(nlogn) 时间内解决许多树上问题的有力算法。 cf600E板子 #include<bits/stdc++.h> #define ll long long #define rep(i,a,n) for(int i=a;i<=n;i++) #define per(i,n,a) for(int i=n;i>=a;i--) #define endl '\n' #define mem(a,b) memset(a,b,sizeof(a))
算法进阶课——7.1 启发式合并、Manacher算法
m0_62021646的博客
01-31 1633
7.1 启发式合并、Manacher算法 启发式合并 启发式合并类似于并查集的按秩合并. 例如，一开始有 nnn 个数，每个数在仅包含自己的单独的集合当中，每次将某个集合内的所有元素，合并到另外一个集合当中，最终要将所有数都合并到一个集合当中. 如果暴力地去实现的话，将包含 aaa 个元素的集合，合并到另外一个集合当中，则其时间复杂度为 O(a×op)O(a \times op)O(a×op)，其中 opopop 为每个元素合并到另一个集合的时间...
【线段树】[LUOGU CF600E Lomsat gelral] 区间众数和 [线段树合并]
BLNG
08-25 1139
题目： 题目链接：[LUOGU CF600E Lomsat gelral] 题解： 这个题就是个（动态开点）权值线段树的板子题，就是在每个点上建立一个取值线段树，记录区间众数和，不断是合并权值线段树就行，在up里面就进行对于众数的判断即可。 这里再说一下权值线段树，之前说过，这就是个桶，但是桶只能查找到权值等于xxx这个值的个数，但是权值线段树可以查找到权值在xxx，yyy之间的的个数。 代码： ...
cf600E. Lomsat gelral
weixin_30702887的博客
11-04 134
题解: dsu on tree 实质上启发式合并 我们考虑维护节点u的信息 需要将u的儿子的信息和节点信息合并 我们考虑启发式合并 把轻儿子合并到重儿子上 我们考虑n次启发式合并 复杂度nlogn*(合并一次的复杂度) 具体做法那我们考虑树链剖分的时候 划分轻重儿子 保留重儿子信息 清空轻儿子信息 并将轻儿子的信息合并到重儿子上即可 #include <algorithm> ...
cf600E Lomsat gelral
ad4627的博客
08-26 166
给定一棵n个节点的树，每个节点有个权值，1为根节点。把任意节点为根的子树中权值出现次数最多的权值称为占领这个节点的权值。 然而次数最多的权值可能有多个，要求每个节点的占领这个节点所有权值的和。 每个子树上的答案互不相关，考虑用树上启发式合并。 用一个数组记录当前子树的所有权值出现的次数，有新的次数出现就给那个次数加上这个权值。 把非重儿子子树插入删除就好。 ...
cf600E(每个节点子树中出现次数最多的颜色编号和 树上启发式合并/线段树)
qq_42576687的博客
10-17 355
题目 1.启发式合并 sum[num[col[x]]]=col[x],num[col[x]]+=val,sum[num[col[x]]]+=col[x]; 2.线段树合并 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=1e5+5; struct Edge{int to,ne...
线段树合并:CF600E
qq_35577488的博客
10-13 243
该算法的全称叫做:动态开点权值线段树合并.一般用来解决不好维护的子树信息. 一般来讲,线段树合并都是指的权值线段树合并.目前还没见到过非权值线段树的合并. 题目大意: 给你一颗树,每个点上有一个权值valival_ivali​.现在问你,对于每一颗子树,它的出现次数最多的权值的和为多少(有多个出现次数最多的,都应算上). n≤1e5n \leq 1e5n≤1e5 题目思路: 两种解法吧,1.dsu on tree. 2.线段树合并.基本都能当板子题使用了. 学过主席树会觉得这个东西没有违和感. 动态开n颗线
CF600E Lomsat gelral（虚树做法）
Ark
06-06 371
题目 n≤105n\le 10^5n≤105。 题解 有dsu on tree\texttt{dsu on tree}dsu on tree的解法。 我写的是虚树的做法。对于每种颜色建虚树，然后在虚树上求一次子树size，然后每个虚树上的点对原树上对应点做初步贡献。 最后再dfs\texttt{dfs}dfs一遍求答案。 存答案我用的是结构体，存最大值和编号之和。可以简单合并。 考虑证明上面的做法对于一种颜色，在初步贡献和最后的一遍dfs\texttt{dfs}df
【CF 600E】Lomsat gelral（树上启发式合并， dsu on tree， 静态链分治，模板题）
小哈里的博客
07-28 806
Algorithm 名称：树上启发式合并， dsu on tree， 静态链分治 用处：一般用来解决一类不带修改的子树查询问题 核心思想为：利用重链剖分的性质优化子树贡献的计算。 前置知识：启发式合并，最常见的就是并查集的按秩合并了，有带按秩合并的并查集中，对于两个大小不一样的集合，我们将小的集合合并到大的集合中，而不是将大的集合合并到小的集合中。让高度小的树成为高度较大的树的子树，这个优化可以称为启发式合并算法。 相关题目： 给出一棵 n 个节点以 1 为根的树，节点 u的颜色为 C[u]，现在对于每个
【CF600E】Lomsat gelral（dsu on tree）
小蒟蒻yyb的博客
06-06 733
题面 洛谷 CF题面自己去找找吧。 题解 dsu&nbsp;on&nbsp;treedsu&nbsp;on&nbsp;treedsu\ on\ tree板子题 其实就是做子树询问的一个较快的方法。 对于子树的询问，我们不难想到子树就是dfsdfsdfs序上的连续一段， 可以把树转化成序列再用莫队来解。 其实可以对树进行树链剖分，然后暴力+优化来解 具体的做法就是： 递归处理...
CF600E Lomsat gelral（set）
tanjunming2020的博客
05-04 1578
### 题目大意 有一棵$n$个节点的以$1$号节点为根的有根数。 每个节点都有一个颜色，第$i$个节点的衍颜色为$c_i$。 如果一种颜色在以$z$为根的子树内出现次数最多，称其在以$x$为根的子树中占主导地位。显然，同一子树中可能有多种颜色占主导地位。 对于每一个$i\in[1,n]$，求以$i$为根的子树中，占主导地位的颜色的编号和。
CF600E Lomsat gelral（树上启发式合并）
hipamp的博客
05-20 520
题意 有一颗 nnn 个节点的树，以 111 为根节点，每个点有一个颜色 viv_ivi​。设子树 aaa 中颜色出现次数最多的颜色集合为 {bi}\{b_i\}{bi​}，记 ansa=∑bians_a=\sum b_iansa​=∑bi​。现在要求 ans1,ans2,....ansnans_1,ans_2,....ans_nans1​,ans2​,....ansn​。 其中，n,v≤105n,v\leq 10^5n,v≤105。 分析 这种题叫做 dsu on treedsu~on
[CF600E] Lomsat Gelral [树链剖分/树上启发式合并]
最后一次修改
09-28 423
题意： 给出一个有NNN个点，以111号点为根的有根树。每个点有一种颜色ci≤Nc_i\le Nci​≤N。 以某个点为根的子树中，如果一种颜色出现的次数不比其它颜色少，称它是这个点的支配颜色。 点的支配颜色的和，是指，某个点的所有支配颜色的编号的和。 求这棵树上每个点的支配颜色的和。 N≤105。N\le10^5。N≤105。 简单地考虑： 可以暴力统计每个点，每种颜色的出现次数。Θ(N2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值