树链剖分---详解

最新推荐文章于 2022-08-09 16:15:25 发布
最新推荐文章于 2022-08-09 16:15:25 发布
阅读量174 收藏 1
点赞数
分类专栏： 笔记 文章标签： 深度优先 图论 算法
原文链接：https://www.cnblogs.com/gzh-red/p/11235038.html
版权

更好的阅读体验点击跳转

更更好的阅读体验点击跳转

导言

你会DFS序吗?

我想,你肯定会说会.不会,欢迎点击搜索和DFS序学习

你会线段树吗?不会,欢迎点击暂无

我想,身为巨佬的你肯定会.

既然巨佬你会DFS序,会线段树.那么接下来的树链剖分,你也一定会.

接下来的学习,您必备的算法知识有,DFS序,线段树.

您可以选修的知识点有树上差分,最近公共祖先

初学算法

适用范围
  1. 将树从x到y结点最短路径上所有节点的值都加上z

我们很容易发现,这个算法就是树上差分算法.

  1. 求树从x到y结点最短路径上所有节点的值之和

Lca大佬们,很容易发现这个其实就是Lca算法,然后通过之前我们所介绍的算法性质.

dis[x]+dis[y]−dis[Lca(x,y)]dis[x]+dis[y]−dis[Lca(x,y)]
的老编号,也就是老名字.

总而言之,这就是我们的目标数组了,看上去好多啊,但其实只要两次DFS就解决完毕了.

代码解析
void dfs1(int x,int father)//father是x的父亲节点
{
    size[x]=1;//刚开始子树为1,也就是直接
    for(int i=head[x]; i; i=Next[i])//访问所有出边
    {
        int y=edge[i];//儿子节点
        if (y==father)//访问到唯一一个不是儿子节点的父亲节点去了
            continue;//当然不可以,直接跳过
        deep[y]=deep[x]+1;//深度+1,儿子节点是父亲节点深度+1
        fa[y]=x;//y的父亲节点是x
        dfs1(y,x);//y的父亲节点是x
        size[x]+=size[y];//加上儿子贡献的子树
        if (size[y]>size[wson[x]])//如果这个节点比当前重儿子,子树还要多(还要重) ,那么营养过剩的重儿子就是他了.
            wson[x]=y;//wson[x]表示x节点的重儿子
    }
}

这一层DFS,就让我们求解出来了前四个数组,那么后三个数组呢?

void dfs2(int x,int tp)//x表示当前节点,tp表示链头
{
    dfn[x]=++cnt;//重新编辑编号
    pre[cnt]=x;//存储老编号
    top[x]=tp;//存储链头
    if (wson[x]) //优先处理重儿子
        dfs2(wson[x],tp);
    for(int i=head[x]; i; i=Next[i])//访问所有的轻链
    {
        int y=edge[i];//存储出边
        if (y==wson[x] || y==fa[x])//重儿子已经处理过了,父亲节点不可以抵达
            continue;
        dfs2(y,y);//每一个轻链的链头,都是自己,而且重儿子的开头都是轻链.
    }
}
算法拓展

咱们知道,树链剖分是LCA+树上差分的合并增强版,那么他们两个有的操作,他当然也得有.

正如同某名言.你的是我的,我的还是我的.

先来看LCA的操作,其实就是其名的求两点的最近公共祖先.

我们对于上面所述的top数组,也就是链头数组,比较懵逼,觉得他似乎没有什么用处啊.

实际上它的用处非常之大,是树链剖分的核心数组之一.

通俗理解的故事,又来了.以下内容纯属瞎编,只为了更好的理解.

AcwingAcwing.

那么我们得出.

因为A小组和B小组是两个没有交集的小组.(也就是互相都不认识)

那么显然A小组这一串人,都不可能成为答案.

同理B小组这一伙人,也不可能成为答案.

明知没有用,何必浪费时间.

所以,我们迅速跨越中间的所有节点.

a=top[a];//直接爬到链头
b=top[b];//直接爬到链头

这样我们发现效率直线上升.

本来我们a节点爬到这条链需要花费O(len(a)).本来我们a节点爬到这条链需要花费O(len(a)).

注意点

还有请注意,每次跳跃的话.
比如说a,b节点要跳跃.
我们每次是将链头深度深的节点往上跳跃,而不本节点的深度.
为了避免出现下面评论所说的情况.
两个节点,跳过去了,跳到了LCA节点的上方去了.

拓展代码
int Query_sum(int a,int b)//a,b这条路径上的权值和
{
    int ans=0;//初始化为0
    while(top[a]!=top[b]) //此时a,b不在同一条重链上面
    {
        if (deep[top[a]]<deep[top[b]])//我们这里默认a是深度在下面的链
            swap(a,b);
        ans+=t.Query_sum(1,1,n,dfn[top[a]],dfn[a]);//访问这条重链,dfn[top[a]]是链头,dfn[a]是当前节点,dfn[top[a]]<dfn[a]因为a后访问.
        a=fa[top[a]];//往上面访问,也就是往上面爬一步
    }
    if (dfn[a]<dfn[b])//保证a深度比b深度,深.保证后面查询l<r
        swap(a,b);
    ans+=t.Query_sum(1,1,n,dfn[b],dfn[a]);//他们已经在同一条重链上面了
    return ans;
}
链上结构
路径操作

看到上面的代码,我们发现t是什么东西.

t其实就是我们的线段树数据结构.

根据树上差分的操作们,得知我们的树链剖分需要复制一大波操作.

  1. 将树从x到y结点最短路径上所有节点的值都加上z

  2. 求树从x到y结点最短路径上所有节点的值之和

根据上面这些操作,我们不难发现,每条链也需要资瓷这些操作.

综上所述得出.

  1. 一条链上,需要资瓷区间修改.
  2. 一条链上,需要支持区间查询.

总而言之,区间操作多多,因此我们使用线段树.

当然了巨佬们,肯定喜欢使用平衡树等等高大上,上档次,有内涵的数据结构,但是线段树的代码复杂度对于考试而言,是最好不过的结构了.

代码复杂度是考试的时候,极为重要的复杂度. by Acwing站长,校长,集训队大佬yxc总裁

总而言之,言而总之,我们树链剖分的代码量,成功的增加了1k.

子树操作

我们再来几个操作.

  1. 将以x为根节点的子树内所有节点值都加上z

  2. 求以x为根节点的子树内所有节点值之和

看到子树操作,有点不知所措,线段树似乎不支持这个鬼东西吧,难道代码量又要翻倍处理.

事实上,我们的代码只需要增加八行代码,也就核心两句话.

我们的DFS遍历,在这里起到了决定性,关键性,核心性的作用.(语文老师:捕捉到了病句,起到了,什么的作用,句式杂糅)

我们发现DFS序列的一个重点,就是.一颗子树,它的DFS序,是有序的.

树链剖分11.png

还是这张图,我们发现熊熊助教这颗子树.

其实就是[2,7][2,7]这个区间,就达到了修改以2为根的树修改.

因此代码如下.

void Update(int x,int v)//修改子树的值
{
    t1.Update(1,1,n,dfn[x],dfn[x]+size[x]-1,v);//DFS序是有序的数列
}

同理,查询操作也就如下所示了.

int Query_sum(int x)//查询子树的和
{
    return t1.Query_sum(1,1,n,dfn[x],dfn[x]+size[x]-1);//统计子树和,其实和修改差不多
}
树链模板
struct line_tree//线段树
{
#define mid (l+r>>1)//二分中点 
#define Lson (rt<<1),l,mid//左儿子 
#define Rson (rt<<1 | 1),mid+1,r//右儿子 
#define Len (r-l+1)//区间长度
    void Push_down(int rt,int l,int r)
    //这里的懒惰标记只适合区间修改,把[l,r]区间都变成v.如果是都+v,则必须Lazy标记+=,而不是下面的=
    {
        if (Lazy[rt]!=-1)//当前节点有Lazy标记
        {
            Lazy[rt<<1]=Lazy[rt<<1 | 1]=Lazy[rt];//懒惰标记下传
            sum[rt<<1]=Lazy[rt]*(mid-l+1);//左儿子的区间长度
            sum[rt<<1 |1]=Lazy[rt]*(r-(mid+1)+1);//右儿子的区间长度
            Lazy[rt]=-1;//此时懒惰标记已经下传完毕了,那么可以全部清空了
        }
    }
    void build(int rt,int l,int r)
    {
        Lazy[rt]=-1;
        if (l==r)//叶子节点
        {
            sum[rt]=1;//sum数组
            return ;
        }
        build(Lson);//左儿子
        build(Rson);//右儿子
        sum[rt]=sum[rt<<1]+sum[rt<<1 |1];//左儿子节点+右儿子节点
    }
    void Update(int rt,int l,int r,int L,int R,int v)//将[L,R]区间统统修改成为v,然后当前区间[l,r]
    {
        if (L<=l && r<=R)//当前区间被包括了
        {
            Lazy[rt]=v;//懒惰标记修改
            sum[rt]=v*Len;//全部修改完毕
            return ;
        }
        Push_down(rt,l,r);//向下传递Lazy标记
        if (L<=mid)//在左儿子身上
            Update(Lson,L,R,v);//左儿子
        if (R>mid)//在右儿子身上
            Update(Rson,L,R,v);//右儿子
        sum[rt]=sum[rt<<1]+sum[rt<<1 |1];//左儿子+右儿子
    }
    int Query_sum(int rt,int l,int r,int L,int R)//查询[L,R]区间和,当前区间[l,r]
    {
        int ans=0;
        if (L<=l && r<=R)//当前区间被包括了
            return sum[rt];
        if (L<=mid)//左儿子上面
            ans+=Query_sum(Lson,L,R);
        if (R>mid)//右儿子上面
            ans+=Query_sum(Rson,L,R);
        sum[rt]=sum[rt>>1]+sum[rt>>1 |1];
        return ans;//返回
    }
} t1;
struct Tree_Chain//树链剖分
{
    void add_edge(int a,int b)//添加边函数
    {
        edge[++tot]=b;//出边节点
        Next[tot]=head[a];//链表链接
        head[a]=tot;//上一个节点
    }
    void dfs1(int x,int father)//x节点,和他的父亲节点father
    {
        size[x]=1;//刚开始就自己这一个节点
        for(int i=head[x]; i; i=Next[i]) //开始遍历所有的出边
        {
            int y=edge[i];//出边节点
            if (y==father)//儿子节点是不可以等于父亲节点的
                continue;
            deep[y]=deep[x]+1;//儿子的深度,是父亲深度+1
            fa[y]=x;//y的父亲节点是x
            dfs1(y,x); //开始遍历儿子节点
            size[x]+=size[y];//儿子节点贡献子树大小
            if (size[y]>size[wson[x]]) //发现当前的儿子节点,比之前的重儿子,还要重(胖),那么更新重儿子
                wson[x]=y;//更新
        }
        return ;//华丽结束
    }
    void dfs2(int x,int tp)//x节点,以及x节点所在链的链头
    {
        dfn[x]=++cnt;//当前节点的新编号,也就是DFS序编号
        pre[cnt]=x;//老编号,虽然在整道题目中没有用处,但是树链剖分板子打一遍也是好的
        top[x]=tp;//链头存储一下
        if (wson[x])//有重儿子,那么一定先访问重儿子
            dfs2(wson[x],tp); //访问节点,此时重儿子一定在重链上,所以还是tp
        for(int i=head[x]; i; i=Next[i]) //访问所有的轻儿子
        {
            int y=edge[i];//出边
            if (y==wson[x] || y==fa[x])//轻儿子节点不能是重儿子,也不能是父亲节点
                continue;
            dfs2(y,y);//每一个轻儿子,他的链头其实都是自己,而且重链的开头也得是轻儿子
        }
    }
    void Update(int x,int v)//修改子树的值
    {
        t1.Update(1,1,n,dfn[x],dfn[x]+size[x]-1,v);//DFS序是有序的数列
    }
    int Query_sum(int x)//查询子树的和
    {
        return t1.Query_sum(1,1,n,dfn[x],dfn[x]+size[x]-1);//统计子树和,其实和修改差不多
    }
    long long Query_sum2(int a,int b)//a,b这条路径上的权值和
    {
        long long ans=0;//初始化为0
        while(top[a]!=top[b]) //此时a,b不在同一条重链上面
        {
            if (deep[top[a]]<deep[top[b]])//我们这里默认a是深度在下面的链
                swap(a,b);
            now_ans=0;
            t1.Query_sum(1,1,n,dfn[top[a]],dfn[a]);
            ans+=now_ans;//访问这条重链,dfn[top[a]]是链头,dfn[a]是当前节点,dfn[top[a]]<dfn[a]因为a后访问.
            a=fa[top[a]];//往上面访问,也就是往上面爬一步
        }
        if (deep[a]<deep[b])//保证a深度比b深度,深.保证后面查询l<r
            swap(a,b);
        now_ans=0;
        t1.Query_sum(1,1,n,dfn[top[a]],dfn[a]);
        ans+=now_ans;//他们已经在同一条重链上面了
        return ans;
    }
    int Update2(int a,int b) //链上修改 
    {
        while(top[a]!=top[b])//也就是两个点还在不同的重链上
        {
            if (deep[top[a]]<deep[top[b]])//我们默认a节点是深度比b节点深一些
                swap(a,b);//交换一下就好了
            t1.Update(1,1,n,dfn[top[a]],dfn[a],0);//在爬的过程中,也帮忙修改一下
            a=fa[top[a]];//往上面爬一下
        }
        if (deep[a]<deep[b])//保证a深度比b深度,深.保证后面查询l<r
            swap(a,b);
        t1.Update(1,1,n,dfn[b],dfn[a],0);//同一条链了,那么修改这条链上在[a,b]之间的点 
    }
    //请注意,本模板是很多题目的操作合并而成,可能有问题,但是单独没有问题.如果有问题请艾特博主.
    //所有代码风格为博主风格,所以操作之间都是通用的,应该不会出现问题.
} t2;

经典选讲

第一题 模板题[HAOI2015]树上操作

题目描述

有一棵点数为 NN ，之后接这个操作的参数（ x 或者 x a ） 。

输出格式：

对于每个询问操作，输出该询问的答案。答案之间用换行隔开。

输入输出样例
输入样例#1：
5 5
1 2 3 4 5
1 2
1 4
2 3
2 5
3 3
1 2 1
3 5
2 1 2
3 3
输出样例#1：
6
9
13
数据范围

对于 100100 。

题意理解

一棵树上,要求支持单点修改,子树修改,路径修改操作.

思路解析

学会了树连剖分的我们,很轻松的发现,这就是一个树链剖分的模板题目.

所以说,我们几乎是可以轻松解决这道题目了.

树链剖分超级详解,可以媲美全网第一通俗树链剖分讲解了

于是我们惊奇的发现一道省选题目,就这样轻松愉快地AC了.

代码超多中文解释,绝对看得懂.

代码解析
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int N=5e5+200;
int sum[N<<2],Lazy[N<<2];//处理区间和;懒惰标记
int head[N<<1],edge[N<<1],ver[N<<1],Next[N<<1],tot;
int pre[N],deep[N],size[N],a[N],fa[N],cnt;
int wson[N],dfn[N],top[N],n,m,now_ans;
struct line_tree
{
#define mid ((l+r)>>1) //二分值 
#define lson root<<1,l,mid //左儿子 
#define rson root<<1|1,mid+1,r //右儿子 
#define len (r-l+1) //区间长度 
    void build(int root,int l,int r)
    {
        if (l==r)//抵达叶子节点,也就是单个节点
        {
            sum[root]=a[pre[l]];
            return ;
        }
        build(root<<1,l,mid);//左儿子
        build(root<<1 | 1,mid+1,r);//右儿子
        sum[root]=sum[root<<1]+sum[root<<1 | 1];//左右儿子都访问完毕了,可以更新父亲节点了.
    }
    inline void Push_down(int x,int lenn)
    {
        Lazy[x<<1]+=Lazy[x];//左儿子得到,父亲节点的懒惰标记下传
        Lazy[x<<1 | 1]+=Lazy[x];//右儿子得到,父亲节点的懒惰标记下传
        sum[x<<1]+=Lazy[x]*(lenn-(lenn>>1));//懒惰标记的值叠加
        sum[x<<1 | 1]+=Lazy[x]*(lenn>>1);//懒惰标记的值叠加
        Lazy[x]=0;//懒惰标记已经下传
    }
    inline void Query_sum(int root,int l,int r,int L,int R)//目标区间ql,qr,当前区间[l,r],当前节点是root
    {
        if(L<=l&&r<=R)//目标区间包含了当前区间
        {
            now_ans+=sum[root];//累加
            return;//返回
        }
        else
        {
            if(Lazy[root])//有标记
                Push_down(root,len);//先走标记
            if(L<=mid)//左儿子上有
                Query_sum(lson,L,R);
            if(R>mid)//右儿子上
                Query_sum(rson,L,R);
        }
    }
    inline void Update(int root,int l,int r,int L,int R,int k)//目标区间[L,R]全部要加上K,当前区间[l,r]
    {
        if (L<=l && r<=R)//[L,R]包括了当前区间[l,r]
        {
            Lazy[root]+=k;//叠加懒惰标记
            sum[root]+=k*len;
            return ;
        }
        if (Lazy[root])//有懒惰标记
            Push_down(root,len);//下传标记
        if (L<=mid)
            Update(lson,L,R,k);//左儿子
        if (R>mid)
            Update(rson,L,R,k);//右儿子
        sum[root]=sum[root<<1]+sum[root<<1 |1];
    }
} t1;
struct Tree_Chain
{
    inline void add_edge(int a,int b)
    {
        edge[++tot]=b;
        Next[tot]=head[a];
        head[a]=tot;
    }
    void dfs1(int x,int father)//fa是x的父亲节点
    {
        size[x]=1;//刚开始子树为1,也就是直接
        for(int i=head[x]; i; i=Next[i])//访问所有出边
        {
            int y=edge[i];//儿子节点
            if (y==father)//访问到唯一一个不是儿子节点的父亲节点去了
                continue;//当然不可以,直接跳过
            deep[y]=deep[x]+1;//深度+1,儿子节点是父亲节点深度+1
            fa[y]=x;//y的父亲节点是x
            dfs1(y,x);//y的父亲节点是x
            size[x]+=size[y];//加上儿子贡献的子树
            if (size[y]>size[wson[x]])//如果这个节点比当前重儿子,子树还要多(还要重) ,那么营养过剩的重儿子就是他了.
                wson[x]=y;//wson[x]表示x节点的重儿子
        }
    }
    void dfs2(int x,int tp)//x表示当前节点,tp表示链头
    {
        dfn[x]=++cnt;//重新编辑编号
        pre[cnt]=x;//存储老编号
        top[x]=tp;//存储链头
        if (wson[x]) //优先处理重儿子
            dfs2(wson[x],tp);
        for(int i=head[x]; i; i=Next[i])//访问所有的轻链
        {
            int y=edge[i];//存储出边
            if (y==wson[x] || y==fa[x])//重儿子已经处理过了,父亲节点不可以抵达
                continue;
            dfs2(y,y);//每一个轻链的链头,都是自己,而且重儿子的开头都是轻链.
        }
    }
    long long Query_sum(int a,int b)//a,b这条路径上的权值和
    {
        long long ans=0;//初始化为0
        while(top[a]!=top[b]) //此时a,b不在同一条重链上面
        {
            if (deep[top[a]]<deep[top[b]])//我们这里默认a是深度在下面的链
                swap(a,b);
            now_ans=0;
            t1.Query_sum(1,1,n,dfn[top[a]],dfn[a]);
            ans+=now_ans;//访问这条重链,dfn[top[a]]是链头,dfn[a]是当前节点,dfn[top[a]]<dfn[a]因为a后访问.
            a=fa[top[a]];//往上面访问,也就是往上面爬一步
        }
        if (deep[a]<deep[b])//保证a深度比b深度,深.保证后面查询l<r
            swap(a,b);
        now_ans=0;
        t1.Query_sum(1,1,n,dfn[top[a]],dfn[a]);
        ans+=now_ans;//他们已经在同一条重链上面了
        return ans;
    }
    inline void update_son(int x,int k)
    {
        t1.Update(1,1,n,dfn[x],dfn[x]+size[x]-1,k);
        //因为DFS所以子树其实是有序的,而且一个子树大小是size[x],那么dfn+size-1就可以遍历整棵树
    }
} t2;
signed main()//其实就是int main()
{
//  freopen("stdin.in","r",stdin);
//  freopen("a.out","w",stdout);
    scanf("%lld%lld",&n,&m);
    for(int i=1; i<=n; i++)
        scanf("%lld",&a[i]);
    for(int i=1; i<n; i++)
    {
        int a,b;
        scanf("%lld%lld",&a,&b);
        t2.add_edge(a,b);
        t2.add_edge(b,a);//无向图建立边
    }
    t2.dfs1(1,0);//第一次DFS,求size,deep,fa
    t2.dfs2(1,1);//第二DFS求dfn,top
    t1.build(1,1,n);
    while(m--)
    {
        int k,a,b,c;
        scanf("%lld",&k);
        if (k==1)
        {
            scanf("%lld%lld",&a,&b);
            t1.Update(1,1,n,dfn[a],dfn[a],b);//虽然是区间修改[dfn[a],dfn[a]],但是其实是单点修改.
        }
        if (k==2)
        {
            scanf("%lld%lld",&a,&b);
            t2.update_son(a,b);//修改a以及子树,统统增加b
        }
        if (k==3)
        {
            scanf("%lld",&a);
            printf("%lld\n",t2.Query_sum(1,a));
        }
    }
    return 0;
}
红和黑
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分详解
算法小猪的博客
08-13 1304
目录一、树链剖分相关概念1.为啥要剖分2.轻边和重边3.轻重边路径剖分的性质二、树链剖分的实现1.重链剖分 一、树链剖分相关概念 1.为啥要剖分 1.可以维护树路径上的信息(维护) 2.将一棵树划分成若干条链，用数据结构去维护每条链，复杂度为O(logN)O(logN)O(logN)。(复杂度低) 2.轻边和重边 将树中的边分为：轻边和重(zhong)边 定义size(x)size(x)size(x)为以xxx为根的子树的节点个数。 令vvv为xxx的儿子节点中sizesizesize值最大的节点，那么边(
luogu P3398 仓鼠找sugar（树链剖分、求树上两条路径有没有交点，爽！）
繁凡さん的博客
10-22 219
舒服，一次敲160行代码一次编译通过一次AC是真的爽！ 虽然这道题可以当作简单版的树链剖分板子题了hhh 要求的是两条路径有没有交点，正解是LCA玄学证明，看的我有点懵，但是这道题可以用树链剖分呀，1e5的数据我们nlognnlognnlogn的树链剖分随便做。 问两条路径有没有交点，实际上我们可以直接用树链剖分直接暴力跑还不会超时，真的爽！我们只需要每次暴力将两条路径权值+1，然后线段树维护一个最大值，看 tr[1].maxv 是不是等于2，如果等于2说明一定有一个点被赋值两次，所以一定是交点！（就算要.
【数据结构】树链剖分 (图文代码详解)
qq_49688477的博客
08-09 1287
树链剖分算法图文详解
树链剖分 简单讲解
Lee_w_j__的博客
01-29 243
如果我们想对一棵树上一个节点到另一个节点的路径进行求和，求极值，修改等操作，单单借助线段树是远远不够的，这个时候我们就需要借用树链剖分的帮助。 树链剖分，顾名思义，树链，指的是树上的路径，剖分就是把树上的各条路径分为重链，轻链。 套用卿学姐的话，树链剖分其实就是一个对树上属性进行hash的一个过程，将树型结构hash成链式结构，再将这些链放至线段树，树状数组等数据结构来解决问题。 学习树链剖
树链剖分笔记——luogu P3384 【模板】树链剖分
Love_mona的博客
02-21 426
蒟蒻的垂死挣扎听说树剖很简单树剖大概算一种思想吧，通过一种巧妙的方式把一棵树的节点有序地排在一个一维数组里，使得其相关询问可以通过线段树等数据结构来维护。那么难点就在这了，这个巧妙的方法到底是什么呢？首先引入几个概念：重结点：子树结点数目最多的结点；轻节点：父亲节点中除了重结点以外的结点；重边：父亲结点和重结点连成的边；轻边：父亲节点和轻节点连成的边；重链：由多条重边连接而成的路径；轻链：由多条轻...
NOIP 树链剖分 NOIP 树链剖分
10-30
### NOIP 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作...
树链剖分
09-22
### 树链剖分知识点详解 #### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了有效地处理树结构中的路径查询和更新问题。通过将树分解为一系列的链（即重链），可以显著提高算法的效率。这样做的...
某静态的超仙人掌_吴作凡 & 倪星宇.pptx
09-14
本文主要介绍了一种特殊的图结构——静态仙人掌，并讲解了如何利用树链剖分技术处理静态仙人掌上的问题。静态仙人掌是指每条边最多属于一个简单环的连通图，而超仙人掌则在此基础上进行拓展。以下是详细的知识点解析...
第十五届蓝桥杯大赛软件赛知识点大纲
最新发布
01-07
- 树链剖分（7-8级难度）：对树进行分解，优化对树的操作。 - 二维/动态开点线段树（7-8级难度）：处理二维或多维区间问题。 - 平衡树（8-9级难度）：自平衡的二叉搜索树，如AVL树、红黑树。 - 可持久化数据结构...
poj 2763 Housewife Wind 【树链剖分维护树上权值和】
大神养成中.....
11-10 3600
题目：poj 2763 Housewife Wind 题意：给一个数，边之间有权值，然后两种操作，第一种：求任意两点的权值和，第二，修改树上两点的权值。 分析：很基础的一个树链剖分维护树上权值和，第二道树链剖分题目，也错了好几次。而且这个题目卡vector。有点坑。 AC代码： #include #include #include #include usin
树链剖分(初学)
weixin_43823476的博客
09-19 159
首先看一下树链剖分是什么东西： 当我们要同时解决以下两个问题时： 1.求树上两点简单路径上的最大最小值(和） 2.修改树上两点简单路径上的边权(点权) 如果只用单独考虑，那么第一个就是树上差分，第二个是倍增，可是如果同时要有两个操作，那么时间复杂度就会大幅度退化，所以现在要用一个新的方法：树链剖分 它将一棵树剖成了几条链来组成，且每个点最多只会存在一条链上，且只出现一次。那么怎么进行剖分...
树链剖分正确的入门姿势
小布丁童学
07-31 1331
树链剖分并不是一个复杂的算法或者数据结构，只是能把一棵树拆成链来处理而已，换一种说法，树链剖分只是xxx数据结构/算法在树上的推广，或者说，树链剖分只是把树hash到了几段连续的区间上。（引用kuangbin大佬的）
P3384 【模板】树链剖分 题解&&树链剖分详解
weixin_30438813的博客
09-24 131
题外话： 一道至今为止做题时间最长的题： begin at 8.30A.M 然后求助_yjk dalao后 最后一次搞取模： awsl。 正解开始： 题目链接。 树链剖分，指的是将一棵树通过两次遍历后将一棵树分成重链，轻边的过程。 我们定义： 重儿子：每个点的子树中，子树大小(即节点数)最大的子节...
树链剖分总结
Greninja的博客
07-02 743
树链剖分总结
10.4 最短路径相关算法——点权、边权、最短路径条数（基础算法）
小魚兒
10-30 1587
#include <cstdio> #include <vector> using namespace std; //单源最短路径——Dijkstra算法 //1、伪代码 //G为图，一般设成全局变量 ，数组d为源点到达各点的最短路径长度 /*Dijstra(G,d[],s) { 初始化； for(循环n次) { u=使d[u]最小的还未被访问的顶点的标号 ...
NOIP树链剖分详解与实现
"NOIP树链剖分是用于优化树形结构数据的处理效率的一种算法，常用于解决涉及树路径信息维护的问题。该算法的主要目标是将一棵树划分为若干条链，每条链的数据结构可以高效地进行操作，使得在树上进行查询或更新操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值