树上启发式合并，静态链分治（DSU）

最新推荐文章于 2024-01-24 09:49:39 发布
最新推荐文章于 2024-01-24 09:49:39 发布
阅读量1.2k 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42852687/article/details/124001985
版权
本文详细介绍了树上启发式合并（DSU）算法在处理树形结构问题中的应用，包括统计共同祖先、判断子树是否构成回文串、查找主要颜色、计算颜色出现次数以及寻找距离最大节点。通过实例代码展示如何实现这些操作，并提供了多个在线判题链接作为练习。
摘要由CSDN通过智能技术生成

树上启发式合并，静态链分治（DSU）

一，讲解

https://www.acwing.com/solution/content/59241/

  • 遍历每一个节点
  • 递归解决所有的轻儿子，同时消除递归产生的影响
  • 递归重儿子，不消除递归的影响
  • 统计所有轻儿子对答案的影响
  • 更新该节点的答案
  • 删除所有轻儿子对答案的影响

二，使用

T1

题目

一片森林，每次询问一个点与多少个点拥有共同的K级祖先

友好链接

https://www.luogu.com.cn/problem/CF208E

https://www.luogu.com.cn/blog/defKaeru/solution-cf208e

题解

我们首先考虑在一棵树上处理的情况，把问题转换一下，其实让你求的就是以某个节点为根的子树中的深度为k的节点个数

因此我们可以用倍增法先求出每一个节点的K级祖先，然后再在第k级祖先上处理维护答案就行了。

code

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int inf= 0x3f3f3f3f;
const int N = 5e5+9;
int n,m;
int dep[N],sz[N],hson[N];
int cnt[N],ans[N],color[N];
int vis[N];
int f[N][26];
vector<int>g[N];
vector<pii>Q[N];


template <typename T> void inline read(T &x)
{
    x= 0 ; bool f= 0; char ch  = getchar();
    while (ch < '0' || ch > '9') {if(ch == '-')f= 1; ch = getchar();}
    while (ch <='9' && ch >= '0') {x= (x<<1)+ (x<<3) + ch - '0'; ch = getchar();}
    if(f)x*=-1;
}

void dfs_tree(int x,int fa)
{
    dep[x]=dep[fa]+1;
    sz[x]= 1;
    f[x][0]=fa;
    rep(i,1,20) f[x][i]=f[f[x][i-1]][i-1];
    for (auto j:g[x])
    {
        if(j==fa)continue;
        dfs_tree(j,x);
        sz[x]+=sz[j];
        if(sz[hson[x]]<sz[j])hson[x]=j;
    }
}

void calc (int u,int f,int k)
{
    /// 统计整个子树的信息
    cnt[dep[u]]+=k;
    for(auto v:g[u])
    {
        if(v!=f&&!vis[v])///不反祖且未被访问
        {
            calc(v,u,k);
        }
    }
}

void dfs_dsu(int u,int f,int keep)
{
    for(auto v:g[u])
    {
        if(v!=hson[u]&&v!=f)
            {
                dfs_dsu(v,u,0);
            }
    }
        /// 递归处理子树问题

    if(hson[u])dfs_dsu(hson[u],u,1),vis[hson[u]]=1;
    calc(u,f,1);///统计非重子树的信息
    for(int i= 0;i < Q[u].size() ; i++)
    {
        int id = Q[u][i].first;  ///询问编号
        int d = Q[u][i].second;  ///询问深度
        ans[id]=cnt[d]-1;
    }
    if(hson[u])vis[hson[u]]=0;
    if(keep==0)calc(u,f,-1);
}

void pre()
{
    for (int k = 1;k <= 26 ; k ++)
    {
         for (int i = 1; i <= n ; i++) f[i][k]=f[f[i][k-1]][k-1];
    }
}


int getfa(int x,int lev)
{
    for(int i=20;~i;i--)
    {
        if(lev&(1<<i))x=f[x][i];
    }
    return x;
}

int main()
{
    read(n);
    rep(i,1,n)
    {
        int x; read(x);
        if(x) g[x].pb(i),g[i].pb(x);
    }

    read(m);
    rep(i,1,n)if(!dep[i])dfs_tree(i,0);

    rep(i,1,m)
    {
        int v,p;
        read(v); read(p);
        int fax= getfa(v,p); ///获取v的p级祖先
        Q[fax].pb({i,dep[v]});
    }
    rep(i,1,n)if(dep[i]==1)dfs_dsu(i,0,0);
    rep(i,1,m)printf("%d\n",ans[i]);
    return 0;
}

T2

题目

给定一个以1为根的n个节点的树，每个点上有一个字母(a-z)，

每个点的深度定义为该节点到1号节点路径上的点数.

每次询问 a,b.查询以a为根的子树内深度为b的节点上的字母重新排列之后是否能构成回文串.

友好链接

https://www.luogu.com.cn/problem/CF570D

题解

T1的cnt基础上再加上一维颜色

重排之后构成回文串的条件是：每个字母出现次数都为偶数或者只有一个字母出现次数为奇数。

因此我们可以直接维护cnt数组来统计子树中在某个深度上每个字符出现次数，然后再检查是否符合条件就行了。

至于查询操作，我们可以离线处理，然后把它挂在节点上，每当统计到该节点时，更新答案就行了。

code

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int inf= 0x3f3f3f3f;
const int N = 5e5+9;
int n,m;
int dep[N],sz[N],hson[N];
int cnt[N][30],ans[N],color[N];
int vis[N];
vector<int>g[N];
vector<pii>Q[N];


template <typename T> void inline read(T &x)
{
    x= 0 ; bool f= 0; char ch  = getchar();
    while (ch < '0' || ch > '9') {if(ch == '-')f= 1; ch = getchar();}
    while (ch <='9' && ch >= '0') {x= (x<<1)+ (x<<3) + ch - '0'; ch = getchar();}
    if(f)x*=-1;
}

void dfs_tree(int x,int fa)
{
    dep[x]=dep[fa]+1;
    sz[x]= 1;
    for (auto j:g[x])
    {
        if(j==fa)continue;
        dfs_tree(j,x);
        sz[x]+=sz[j];
        if(sz[hson[x]]<sz[j])hson[x]=j;
    }
}

void calc (int u,int f,int k)
{
    /// 统计整个子树的信息
    cnt[dep[u]][color[u]]+=k;
    for(auto v:g[u])
    {
        if(v!=f&&!vis[v])///不反祖且未被访问
        {
            calc(v,u,k);
        }
    }
}

void dfs_dsu(int u,int f,int keep)
{
    for(auto v:g[u])
    {
        if(v!=hson[u]&&v!=f)
            {
                dfs_dsu(v,u,0);
            }
    }
        /// 递归处理子树问题

    if(hson[u])dfs_dsu(hson[u],u,1),vis[hson[u]]=1;
    calc(u,f,1);///统计非重子树的信息
    for(int i= 0;i < Q[u].size() ; i++)
    {
        int id = Q[u][i].first;  ///询问编号
        int d = Q[u][i].second;  ///询问深度
        int num = 0;

        for(int j = 1;j<= 26;j++)
            if(cnt[d][j]&1) num++;

        ans[id]=num>1?0:1;
    }
    if(hson[u])vis[hson[u]]=0;
    if(keep==0)calc(u,f,-1);
}

int main()
{
    read(n); read(m);
    rep(i,2,n)
    {
        int x; read(x);
        g[x].pb(i); g[i].pb(x);
    }
    char s[N];
    scanf("%s",s+1);
    int len = strlen(s+1);
    rep(i,1,len)color[i]=s[i]-'a'+1;
    dfs_tree(1,0);
    rep(i,1,m)
    {
        int x,y;
        read(x); read(y);
        Q[x].pb({i,y});
    }
    dfs_dsu(1,0,1);
    rep(i,1,m)
    {
        if(ans[i])puts("Yes");
        else puts("No");
    }
    return 0;
}

T3

题目

给定一棵由 n 个节点组成的树。

树的节点编号为 1∼n，其中 1 号节点为树的根节点。

每个节点上都标有某种颜色。

第 i 个节点上的颜色为 ci。

如果在以节点 v 为根节点的子树中，没有任何颜色的出现次数超过颜色 c 的出现次数，那么我们称颜色 c 为该子树的主要颜色。

一些子树的主要颜色可能不止一种。

以节点 v 为根节点的子树由节点 v 以及到达根节点的路径中包含节点 v 的其它所有节点共同组成。

对于每个节点 v(1≤v≤n)，请你求出以该节点为根节点的子树的所有主要颜色之和。

友好链接

https://www.luogu.com.cn/problem/CF600E

题解

  • 注意统计答案的时候不用遍历cnt数组，可以在加减档过程中维护
  • 注意开ll
  • 注意不要忘记开重链剖分

code

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int inf= 0x3f3f3f3f;
const int N = 5e5+9;
int n,m;
int dep[N],sz[N],hson[N];
ll cnt[N],ans[N];
int col[N];
int vis[N];
int f[N][26];
vector<int>g[N];
vector<pii>Q[N];
ll sum,mx;

template <typename T> void inline read(T &x)
{
    x= 0 ; bool f= 0; char ch  = getchar();
    while (ch < '0' || ch > '9') {if(ch == '-')f= 1; ch = getchar();}
    while (ch <='9' && ch >= '0') {x= (x<<1)+ (x<<3) + ch - '0'; ch = getchar();}
    if(f)x*=-1;
}

void dfs_tree(int x,int fa)
{
    dep[x]=dep[fa]+1;
    sz[x]= 1;
    for (auto j:g[x])
    {
        if(j==fa)continue;
        dfs_tree(j,x);
        sz[x]+=sz[j];
        if(sz[hson[x]]<sz[j])hson[x]=j;
    }
}

void calc (int u,int f,int k)
{
    /// 统计整个子树的信息
    cnt[col[u]]+=k;

    if(cnt[col[u]]>mx)sum=col[u],mx=cnt[col[u]];
    else if(cnt[col[u]]==mx)sum+=col[u];


    for(auto v:g[u])
    {
        if(v!=f&&!vis[v])///不反祖且未被访问
        {
            calc(v,u,k);
        }
    }
}

void dfs_dsu(int u,int f,int keep)
{
    for(auto v:g[u])
    {
        if(v!=hson[u]&&v!=f)
            {
                dfs_dsu(v,u,0);
            }
    }
        /// 递归处理子树问题

    if(hson[u])dfs_dsu(hson[u],u,1),vis[hson[u]]=1;
    calc(u,f,1);///统计非重子树的信息
    ans[u]=sum;
    if(hson[u])vis[hson[u]]=0;
    if(keep==0)calc(u,f,-1),mx=sum= 0;
}


int main()
{
    read(n);

    rep(i,1,n)read(col[i]);

    rep(i,1,n-1)
    {
        int v,p;
        read(v); read(p);
        g[v].pb(p); g[p].pb(v);
    }
    dfs_tree(1,0);
    dfs_dsu(1,0,0);
    rep(i,1,n)printf("%lld ",ans[i]);
    return 0;
}

T4

题目

给出一棵 n 个结点的树，每个结点有一个颜色 c i 。 询问 q 次，每次询问以 v 结点为根的子树中，出现次数 ≥k 的颜色有多少种。树的根节点是1.

友好链接

https://www.luogu.com.cn/problem/CF375D

题解

维护一个后缀和，我们结合calc函数看一下框架

考虑到出现次数k最大不超过点数，开一个桶是可行的

num[x] 表示出现次数大于等于 k 的次数

考虑到增加的时候是一个一个加的，删除的时候，每删除一个也是只对删除的当前k造成了影响，只要处理这一位就好了，不用管前面的或者后面的

void calc (int u,int f,int k)
{
    int pos = col[u];
    /// num[x] 表示出现次数大于等于k的计数
    if(k==-1) num[cnt[pos]]+=k;

    cnt[pos]+=k;
    if(k==1) num[cnt[pos]]+=k;

    for (auto v:g[u])
    {
        if(v!=f&&!vis[v])calc(v,u,k);
    }
}

code

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int inf= 0x3f3f3f3f;
const int N = 5e5+9;
int n,m;
int dep[N],sz[N],hson[N];
int cnt[N],ans[N];
int col[N];
int vis[N];
int num[N];
vector<int>g[N];
vector<pii>Q[N];
int colmax;

template <typename T> void inline read(T &x)
{
    x= 0 ; bool f= 0; char ch  = getchar();
    while (ch < '0' || ch > '9') {if(ch == '-')f= 1; ch = getchar();}
    while (ch <='9' && ch >= '0') {x= (x<<1)+ (x<<3) + ch - '0'; ch = getchar();}
    if(f)x*=-1;
}

void dfs_tree(int x,int fa)
{
    dep[x]=dep[fa]+1;
    sz[x]= 1;
    for (auto j:g[x])
    {
        if(j==fa)continue;
        dfs_tree(j,x);
        sz[x]+=sz[j];
        if(sz[hson[x]]<sz[j])hson[x]=j;
    }
}

void calc (int u,int f,int k)
{
    int pos = col[u];
    /// num[x] 表示出现次数大于等于k的计数
    if(k==-1) num[cnt[pos]]+=k;

    cnt[pos]+=k;
    if(k==1) num[cnt[pos]]+=k;

    for (auto v:g[u])
    {
        if(v!=f&&!vis[v])calc(v,u,k);
    }
}

void dfs_dsu(int u,int f,int keep)
{
    for(auto v:g[u])
    {
        if(v!=hson[u]&&v!=f)
            {
                dfs_dsu(v,u,0);
            }
    }
        /// 递归处理子树问题

    if(hson[u])dfs_dsu(hson[u],u,1),vis[hson[u]]=1;
    calc(u,f,1);///统计非重子树的信息
    for (int i= 0;i<Q[u].size();i++)
    {
        ll sum =0;
        int id = Q[u][i].first;
        int d = Q[u][i].second;
        ans[id]=num[d];
    }

    if(hson[u])vis[hson[u]]=0;
    if(keep==0)calc(u,f,-1);
}
int main()
{
    read(n);read(m);
    rep(i,1,n)read(col[i]),colmax=max(colmax,col[i]);
    rep(i,1,n-1)
    {
        int a,b;
        read(a); read(b);
        g[b].pb(a);
        g[a].pb(b);
    }

    dfs_tree(1,0);
    rep(i,1,m)
    {
        int v,p;
        read(v);read(p);
        Q[v].pb({i,p});
    }

    dfs_dsu(1,0,1);
    rep(i,1,m)printf("%d\n",ans[i]);

    return 0;
}

T5

题目

给定一棵以 1 为根，n 个节点的树。设 d(u,x) 为 u 子树中到 u 距离为 x 的节点数。

对于每个点，求一个最小的 k，使得 d(u,k) 最大。

友好链接

https://www.luogu.com.cn/problem/CF1009F

题解

注意答案统计方式，在注销非重儿子的时候，可以认为开始新的问题，答案的状态可设置为初始状态

void calc(int u,int f,int k)
{
    cnt[dep[u]]+=k;
    if(k>0&&cnt[dep[u]]>=maxcnt)
    {
        if(cnt[dep[u]]>maxcnt)maxcnt=cnt[dep[u]],mindep=dep[u];
        else if(cnt[dep[u]]==maxcnt)mindep=min(mindep,dep[u]);
    }

    for(auto v:g[u])
    {
        if(v!=f&&!vis[v])calc(v,u,k);
    }
}

code

#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int,int>pii;
const int inf= 0x3f3f3f3f;
const int N = 1e6+9;
int n,m;
int dep[N],sz[N],hson[N];
int cnt[N],ans[N];
int vis[N];
vector<int>g[N];
vector<pii>Q[N];
int mindep,maxcnt;

template <typename T> void inline read(T &x)
{
    x= 0 ; bool f= 0; char ch  = getchar();
    while (ch < '0' || ch > '9') {if(ch == '-')f= 1; ch = getchar();}
    while (ch <='9' && ch >= '0') {x= (x<<1)+ (x<<3) + ch - '0'; ch = getchar();}
    if(f)x*=-1;
}

void dfs_tree(int u,int f)
{
    sz[u]= 1;
    dep[u]=dep[f]+1;
    for(auto v:g[u])
    {
        if(v==f)continue;
        dfs_tree(v,u);
        sz[u]+=sz[v];
        if(sz[hson[u]]<sz[v])hson[u]=v;
    }
}

void calc(int u,int f,int k)
{
    cnt[dep[u]]+=k;
    if(k>0&&cnt[dep[u]]>=maxcnt)
    {
        if(cnt[dep[u]]>maxcnt)maxcnt=cnt[dep[u]],mindep=dep[u];
        else if(cnt[dep[u]]==maxcnt)mindep=min(mindep,dep[u]);
    }

    for(auto v:g[u])
    {
        if(v!=f&&!vis[v])calc(v,u,k);
    }
}

void dfs_dsu(int u,int f,int keep)
{
    for(auto v:g[u])
    {
        if(v!=hson[u]&&v!=f) dfs_dsu(v,u,0);
    }
    if(hson[u])dfs_dsu(hson[u],u,1),vis[hson[u]]= 1;
    calc(u,f,1);
    ans[u]=mindep-dep[u];
    if(hson[u])vis[hson[u]]=0;
    if(keep==0)calc(u,f,-1),mindep=inf,maxcnt=0;
}

int main()
{
    read(n);
    rep(i,1,n-1)
    {
        int a,b;
        read(a); read(b);
        g[a].pb(b); g[b].pb(a);
    }
    dfs_tree(1,0);
    dfs_dsu(1,0,1);
    rep(i,1,n)printf("%d\n",ans[i]);
    return 0;
}
流苏贺风
关注
专栏目录
启发式合并（dsu），树上启发式合并（dsu on tree）总结
x052xiao的博客
11-06 366
启发式合并（dsu），树上启发式合并（dsu on tree）总结
树上启发式合并
矮纸斜行闲作草
09-29 2139
树上启发式合并算法原理+流程+复杂度 又称dsu on tree,但这个算法和并查集没啥联系，可能借鉴了按秩合并的思想吧。 算法原理+流程+复杂度 参考大佬博客传送 我们先从第一个例题开始看起： E. Lomsat gelral 题意是给定了一个无根树，带点权，q次询问，每次询问某棵子树内，点权众数之和。（如果2 3 4都是众数，那么答案是2+3+4=9) ...
树上启发式合并（DSU on Tree）
wanglianda2007的博客
02-12 388
浅谈树上启发式合并（DSU on Tree）
树上dsu
Freopen的博客
10-27 475
现在有一棵二叉树，所有非叶子节点都有两个孩子。在每个叶子节点上有一个权值(有n个叶子节点，满足这些权值为1…n的一个排列)。可以任意交换每个非叶子节点的左右孩子。 要求进行一系列交换，使得最终所有叶子节点的权值按照遍历序写出来，逆序对个数最少。 n&amp;lt;=200000 这个题其实就是要求出每个非叶子节点的，左儿子中的一个叶子上的值大于右儿子中一个叶子的值，的对数。 树上dsu就是一种启发式合并，...
spoj Query on a tree VII（链分治）
苟为蒟蒻又何妨
02-17 329
传送门 跟QTREE6QTREE6QTREE6神似，改成了求连通块里的最大值。 于是我们对每条链开一个heapheapheap维护一下即可。 MDMDMD终于1A1A1A链分治了。 代码： #include&lt;bits/stdc++.h&gt; #define ri register int #define fi first #define se second using namespace ...
2019.02.17 spoj Query on a tree VI（链分治）
weixin_30278237的博客
02-17 93
传送门 题意简述：给你一棵nnn个黑白点的树，支持改一个点的颜色，询问跟某个点颜色相同的连通块大小。 思路： 还是链分治 233 记fi,0/1f_{i,0/1}fi,0/1​表示iii的所有颜色为0/10/10/1的轻儿子在它们子树中颜色相同的连通块大小。 然后这个可以用来询问子树里的答案，但是要询问的东西是针对全局的。 因此我们沿着重链往上跳更...
树上启发式合并（dsu on tree）
UniverseofHK的博客
01-01 472
Lomsat gelral 之前没有记录过dsu on tree，挑了一个板子题记录一下 DSU on tree（Disjoint Set Union，树上启发式合并） 思想：利用每个节点到根节点路径上的轻边数复杂度是logloglog级别的，同时只有当每次遍历轻边时才会将整棵轻边连接的子树额外暴力遍历一遍，所以每个节点被暴力遍历的次数就是logloglog级别的，这样就保证了整体复杂度在log...
dsu on tree(树上启发式合并)算法总结+习题
mumei的博客
02-03 2714
前几天补了一下在camp中没学到的算法，树上启发式合并，一个O(nlogn)处理树上查询问题比较好的算法（其实就是暴力） 前置知识 学习这个算法之前需要知道一些树链剖分中的概念，不知道也没问题，下面我会给出 节点的大小：以当前节点为根的子树中的节点个数 重儿子：所有儿子节点中大小最大的那个节点 轻儿子：除重儿子之外的儿子节点 至于节点的深度等常见概念就不解释了。 算法思想 先拿一...
CodeForces-600E Lomsat gelral（树上DSU）
Paulliant的博客
08-18 261
题意 给定一个 nnn 个节点的树，对于每个子树，输出子树中出现次数最多的节点编号之和。（次数最多的编号有多个节点都要统计进去）。 1≤n≤1051≤n≤1051 \leq n \leq 10^5 思路 无疑仍是树上 dsudsudsu ，考虑到需要维护节点出现次数最多的编号和，所以实时维护一个数组 cntcntcnt 保存每种编号出现的次数，然后再用两个变量分别保存最多出现次数和答案即可...
「AHOI / HNOI2018」毒瘤 （DDP）（链分治）
01-07
LOJLOJLOJ 传送门 题解：首先考虑一棵树怎么做，就是树形 dpdpdp，然后我们可以枚举每一条边怎么选，显然有 3 种情况 进一步发现只需要枚举两种，即强制 uuu 选 vvv 不选，和强制 uuu 不选 vvv 随意 那么现在的问题就是每次 banbanban 掉一些点选一些点不选，动态更新根节点的 dpdpdp 值 然后把转移写成矩阵的形式链分治，由于可以除 000 所以手写了一个用 x∗0yx*0^yx∗0y 表示每个数的类 复杂度 O(n+k∗2k∗log(n)2)O(n+k*2^k*log(n)^2)O(n+k∗2k∗log(n)2) 被虚树吊打 #include #defi
树上启发式合并（DSU ON TREE）
m0_53899788的博客
05-09 448
算法过程 对于树上的一个节点uuu，按照以下步骤执行： 遍历 uuu 的轻儿子，计算轻儿子的答案，不保留对 uuu 的贡献 遍历 uuu 的重儿子，计算重儿子的答案，保留对 uuu 的贡献 遍历 uuu 的轻儿子，加入其对 uuu 的贡献，得到 uuu 的答案 一般来说，没有修改、只对子树进行询问(或者转化成子树的答案) 就可以用 dsu on tree。 时间复杂度 根节点到任意节点的轻边数不超过 lognlognlogn 条。设根节点 rootrootroot 到节点 uuu 的路径中有 xxx 条
Codeforces-375D Tree and Queries（树上dsu）
Paulliant的博客
08-18 411
题意 给定一棵 nnn 个节点的树，每个节点上有一个颜色。有 mmm 个询问，每次询问 uuu 对应的子树中，有多少种颜色至少出现 kkk 次。 1≤n,m≤1051≤n,m≤1051 \leq n,m \leq 10^5 思路 树上 dsudsudsu 的入门题（即树上启发式合并）。首先，暴力比较好想，对于每一个询问的 uuu ，在 uuu 的子树中统计每种颜色出现的次数，得到出现次...
图论-树上启发式合并(DSU On Tree)
weixin_30815469的博客
08-27 160
Disjoint Set Union On Tree ，似乎是来自 Codeforces 的一种新操作，似乎被叫做“树上启发式合并”。 在不带修改的有根树子树信息统计问题中，似乎树上莫队和这个 DSU On Tree 是两类常规操作。 先对树按轻重链剖分。对于每个节点，先计算轻儿子为根的子树信息，每次计算后消除影响，再去计算其他轻儿子。然后计算重儿子为根的子树信息，不消除影响，并把轻儿子...
【树上静态链分治】【CF741D】Arpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths...
weixin_34281477的博客
03-02 145
Description 给定一棵 \(n\) 个节点的树，每条边上有一个字符，字符集大小 \(22\)，求每个节点的子树内最长的简单路径使得路径上的字符经过重排后构成回文串。 Limitation \(1~\leq~n~\leq~500000,~\text{字符集}~=~['a',~'v']\) Solution 考虑一条路径能构成回文串当且仅当路径上的字符出现奇数次的至多为一个。由于字符集大小很...
优美的暴力——树上启发式合并（dsu on tree）
最新发布
WerChange的OI博客
01-24 1535
非常优美的暴力，把n^2优化成nlogn的神仙算法！
CF741D Arpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths（静态链分治）
ding4440的博客
09-18 209
题目 树上启发式合并（静态链分治）模板题。 首先一个串能重排形成是回文串当且仅当其字符数量最多有一个为奇数。 因此我们只关心路径上某个字符的奇偶性。 所以我们对字符集状压，\(0\)表示偶，\(1\)表示奇。 记\(dis_u\)为\(1\)到\(u\)的路径上的字符集。 那么对于点对\(u,v\)，其路径上的字符集为\(dis_u\oplus dis_v\)。 一条路径的字符集\(S\...
树上启发式合并（DSU on Tree） Study
ICEEBBING的博客
06-04 210
前言 话说很多树上启发式合并的题都可以用线段树合并来实现。 然而对于一些题目还是得用树上启发式合并做，所以要学习一下的。 讲解 对于一个节点做树dp，我们先跑完轻儿子，然后跑重儿子后，父节点就可以承载这个重儿子，所以每次都只用重新跑轻儿子即可。那么时间复杂度就是O(nlogn)O(nlogn)O(nlogn)的。 ...
树上启发式合并（dsu on tree）学习笔记【理解+套路+例题及题解】
birdmanqin的博客
11-20 428
一、理解 先从一个典型的例题开始，树的每个节点都有一个颜色，求某个节点v的子树中颜色c的个数。暴力的话，就是对于每一个节点都统计一下子树中颜色c的个数，复杂度为。现在，我们来优化。可以发现我们做了很多重复的工作，如果能利用一些工作的结果那就好了。这里要引入轻/重儿子的思想（好像就是轻重链，树链剖分。。。。），可以证明从整棵树的根节点到树中任意一点的路径上最多有条轻边。（相关定义及证明请参考博客：https://www.cnblogs.com/zwfymqz/p/9683124.html）。所以我们把重..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

流苏贺风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值