树链剖分原理、实现及例题

最新推荐文章于 2021-07-11 15:23:06 发布
最新推荐文章于 2021-07-11 15:23:06 发布
阅读量273 收藏
点赞数
分类专栏： 树链剖分 追逐星光之路（OI旅程，与诸君共勉）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CQBZLYTina/article/details/81534487
版权

参考博文：
http://www.cnblogs.com/George1994/p/7821357.html

知识点

重结点：子树结点数目最多的结点；
轻节点：父亲节点中除了重结点以外的结点；
重边：父亲结点和重结点连成的边；
轻边：父亲节点和轻节点连成的边；
重链：由多条重边连接而成的路径；
轻链：由多条轻边连接而成的路径；

dfs1用来计算出一些上述的值
而dfs2则是从根节点开始，连重边成重链，以便于后面的线段树等数据结构的操作

例题 Query on a tree系列
Query on a tree
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAXN 50005
#define INF 0x3fffffff
#define lch rt<<1
#define rch rt<<1|1
int n,dcnt;
int val[MAXN],siz[MAXN],top[MAXN],son[MAXN];
int dep[MAXN],tid[MAXN],rnk[MAXN],fa[MAXN],belong[MAXN];
struct Tnode{
    int v,w,id;
    Tnode *next;
}Edge[MAXN*2];
Tnode *Adj[MAXN],*ecnt;
struct Snode{
    int mx;
}Seg[MAXN*4];

void Init()
{
    memset(Adj,0,sizeof(Adj));
    memset(son,-1,sizeof(son));
    dcnt=0;
    ecnt=&Edge[0]; 
}

void AddEdge(int u,int v,int w,int id)
{
    Tnode *p=++ecnt;
    p->v=v,p->w=w,p->id=id,p->next=Adj[u],Adj[u]=p;
    p=++ecnt;
    p->v=u,p->w=w,p->id=id,p->next=Adj[v],Adj[v]=p;
}

void dfs1(int u,int f,int d)
{
    dep[u]=d;
    fa[u]=f;
    siz[u]=1;
    for(Tnode *p=Adj[u];p!=NULL;p=p->next)
    {
        int v=p->v;
        int id=p->id;
        if(v==f) continue;
        belong[id]=v;
        val[v]=p->w;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(son[u]==-1||siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    tid[u]=++dcnt;
    rnk[dcnt]=u;
    if(son[u]==-1)
        return ;
    dfs2(son[u],tp);
    for(Tnode *p=Adj[u];p!=NULL;p=p->next)
    {
        int v=p->v;
        if(v==son[u]||v==fa[u])
            continue;
        dfs2(v,v);
    }
}
void Pushup(int rt)
{
    Seg[rt].mx=max(Seg[lch].mx,Seg[rch].mx);
}
void Build(int rt,int l,int r)
{
    if(l==r)
    {
        Seg[rt].mx=val[rnk[l]];
        return ;
    }
    int mid=(l+r)>>1;
    Build(lch,l,mid);
    Build(rch,mid+1,r);
    Pushup(rt);
}
void update(int rt,int l,int r,int pos,int val)
{
    if(l==r)
    {
        Seg[rt].mx=val;
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid)
        update(lch,l,mid,pos,val);
    else update(rch,mid+1,r,pos,val);
    Pushup(rt);
}
int Query(int rt,int l,int r,int st,int ed)
{
    if(st<=l&&r<=ed)
        return Seg[rt].mx;
    int mid=(l+r)>>1;
    int ret=-INF;
    if(st<=mid)
        ret=max(ret,Query(lch,l,mid,st,ed));
    if(ed>mid)
        ret=max(ret,Query(rch,mid+1,r,st,ed));
    return ret;
}
void Change(int i,int val)
{
    int u=belong[i];
    update(1,2,n,tid[u],val);
}
int Ask(int u,int v)
{
    int ans=-INF;
    while(top[u]!=top[v])
    {
        if(dep[top[u]]<dep[top[v]])
            swap(u,v);
        ans=max(ans,Query(1,2,n,tid[top[u]],tid[u]));
        u=fa[top[u]];
    }
    if(dep[u]>dep[v])
        swap(u,v);
    if(u!=v)
        ans=max(ans,Query(1,2,n,tid[u]+1,tid[v]));
    return ans;
}
int main()
{
    int cs;
    scanf("%d",&cs);
    while(cs--)
    {

        Init();
        scanf("%d",&n);
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            AddEdge(u,v,w,i);
        }
        dfs1(1,1,1);
        dfs2(1,1);
        Build(1,2,n);
        char s[50];
        int u,v;
        while(1)
        {
            scanf("%s",s);
            if(s[0]=='D')
                break;
            scanf("%d %d",&u,&v);
            if(s[0]=='Q')
                printf("%d\n",Ask(u,v));
            else Change(u,v);
        }
    }
}
Query on a tree II
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 10010
#define INF 0x3fffffff
#define lch rt<<1
#define rch rt<<1|1
struct Tnode{
    int v,w,id;
    Tnode *next;
}edge[MAXN*2];
Tnode *Adj[MAXN],*ecnt;
struct Snode{
    int sum;
}Seg[MAXN*4];
int n,k,dcnt;
int val[MAXN],siz[MAXN],top[MAXN],son[MAXN],dep[MAXN],tid[MAXN],rnk[MAXN],fa[MAXN];
int belong[MAXN];

void Init()
{
    memset(Adj,0,sizeof(Adj));
    memset(son,-1,sizeof(son));
    dcnt=0;
    ecnt=&edge[0]; 
}
void AddEdge(int u,int v,int w,int id)
{
    Tnode *p=++ecnt;
    p->v=v,p->w=w,p->id=id,p->next=Adj[u],Adj[u]=p;
    p=++ecnt;
    p->v=u,p->w=w,p->id=id,p->next=Adj[v],Adj[v]=p;
}
void dfs1(int u,int f,int d)
{
    dep[u]=d;
    fa[u]=f;
    siz[u]=1;
    for(Tnode *p=Adj[u];p!=NULL;p=p->next)
    {
        int v=p->v,id=p->id;
        if(v==f) continue;
        belong[id]=v;
        val[v]=p->w;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(son[u]==-1||siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    tid[u]=++dcnt;
    rnk[dcnt]=u;
    if(son[u]==-1)
        return ;
    dfs2(son[u],tp);
    for(Tnode *p=Adj[u];p!=NULL;p=p->next)
    {
        int v=p->v;
        if(v==fa[u]||v==son[u])
            continue;
        dfs2(v,v);
    }
}
void Pushup(int rt)
{
    Seg[rt].sum=Seg[lch].sum+Seg[rch].sum;
}
void Build(int rt,int l,int r)
{
    if(l==r)
    {
        Seg[rt].sum=val[rnk[l]];
        return ;
    }
    int mid=(l+r)>>1;
    Build(lch,l,mid);
    Build(rch,mid+1,r);
    Pushup(rt);
}
int Query(int rt,int l,int r,int st,int ed)
{
    if(st<=l&&r<=ed)
        return Seg[rt].sum;
    int mid=(l+r)>>1;
    int ret=0;
    if(st<=mid)
        ret+=Query(lch,l,mid,st,ed);
    if(ed>mid)
        ret+=Query(rch,mid+1,r,st,ed);
    return ret;
}
int Ask(int u,int v,bool typ)
{
    int ans=0,tu=u,tv=v;
    while(top[u]!=top[v])
    {
        if(dep[top[u]]<dep[top[v]])
            swap(u,v);
        ans+=Query(1,2,n,tid[top[u]],tid[u]);
        u=fa[top[u]];
    }
    if(dep[u]>dep[v])
        swap(u,v);
    int lca=u;
    if(u!=v)
        ans+=Query(1,2,n,tid[u]+1,tid[v]);
    if(!typ)
        return ans;
    if(dep[tu]-dep[lca]+1<k)
    {
        k-=dep[tu]-dep[lca]+1;
        k=dep[tv]-dep[lca]-k+1;
        tu=tv;
    }
    while(dep[top[tu]]>dep[lca])
    {
        int dis=dep[tu]-dep[top[tu]]+1;
        if(dis>=k) break;
        k-=dis;
        tu=fa[top[tu]];
    }
    return rnk[tid[tu]-k+1];
}
int main()
{
    int cs;
    char s[10];
    scanf("%d",&cs);
    while(cs--)
    {
        Init();
        scanf("%d",&n);
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            AddEdge(u,v,w,i);
        }
        dfs1(1,1,1);
        dfs2(1,1);
        Build(1,2,n);
        while(~scanf("%s",s))
        {
            if(s[1]=='O')
                break;
            int u,v;
            scanf("%d %d",&u,&v);
            if(s[1]=='I')
                printf("%d\n",Ask(u,v,0));
            else 
            {
                scanf("%d",&k);
                printf("%d\n",Ask(u,v,1));
            }
        }
    }
    return 0;
}
Query on a tree again!
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAXN 100005
#define INF 0x3fffffff
#define lch rt<<1
#define rch rt<<1|1
int n,m,dcnt;
int val[MAXN],siz[MAXN],top[MAXN],son[MAXN];
int dep[MAXN],tid[MAXN],rnk[MAXN],fa[MAXN];
struct Tnode{
    int v;
    Tnode *next;
}Edge[MAXN*2];
Tnode *Adj[MAXN],*ecnt;
struct Snode{
    int sum;
}Seg[MAXN*4];
void Init()
{
    memset(Adj,0,sizeof(Adj));
    memset(son,-1,sizeof(son));
    dcnt=0;
    ecnt=&Edge[0]; 
}
void AddEdge(int u,int v)
{
    Tnode *p=++ecnt;
    p->v=v,p->next=Adj[u],Adj[u]=p;
    p=++ecnt;
    p->v=u,p->next=Adj[v],Adj[v]=p;
}
//--------------------------------------------------------
void dfs1(int u,int f,int d)
{
    dep[u]=d;
    fa[u]=f;
    siz[u]=1;
    for(Tnode *p=Adj[u];p!=NULL;p=p->next)
    {
        int v=p->v;
        if(v==f) continue;
        dfs1(v,u,d+1);
        siz[u]+=siz[v];
        if(son[u]==-1||siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    tid[u]=++dcnt;
    rnk[dcnt]=u;
    if(son[u]==-1)
        return ;
    dfs2(son[u],tp);
    for(Tnode *p=Adj[u];p!=NULL;p=p->next)
    {
        int v=p->v;
        if(v==son[u]||v==fa[u])
            continue;
        dfs2(v,v);
    }
}

//---------------------------------------------------------------
void pushup(int rt)
{
    Seg[rt].sum=Seg[lch].sum+Seg[rch].sum;
}
void build(int rt,int l,int r)
{
    if(l==r)
    {
        Seg[rt].sum=0;
        return ;
    }
    int mid=(l+r)>>1;
    build(lch,l,mid);
    build(rch,mid+1,r);
    pushup(rt);
}
void update(int rt,int l,int r,int pos)
{
    if(l==r)
    {
        Seg[rt].sum^=1;
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid)
        update(lch,l,mid,pos);
    else update(rch,mid+1,r,pos);
    pushup(rt);
}
int ask(int rt,int l,int r)
{
    if(!Seg[rt].sum) return -1;
    if(l==r) return l;
    int mid=(l+r)>>1;
    if(!Seg[lch].sum) return ask(rch,mid+1,r);//优先左区间，左区间没有返回右区间
    else return ask(lch,l,mid);
}
int query(int rt,int l,int r,int st,int ed)//查找路径上的第一个黑点的tid
{
    if(!Seg[rt].sum) return -1;//没有黑点
    if(l==st&&r==ed)
        return ask(rt,l,r);
    int mid=(l+r)>>1;
    if(ed<=mid) return query(lch,l,mid,st,ed);
    else if(st>mid) return query(rch,mid+1,r,st,ed);
    else//横跨左右儿子
    {
        int res=query(lch,l,mid,st,mid);//tid在线段树中有序，优先左区间，左区间没有才找右区间
        if(res==-1) return query(rch,mid+1,r,mid+1,ed);
        else return res;
    }
}
int sol(int u)
{
    int res=-1,t;
    while(top[u]!=1)//目标：走到节点1所在重链，就能顺着该重链到节点1
    {
        t=query(1,1,n,tid[top[u]],tid[u]);//沿着重链向上爬，查找这一条重链上的第一个黑点
        if(t!=-1) res=rnk[t];//越往上，答案越优，所以不断更新
        u=fa[top[u]];//走一条轻边，爬另一条重链
    }
    if(u==1) t=query(1,1,n,1,1);
    else t=query(1,1,n,1,tid[u]);
    if(t!=-1) res=rnk[t];
    return res;
}
int main()
{
    Init();
    scanf("%d %d",&n,&m);
    int u,v;
    for(int i=1;i<=n-1;i++)
    {
        scanf("%d %d",&u,&v);
        AddEdge(u,v);
    }
    dfs1(1,1,1);
    dfs2(1,1);
    build(1,1,n);
    int opt;
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d",&opt,&u);
        if(opt) printf("%d\n",sol(u));
        else update(1,1,n,tid[u]);
    }
}
Query on a tree IV
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;
#define MAXN 100010
#define INF 0x3f3f3f3f
int n,m,dcnt;
int tid[MAXN],top[MAXN],rnk[MAXN],sz[MAXN],fa[MAXN],son[MAXN],fav[MAXN];
int presum[MAXN*4],cnt,col[MAXN],root[MAXN];
multiset<int> ch[MAXN],ansx;
bool flagx[MAXN*4];
struct node{
    int pl,pr,v,maxl,maxr;
}tree[MAXN*4];
void read(int& x)
{
    char c;
    bool flag=0;
    while(c=getchar(),c!=EOF&&(c<'0'||c>'9')&&c!='-');
    if(c=='-'){flag=1;c=getchar();}
    x=c-'0';
    while(c=getchar(),c!=EOF&&c>='0'&&c<='9')   x=x*10+c-'0';
    if(flag)    x=-x;
}
vector<int> a[MAXN],va[MAXN];
//-----------------------------------------------------
int Query(int x,int y)
{
    if(x>y) swap(x,y);
    return presum[y]-presum[x];
}
void dfs1(int x,int fax)
{
    fa[x]=fax;
    sz[x]=1;
    son[x]=-1;
    for(int i=0;i<a[x].size();i++)
        if(a[x][i]!=fax)
        {
            dfs1(a[x][i],x);
            sz[x]+=sz[a[x][i]];
            if(son[x]==-1||sz[son[x]]<sz[a[x][i]])
                son[x]=a[x][i];
        }
        else fav[x]=va[x][i];//顶点x与它父亲的边权
}
void dfs2(int x,int tp)
{
    top[x]=tp;
    tid[x]=++dcnt;
    sz[tp]++;
    if(x!=tp)
        presum[dcnt]=presum[tid[fa[x]]]+fav[x];
    rnk[dcnt]=x;
    if(son[x]==-1) return ;
    dfs2(son[x],tp);
    for(int i=0;i<a[x].size();i++)
        if(a[x][i]!=son[x]&&a[x][i]!=fa[x])
            dfs2(a[x][i],a[x][i]);
}
void Merge(int u,int x,int y,int l,int r)
{
    int mid=(l+r)>>1;
    flagx[u]=1;
    tree[u].maxl=max(tree[y].maxl+Query(l,mid+1),tree[x].maxl);//以左端点出发（含），向右的最大
    tree[u].maxr=max(tree[x].maxr+Query(mid,r),tree[y].maxr);//以右端点出发（含），向左的最大
    tree[u].v=max(tree[x].maxr+tree[y].maxl+Query(mid,mid+1)/*跨越左右儿子*/,max(tree[x].v/*在左儿子*/,tree[y].v/*在右儿子*/));
}
void update(int x,int id)
{
    int d1=-INF,d2=-INF;
    flagx[id]=1;
    if(ch[x].size()!=0)
        d1=*(ch[x].rbegin());//按从小到大排序 rbegin()是最大 由于是迭代器 *表示取值
    if(ch[x].size()>1)
        d2=*(++ch[x].rbegin());//d1,d2取出最长的链和次长的链
    if(col[x]==0)
    {
        tree[id].maxl=max(d1,0);
        tree[id].maxr=max(d1,0);
        tree[id].v=max(0,max(d1,d1+d2));
    }
    else
    {
        tree[id].maxl=d1;
        tree[id].maxr=d1;
        tree[id].v=max(-INF,d1+d2);
    }
}
void build(int l,int r,int id,bool flag)
{
    if(l==r)
    {
        int x=rnk[l];
        for(int i=0;i<a[x].size();i++)
        {
            int y=a[x][i];
            if(y!=fa[x]&&top[y]!=top[x])
            {
                root[y]=++cnt;// 每一条链都建了一颗线段树
                build(tid[y],tid[y]+sz[y]-1,root[y],1);
                ch[x].insert(tree[root[y]].maxl+va[x][i]);//上传信息
            }
        }
        update(x,id);
        if(flag==1)
            ansx.insert(tree[id].v);
    }
    else
    {
        int mid=(l+r)>>1;
        tree[id].pl=++cnt;
        tree[id].pr=++cnt;
        build(l,mid,tree[id].pl,0);
        build(mid+1,r,tree[id].pr,0);
        Merge(id,tree[id].pl,tree[id].pr,l,r);
        if(flag==1)
            ansx.insert(tree[id].v);
    }
}
vector<int> path,pathv;
void find_path(int x)
{
    while(x!=0)
    {
        path.push_back(x);
        pathv.push_back(fav[top[x]]);
        x=fa[top[x]];
    }
}
void modify(int l,int r,int id,int i,bool flag)
{
    if(l==r)
    {
        int x=rnk[l];
        if(i!=0)
        {
            int ne=top[path[i-1]];
            ch[x].erase(ch[x].find(tree[root[ne]].maxl+pathv[i-1]));
            modify(tid[ne],tid[ne]+sz[ne]-1,root[ne],i-1,1);
            ch[x].insert(tree[root[ne]].maxl+pathv[i-1]);
        }
        if(flag)
            ansx.erase(ansx.find(tree[id].v));
        update(x,id);
        if(flag)
            ansx.insert(tree[id].v);
    }
    else
    {
        int mid=(l+r)>>1;
        if(tid[path[i]]<=mid)
            modify(l,mid,tree[id].pl,i,0);
        else    modify(mid+1,r,tree[id].pr,i,0);
        if(flag)
            ansx.erase(ansx.find(tree[id].v));
        Merge(id,tree[id].pl,tree[id].pr,l,r);
        if(flag)
            ansx.insert(tree[id].v);
    }
}
//-----------------------------------------------------
int u,v,q,sum,val;
char t[10];
int main()
{
    scanf("%d",&n);
    sum=0;
    for(int i=1;i<n;i++)
    {
        read(u),read(v),read(val);
        a[u].push_back(v);
        a[v].push_back(u);
        va[u].push_back(val);
        va[v].push_back(val);
    }
    dfs1(1,0);
    memset(sz,0,sizeof(sz));
    dfs2(1,1);
    root[1]=1;
    cnt=1;
    build(tid[1],tid[1]+sz[1]-1,1,1);
    scanf("%d",&q);
    for(int i=1;i<=q;i++)
    {
        scanf("%s",t);
        if(t[0]=='C')
        {
            read(u);
            if(!col[u]) 
                sum++;
            else sum--;
            col[u]^=1;
            path.clear();
            pathv.clear();
            find_path(u);
            modify(tid[1],tid[1]+sz[1]-1,root[1],path.size()-1,1);
        }
        else
        {
            if(sum==n)
                printf("They have disappeared.\n");
            else if(sum==n-1)
                printf("0\n");
            else 
                printf("%d\n",*ansx.rbegin());
        }
    }
}
一句话总结：

树链剖分就是将树形结构转化为线性结构，通过将树划分成许多条链然后再利用线段树等数据结构进行维护，后续操作与树本身并没有什么关系，即对原树不再进行修改。

杏花疏影里_吹笛到天明
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分小结及题目
每一次AC都是一种感动
08-04 3669
我们经常会遇到这样一类题目：给出一棵树，询问树上u,v两点路径间的最值，合值，更新u，v路径上的点权或边权，或者区间更新etc，此时如果单纯的用线段树或者树状数组去搞，很明显问题不能够得到完美解决，此时就需要更高级的数据结构去对树进行重新构造，也就是通常说的树链剖分。 一．树链剖分 树链剖分，顾名思义，也就是对树的每一条链进行剖分，将一棵树拆分成若干条链，对其进行重新编号，在进行了重新编
NOIP 树链剖分 NOIP 树链剖分
10-30
NOIP 树链剖分 NOIP 树链剖分
树链剖分题集
帅比王的博客
10-12 1451
树链剖分常用于处理静态树上操作，效率很高，写起来也就是固定的轻重边拆分+线段树，但是代码一般都是100行+，容易出错。 本题集中的树链剖分练习题，在解决思路上没什么难点，主要是如何设计线段树以及如何更新+询问，也就是说要想好怎么维护线段树，其它地方没什么太难的，但是代码长就容易出bug，多写写就好了。最后一题是线段树动态开点，这和可持久化权值线段树（动态主席树）一样的思想，只需要将普通的线段树给稍...
树链剖分-入门题目
CodeDream
11-12 1345
Query on a tree 题目链接: http://vjudge.net/problem/SPOJ-QTREE 题目大致意思就是: 给你一棵树,有连个操作:       ● 第一个是查询任意两个不同节点上的最短路径上的最大权边!       ● 第二个操作修改某一条边的权值; 对于一棵树,数的深度如果很大,那么每次查询两个叶子节点,时间复杂度还是很高的。所以我们就把树分成一
专题·树链剖分【including 洛谷·【模板】树链剖分
樱狸✨愿携清风归来处
05-03 6332
初见安~~~终于学会了树剖~~~ 【兴奋】当初机房的大佬在学树剖的时候我反复强调过：“学树剖没有前途的！！！” 恩。真香。 一、重链与重儿子 所谓树剖——树链剖分，就是赋予一个链的概念来优化一些或者说是应对一些操作的，所以相应的会有一些专用的概念定义。 一个节点的重儿子，为其更大的一颗子树的根节点。从这个点连向重儿子的边我们称为重边。 这里我们定义子树的大小是取决于节点的数量，而...
树链剖分个人题目总结
关祺
03-17 665
首先，想要学树链剖分基础的朋友们很抱歉请换篇博客看，，，这是个题目总结 ////////////////////////////////// 本蒟蒻求不被大佬嘲讽。。。。 ////////////////////////////////// 树剖啊啊，记得高一时因“运输计划”一题需要此算法，还不会线段树的我便去网上看。。。嗯嗯。。结果可想而知。。从此有了心理阴影。。 其实树剖没那么恶心，
树链剖分算法.pptx
09-03
树链剖分，计算机术语，指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、BST、SPLAY、线段树等）来维护每一条链
第5章 树链剖分 测试数据.rar
12-02
在本章的测试数据中，你将有机会实践和理解树链剖分的原理及其应用。 树链剖分的基本思想是将一棵树通过深度优先搜索（DFS）进行分割，使得每个节点到根节点的路径上，边被分为若干个连续的链。这些链的长度通常...
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
bzoj4515 [Sdoi2016]游戏（树链剖分+超哥线段树）
Coco_T的博客
01-15 323
题目链接 分析： 这道题要是让我做，就是模拟暴力 我们的目的是通过这道题学习一下超哥线段树 在树上的区间修改，维护最小值 可以立刻联想到树链剖分用线段树维护最小值 但是这个disdis让人很不爽啊 显然s~t的路径可以分成s~lca和lca~t两条路径 令deep[x]deep[x]表示xx的深度， 对于s~lca上面的点xx，修改的值相当于a∗(deep[s]−deep[x])
树链剖分题目大集
TheWayForDream
07-11 415
树链剖分题目大集如果还没学树链剖分的伙伴可以跳转到下面的博客1.模板题 P3384 【模板】轻重链剖分/树链剖分2.洛谷-P3379 【模板】最近公共祖先（LCA）（强行用树剖写LCA）3.洛谷-P2590 [ZJOI2008]树的统计4.P3038 [USACO11DEC]Grass Planting G5.P3178 [HAOI2015]树上操作6.树链剖分+线段树 2019ICPC西安邀请赛E7.HDU - 5052 树链剖分主要是解决对于树上路径的修改和查询操作，常常结合线段树来出题，使用线段树维护
LibreOJ #139 树链剖分 [树链剖分，线段树]
weixin_30530939的博客
06-25 106
　　题目传送门 树链剖分 题目描述 这是一道模板题。 给定一棵n个节点的树，初始时该树的根为1号节点，每个节点有一个给定的权值。下面依次进行m个操作，操作分为如下五种类型： 换根：将一个指定的节点设置为树的新根。 修改路径权值：给定两个节点，将这两个节点间路径上的所有节点权值（含这两个节点）增加一个给定的值。 修改子树权值：给定一个...
一篇自己都看不懂的树链剖分学习笔记
weixin_30437337的博客
11-24 117
树链剖分是一个比较好理解的数据结构，码量不是很大（如果你发现你写的很多，那么一定是线段树的锅） PS：树链剖分默认为重链剖分，长链剖分和实链剖分（LCT）以后有时间再写 One.树链剖分用来干啥 树链剖分的基本应用是对一段路径上或者一棵子树的点的点权进行修改，并且对路径或者子树内的点权进行查询操作。树链剖分本身的复杂度为$O(nlogn)$，但是因为它经常要与线段树、树状数组等$log$数据...
树链剖分详解
热门推荐
a_forever_dream的博客
07-09 1万+
树链剖分，正如其名，这个算法的主要思想就是 把“树”“剖分”成“链” 那怎么实现以及它的作用是什么呢，以洛谷上的模板题为例子： 已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作： 操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z 操作2： 格式： 2 x y 表示求树从x到y结点最短...
浅谈树链剖分
cdy1206473601的博客
01-28 4377
什么是树链剖分？ 指一种对树进行划分的算法，它先通过轻重边剖分将树分为多条链，保证每个点属于且只属于一条链，然后再通过数据结构（树状数组、SBT、SPLAY、线段树等）来维护每一条链,主要用来维护树上每条链的极值或和之类的。 类似 首先把树上倍增摆在前面，如果不会树上倍增就不必来看树链剖分。 为什么要学树链剖分？ 有的人说：“我会树上倍增，我怕谁？”，没错，你怕的就是树链...
树链剖分原理和实现
weixin_30746117的博客
11-12 117
树链剖分原理和实现.mdhtml {overflow-x: initial !important;}.CodeMirror { height: auto; } .CodeMirror-scroll { overflow-y: hidden; overflow-x: auto; } .CodeMirror-lines { padding: 4px 0px; } .CodeMir...
树链剖分专题训练及相应题目总结（洛谷）
weixin_45677913的博客
04-10 534
树链剖分练习题（原题单链接） 最近花了一点时间完成了前不久题单还剩下的一些部分，现在小小的做一个总结，个人感觉树链剖分题目类型还是很有规律的，都是可以做的，可能我还遇到特别难得题吧。我觉得树链剖分最主要的就是怎么与线段树结合将路径信息转变成区间线段信息，以及在线段树中懒标记的使用，而且树链剖分代码量有点大，所以需要很细心。 [USACO11DEC]Grass Planting G 这道题就是把边权...
Aragorn 树链剖分
最新发布
09-24
Aragorn 树链剖分是一种将一棵树剖分为若干条链的算法，然后利用数据结构去维护每一条链的技术。剖分完毕后，每条重链相当于一段区间，然后可以使用数据结构去维护整个树。具体过程是通过两次深度优先搜索来实现的：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值