ACM算法总结 树上问题

最新推荐文章于 2020-07-13 14:03:00 发布
最新推荐文章于 2020-07-13 14:03:00 发布
阅读量1.2k 收藏 7
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM算法总结 文章标签： 算法 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dragonylee/article/details/104091056

目录



简介

树是一种联通无向非循环图，对于 n 个结点的树来说有 n-1 条边；如果不要求联通，我们称之为森林。

在数据结构中有很多实用的树形结构，但是大多数都是基于二叉树的结构，这里更多地讨论一般树形结构。

关于树的一些名词定义：

  • 根：人为指定的一个结点；
  • 结点深度：从根结点到该结点的路径上的边数；
  • 树的高度：结点深度的最大值；
  • 叶结点：度数为 1 的非根结点；
  • 父亲、祖先、儿子、兄弟、后代：顾名思义即可

存储二叉树我们一般用数组存储，用 k<<1 和 k<<1|1 表示两个儿子，用 k>>1 表示父亲，对于一般树使用邻接表的存储方法（类似图），可以新开 f 数组记录父亲结点，或者在搜索时传递父亲以区分上下关系。




树的直径

从任意一个结点开始 bfs 找到最远结点，再从最远结点开始 bfs 找到最远结点，这个距离就是直径。




树的重心

定义：树上所有结点到重心的距离之和最小。 这等价于对于每一个点，取其所有子树中最大的结点数，这个数最小的就是重心。

求解方法就和定义类似，我们 dfs 的时候计算出每一个子树的结点数，然后取其中最大的那个，更新答案。

代码如下：

const int maxn=1e5+5;
vector<int> G[maxn];
int n,root,siz[maxn],max_siz=maxn;

void get_root(int u,int fa)
{
    int maxx=0; siz[u]=1;
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i];
        if(v==fa) continue;
        get_root(v,u);
        siz[u]+=siz[v];
        maxx=max(maxx,siz[v]);
    }
    maxx=max(maxx,n-siz[u]);
    if(maxx<max_siz || (maxx==max_siz && u<root)) max_siz=maxx,root=u;
}




树链剖分

下图为一棵树的树链剖分（重链剖分）：

树链剖分把一棵树分为若干条不相交的重链，连接这些重链的树边称为轻链，一些名词定义如下：

  • 重儿子：所有儿子中子树最大的儿子结点（如有多个任取）；
  • 轻儿子：除了重儿子之外的所有儿子；
  • 重边：父亲和重儿子的连边；
  • 轻边：父亲和轻儿子的连边；

注意单个结点我们也看成一条重链，这样整棵树就被划分为若干条不相交的重链，而每条重链有一个顶端结点（图中蓝色结点），表示这条重链的起始结点，也是这条重链中深度最小的结点。除此之外，重链的 dfn（dfs序，图中红色数字）一定是连续的。

树链剖分的过程就是两次 dfs 的过程，第一次处理 f、siz、d、son（父亲，子树大小，深度，重儿子），第二次处理 dfn、which、top（dfs序，dfn的逆（即dfs序为 i 的结点编号为which[i]），结点所在重链的起始结点）。注意第二次 dfs 要优先搜索重儿子。

代码如下：

const int maxn=1e6+5;
vector<int> G[maxn];
int n,m,root,cnt,a[maxn];
int siz[maxn],f[maxn],d[maxn],son[maxn],dfn[maxn],which[maxn],top[maxn];

void dfs1(int u,int fa,int depth)
{
    f[u]=fa; d[u]=depth; siz[u]=1; son[u]=0;
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i];
        if(v==fa) continue;
        dfs1(v,u,depth+1);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]]) son[u]=v;
    }
}

void dfs2(int u,int tf)
{
    top[u]=tf; dfn[u]=++cnt; which[cnt]=u;
    if(!son[u]) return;
    dfs2(son[u],tf);
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i];
        if(v!=f[u] && v!=son[u]) dfs2(v,v);
    }
}

树链剖分本身只是一种对树形结构的操作，进行按重链划分，但它对于处理树上问题很有帮助。比如说对于 洛谷P3384重链剖分 ，要求维护结点 u 和 v 路径上的权值和以及某一结点的子树权值和。

由于同一条重链的 dfn 是连续的，所以我们可以用线段树维护 dfn 序列的权值和。对于两个结点路径权值和，我们将两个结点不停往上跳重链，每跳一次对线段树更新一次；对于某一结点子树权值和，发现子树的 dfn 也是连续的，我们通过子树根结点和其 siz 值计算出应该更新的 dfn 区间，然后更新线段树。

还有一种树链剖分后不维护点权，而是维护边权，这个时候我们可以把边变成一个点，然后与原来的两端的点相连，这样就转换为点权了。




LCA

最近公共祖先（Least Common Ancestor），即两个结点 u 和 v 的所有祖先中最深的那个，该结点必然在 u 和 v 的路径上。

  • d i s t ( u , v ) = d ( u ) + d ( v ) − 2 d ( L C A ( u , v ) ) dist(u,v)=d(u)+d(v)-2d(LCA(u,v)) dist(u,v)=d(u)+d(v)−2d(LCA(u,v))，其中 d 为深度，或者是某个结点到根的距离；

将树进行树链剖分之后，求解LCA就转变为对两个结点不停地往上跳重链（u=f[top[u]]），直到两个结点在同一条重链为止，这时比较浅的那个就是LCA。这里要注意往上跳重链的时候，要优先跳起始结点比较深的那个。

代码如下：

int LCA(int x,int y)
{
    while(top[x]!=top[y])
        d[top[x]]>d[top[y]]?(x=f[top[x]]):(y=f[top[y]]);
    return d[x]<d[y]?x:y;
}

还有一种倍增的方法也可以求解LCA。

  • 可换根的LCA：结点 u 和结点 v 的以 w 为根的LCA就是 LCA(u,v)、LCA(u,w)、LCA(v,w) 中最深的那个。




点分治

点分治用来处理树上路径问题。

对于某一个有根树，树上的路径分为两种：经过根的和不经过根的。但是不经过根的路径一定是某一棵子树上经过根的路径。所以树上的路径可以都看作是经过根的路径。要处理某一路径信息时，我们可以对子树选取一个根，然后枚举其儿子，统计儿子的路径信息，然后合并到总路径信息列表中，对下一个儿子处理时同时根据已有的总路径信息判断某一条件是否成立，这样的话就可以处理当前子树经过根的所有路径信息。处理完当前子树后对所有儿子所在子树递归处理即可。

对于某一子树，我们选取其重心作为树根，这样保证复杂度为 O(nlogn) 级别。

对于 洛谷P3806 点分治1 ，要求判断树上是否存在长度为 k 的路径，代码如下：

const int maxn=1e5+5;
struct edge {int v,w;};
vector<edge> G[maxn];
int n,m,root,siz[maxn],max_siz=maxn;
int e[maxn],dis[maxn],all_dis[maxn],tot,all_tot;
bool is[maxn*100],vis[maxn],ans[maxn];

void get_root(int u,int fa)
{
    int maxx=0; siz[u]=1;
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i].v;
        if(v==fa || vis[v]) continue;
        get_root(v,u);
        siz[u]+=siz[v];
        maxx=max(maxx,siz[v]);
    }
    maxx=max(maxx,n-siz[u]);
    if(maxx<max_siz || (maxx==max_siz && u<root)) max_siz=maxx,root=u;
}

void dfs(int u,int fa,int depth)
{
    dis[tot++]=depth;
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i].v,w=G[u][i].w;
        if(v==fa || vis[v]) continue;
        dfs(v,u,depth+w);
    }
}

void solve(int s)
{
    vis[s]=1; is[0]=1;
    all_tot=0;
    REP(i,0,G[s].size()-1)
    {
        int v=G[s][i].v,w=G[s][i].w;
        tot=0;
        dfs(v,s,w);
        REP(j,0,tot-1) REP(k,1,m)
            if(dis[j]<=e[k] && is[e[k]-dis[j]]) ans[k]=1;
        REP(j,0,tot-1) all_dis[all_tot++]=dis[j],is[dis[j]]=1;
    }
    REP(i,0,all_tot-1) is[all_dis[i]]=0;
    REP(i,0,G[s].size()-1)
    {
        int v=G[s][i].v;
        if(vis[v]) continue;
        root=0; max_siz=maxn;
        get_root(v,s);
        solve(root);
    }
}

int main()
{
    //freopen("input.txt","r",stdin);
    n=read(),m=read();
    REP(i,1,n-1)
    {
        int u=read(),v=read(),w=read();
        G[u].push_back((edge){v,w});
        G[v].push_back((edge){u,w});
    }
    REP(i,1,m) e[i]=read();
    get_root(1,0);
    solve(root);
    REP(i,1,m) puts(ans[i]?"AYE":"NAY");

    return 0;
}

以及对于 洛谷P4178 Tree ，要求统计长度小于等于 K 的路径数目，在统计某一子树的根的儿子的总路径信息时，我们用线段树维护长度区间路径数目即可。




支配树

给定一个有向图 G，并且给定一个起始结点 s，对于某一个结点 x，如果从 s 到 x 的路径中一定经过某个结点 y，那么就说 y 是 x 的支配点。

支配树是一个这样的东西：根结点为 s，某个结点 x 的祖先都是它的支配点。

可以看出支配树有这样的性质：

  • 所有和 s 连通的结点（s 可以到达的结点）都会在支配树中，因为任意结点一定存在一个支配点 s；
  • 结点 x 的父亲为其最近支配点；

求解支配树的过程有点复杂，我还没有学完，不过板子是有的了。

代码：

struct dominant_tree
{
    #define maxn 500005
    VI a[maxn],b[maxn],c[maxn],t[maxn];
    int dfn[maxn],which[maxn],f[maxn],cnt,n,root;
    int sdom[maxn],idom[maxn],far[maxn],val[maxn];

    void dfs(int u,int fa)
    {
        dfn[u]=++cnt; which[cnt]=u; f[u]=fa;
        for(int v:a[u]) if(!dfn[v]) dfs(v,u);
    }

    int find(int x)
    {
        if(x==far[x]) return x;
        int t=find(far[x]);
        if(dfn[sdom[val[far[x]]]]<dfn[sdom[val[x]]]) val[x]=val[far[x]];
        return far[x]=t;
    }

    void tarjan()
    {
        REP_(i,cnt,2)
        {
            int u=which[i];
            for(int v:b[u]) if(dfn[v])
            {
                find(v);
                if(dfn[sdom[val[v]]]<dfn[sdom[u]]) sdom[u]=sdom[val[v]];
            }
            c[sdom[u]].pb(u);
            far[u]=f[u]; u=f[u];
            for(int v:c[u])
            {
                find(v);
                if(sdom[val[v]]==u) idom[v]=u;
                else idom[v]=val[v];
            }
        }
        REP(i,2,cnt)
        {
            int u=which[i];
            if(idom[u]!=sdom[u]) idom[u]=idom[idom[u]];
        }
    }

    void build(int n,int root,vector<P> E)
    {
        this->n=n; this->root=root; cnt=0;
        REP(i,0,n) a[i].clear(),b[i].clear(),c[i].clear(),t[i].clear();
        REP(i,0,n) sdom[i]=val[i]=far[i]=i;
        REP(i,0,n) idom[i]=dfn[i]=f[i]=which[i]=0;
        for(P e:E)
        {
            int u=e.first,v=e.second;
            a[u].pb(v); b[v].pb(u);
        }
        dfs(root,0);
        tarjan();
        REP(i,1,n) if(i!=root) t[idom[i]].pb(i);
    }
};

指定有向图结点个数 n、起始结点 root 以及边集 E，调用 build 就可以构建出支配树，里面的 t 存储支配树的树形结构。




树上最长路

这是一个这样的问题：给出一棵带边权的树，让你求出每个结点到其它结点的最长路。

我们可以随意指定一个根 root，然后第一次 dfs 可以算出每个结点的子树中的最长路 down[i] ，然后考虑如何在第二次 dfs 时计算出每个结点祖先的最长路 up[i] 。可以用一张图形象表示：

我们在 dfs 结点 u 时已经得到了 up[u]，然后我们需要计算出它每一个儿子的 up 。对于每一个儿子，用 down[v]+w 去更新维护的一个最大值和次大值，计算完 down[v]+w 的最大值和次大值之后，对于每一个儿子，如果它不是最大值的那个儿子，那么有 up[v]=w+max(up[u], 最大值)；如果它是最大值的那个儿子，那么有 up[v]=w+max(up[u], 次大值) 。这样对于每个结点，max(up[u], down[u]) 就是它到其它结点的最长路。

这道题 Computer 的代码：

#include <bits/stdc++.h>
#define mem(a,b) memset(a,b,sizeof(a))
#define REP(i,a,b) for(int i=(a);i<=(int)(b);i++)
#define REP_(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
using namespace std;
typedef long long LL;
typedef vector<int> VI;
typedef pair<int,int> P;
int read()
{
    int x=0,flag=1;
    char c=getchar();
    while((c>'9' || c<'0') && c!='-') c=getchar();
    if(c=='-') flag=0,c=getchar();
    while(c<='9' && c>='0') {x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return flag?x:-x;
}

const int maxn=1e4+5;
struct edge {int v,w;};
vector<edge> G[maxn];
int n,up[maxn],down[maxn];

void dfs_down(int u,int fa)
{
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i].v,w=G[u][i].w;
        if(v==fa) continue;
        dfs_down(v,u);
        down[u]=max(down[u],down[v]+w);
    }
}

void dfs_up(int u,int fa)
{
    if(!fa && G[u].size()==0) return;
    if((!fa && G[u].size()==1) || (fa && G[u].size()==2))
    {
        int v=G[u][0].v,w=G[u][0].w;
        if(v==fa) v=G[u][1].v,w=G[u][1].w;
        up[v]=up[u]+w;
        dfs_up(v,u);
    }
    int max1=0,max2=0,u1,u2;
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i].v,w=G[u][i].w;
        if(v==fa) continue;
        if(down[v]+w>max1) max2=max1,u2=u1,max1=down[v]+w,u1=v;
        else if(down[v]+w>max2) max2=down[v]+w,u2=v;
    }
    REP(i,0,G[u].size()-1)
    {
        int v=G[u][i].v,w=G[u][i].w;
        if(v==fa) continue;
        if(v==u1) up[v]=w+max(max2,up[u]);
        else up[v]=w+max(max1,up[u]);
        dfs_up(v,u);
    }
}

int main()
{
    while(~scanf("%d",&n))
    {
        REP(i,1,n) G[i].clear(),up[i]=down[i]=0;
        REP(i,2,n)
        {
            int v=read(),w=read();
            G[i].pb((edge){v,w});
            G[v].pb((edge){i,w});
        }
        dfs_down(1,0);
        dfs_up(1,0);
        REP(i,1,n) printf("%d\n",max(down[i],up[i]));
    }

    return 0;
}

这里计算最大值和次大值时，如果儿子个数少于2那就不用这么麻烦了，所以在 dfs_up 一开始有一个讨论的过程。

【ACM】树 小结
( :3 )
01-19 837
树是一种表达层级结构的数据结构，也是实现高效算法与数据结构的基础。 学习之前的基础：数组，循环处理，结构体，递归函数。 树：由结点（node）和连接结点的边（edge）构成。             一、树的相关基本概念： 双亲（父母/前件），子女（孩子/后件），双亲和子女的关系是相对而言的。 兄弟：若几个结点的双亲为同一个结点，则这些结点互称为兄弟。 祖先：将从树根到某一结点K的路...
树上问题
Yangxiansen——Nextdoor
10-03 874
树 树的存储 无根树 有根树 无根树转有根树 有根树转无根树 树上的路径长度 树的直径 树的中心 树上两点间距离 查询 kkk 级祖先 树上动态规划 有根树求 LCALCALCA 暴力 记忆化暴力 倍增 ...
NOIP树上问题总结
weixin_30493321的博客
09-12 319
这几年考了好几次树上问题： NOIP2012 疫情控制(二分答案+倍增+贪心) NOIP2013 货车运输(最大生成树+倍增) NOIP2014 联合权值(勉强算作树形dp的傻逼题) NOIP2015 运输计划(二分答案+树上差分+最近公共祖先) NOIP2016 天天爱跑步(树上差分+树上倍增) 可以说除了联合权值外都有一定的难度，(关键是我不抄题解一道也做不出来) 去年没考树上的...
ACM主要算法
harmony的专栏
04-20 2882
ACM主要算法 ACM主要算法介绍 初期篇 一、基本算法 (1)枚举(poj1753, poj2965) (2)贪心(poj1328, poj2109, poj2586) (3)递归和分治法 (4)递推 (5)构造法(poj3295) (6)模拟法(poj1068, poj2632, poj1573, poj2993, poj2996) 二、图算法 (1)图的深度优先
树上问题归纳
weixin_30655569的博客
06-16 361
。 转载于:https://www.cnblogs.com/a-blog-of-taojiayi-2003/p/11032148.html
2016年ACM常用算法总结
01-11
在ACM竞赛中，图论算法用来解决各种涉及网络、路由、最短路径、最小生成树等问题。 7. **数据结构**：数据结构是计算机存储、组织数据的方式。在ACM竞赛中，数据结构的选择和实现直接影响到算法的效率。常见的数据...
ACM算法竞赛-ACM资源
最新发布
05-13
ACM算法竞赛是计算机领域内的一项重要赛事，它主要面向大学生群体，要求参赛者具备扎实的算法和编程基础，以及在短时间内解决复杂问题的能力。这项竞赛不仅仅考察算法知识，还包括团队合作、问题分析、以及编写高效...
一类子树问题的总结
weixin_30336061的博客
03-28 159
以下问题均允许离线，根节点都为1。 prob1 : 一棵有根树，要求线性时间求出任意子树的权值和。 prob2 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的节点的权值和。 prob3 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的不同颜色种类个数，颜色数不超过1E6。 prob4 : 一颗有根数，要求O(nlogn+大常数)求出与u距离不超...
2020.02.06日常总结——树上问题
ZHUYINGYE_123456的博客
02-06 394
树上dp\color{green}{树上dp}树上dp 顾名思义，即树上的dp问题。 有两种转移方式：一是从根转移到叶子，二是从叶子转移到根。在实际应用中，从叶子转移到根的方式应用的更多。 树上dp在实现起来的时候，可能需要配合贪心等其它高效的算法，甚至于线段树等高效数据结构。 代码实现起来的时候，常常用递归实现，因为树的定义就是递归定义的。同时，一定要注意不要从一个点又转移回了它的父亲，否则，...
ACM技能树加点
zsdostar
06-08 1738
来源于知乎SimonS的回答（zhihu.com/question/23148377/answer/36824071）初期（校赛及省赛水题难度）:一.基本算法:枚举. (poj1753,poj2965)贪心(poj1328,poj2109,poj2586)递归和分治法.递推.构造法.(poj3295)模拟法.(poj1068,poj2632,poj1573,poj2993,poj2996)二.图算法
树上处理的问题总结
weixin_30387339的博客
06-20 159
树的直径 也就是树的最长路径的长度 做法 求2次DFS，第一次DFS找到当前距离根节点最远的点(叶节点)，然后以这个点出发再做一次DFS，找到最远的点。可以证明这个距离即是树上的最长路径。 //hdu4607 //树的直径，树上最长的链的顶点的个数 #include <cstdio> #include <cstring> #include <str...
一类树上问题的总结
weixin_42465242的博客
01-03 407
目录 方法一 优点 缺点 方法二 优点 缺点 例题： - CF70E Information Reform - P3267 [JLOI2016/SHOI2016]侦察守卫 ...
acm-树
weixin_43460331的博客
05-08 301
树 一棵树是由n（n>0）个元素组成的有限集合，其中：（1）每个元素称为结点(node)；（2）有一个特定的结点，称为根结点或树根（root）；（3）除根结点外，其余结点能分成m（m>=0）个互不相交的有限集合T0,T1,T2,……Tm-1。其中的每个子集又都是一棵树，这些集合称为这棵树的子树。 输的基本概念： A.一个结点的子树个数，称为这个结点的度； 度为0的结...
总结一些树的问题
qq_34471804的博客
11-20 249
#965. Univalued Binary Tree 用DFS来解决这个问题，如果根存在，就把节点的值放在数组中，然后继续遍历它的左右子节点。最后判断数组中元素是否都相等就可以了。相同就是独一无二的树。 function dfs(root,val) { if(root) { val.push(root.val); dfs(root.left,val);...
树的重心---解释和模板
bensanhuan的博客
07-13 636
树的重心 使用背景： 对一颗无根树，求重心.(当然，对一棵树，究竟是有根还是无根，完全自己说了算)， 感性定义： 作为根时，能使各子树节点数目"均衡"的节点。 明确定义： 设f(x)f(x)f(x)表示节点xxx为根时，所有子树中的最大子树节点数。f(x)f(x)f(x)最小的节点即这颗无根树的重心。 性质： 以树的重心为根时，所有子树的大小都不超过整棵树大小的一半。 树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么到它们的距离和一样。 把两棵树通过一条边相连得到一棵新的树，那么
ACM树和数据结构
zhonglong_lin的博客
10-15 1733
ACM树和数据结构 树这个结构是真的神奇，很多算法和复杂一点的数据结构，都是以树为基础的， 因为树结构的可以再很快的时间（logn）去解决很多问题。 比如 去做一个dfs搜索，实际上就是一个状态空间上的搜索树。 然后就是线段树、平衡树、动态树、Trie树（前缀树）。都用来解决一些特殊的问题。 下面从头开是讲树 0、树的结构和性质 大部分数据结构书上都说了，总结一下，就是1对n， 实现上：三种实现方...
树问题总结
weixin_44233369的博客
08-13 350
二叉树的结构 class Node<V>{ V value; Node left; Node right; } 二叉树的遍历 分别是前序、中序、后续、层序遍历。 //递归实现的前序遍历 static void preOrderRecur(Node* head){ if(head == NULL) return; ...
基于在树上走的DP问题
weixin_30678349的博客
08-15 164
笔者已经很久没有打过题解了，如果打题解，就总是要连着一个知识点来打题解。 最近做过一共两道这样的题目。笔者认为这样的题有较强的可拓展性，比较...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值