树链剖分（1）

---恢复内容开始---

对于一个树的图，有如下概念

重结点：子树结点数目最多的结点；

轻节点：父亲节点中除了重结点以外的结点；

重边：父亲结点和重结点连成的边；

轻边：父亲节点和轻节点连成的边；

重链：由多条重边连接而成的路径；

轻链：由多条轻边连接而成的路径；

基本原理，就是对于一组树形的数据结构的操作区间取值，采用将树分成链，然后利用数据结构（线段树、树状数组等）来维护这些链。

siz[u]	保存以u为根的子树节点个数　　　 dfs1
top[u]	保存当前节点所在链的顶端节点　　dfs2
son[u]	保存重儿子　　　　　　　　　　　　dfs1
dep[u]	保存结点u的深度值　　　　　　　　dfs1
faz[u]	保存结点u的父亲节点　　　　　　　　dfs1
tid[u]	保存树中每个节点剖分以后的新编号（DFS的执行顺序）　　dfs2
rnk[u]	保存当前节点在树中的位置　　　　　　　　　　　　　　dfs2

还有两条性质：

如果(u, v)是一条轻边，那么size(v) < size(u) / 2； ps：因为重点是子节点数最多的了

从根结点到任意结点的路所经过的轻重链的个数必定都小与O(logn)；

再次想一想我们需要什么

***节点的重儿子son数组

***该节点的父亲f数组

***节点的根节点top数组

***该节点的子节点个数siz数组

***该节点的深度dep数组

***dfs中该节点被访问的顺序did数组

***dfs中访问顺序所对应的节点

两次dfs

维护线段树

进行LCA查询操作

如果改查一个节点和其子树————dfs序查询一个节点和其子树————dfs序 + 线段树维护
如果改查一条链或者不同链上的任意两个点，线段树就不够了需要用到LCA并且利用top数组实现优化，快速计算

初始准备工作：

//https://www.luogu.org/problemnew/show/P3384
//https://www.cnblogs.com/George1994/p/7821357.html
#include <iostream>
#include <cstdio>
#include <string.h>
#include <cmath>
#include <algorithm>
#define inf (1 << 28)
#define lson rt<<1,left,mid
#define rson rt<<1|1,mid+1,right
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
typedef long long ll;
int n,m,root,Mod;//节点个数，操作个数，根节点序号，取模数
const int maxn = 1e5 + 1e3;
int V[maxn];
//step1 构建线段树
ll lazy[maxn<<2];//经典之lazy标记
ll val[maxn<<2];//树中的节点对应的值（树中的节点就是dfs的序号）
/*dfs1*/
int siz[maxn];
int dep[maxn];
int son[maxn];
int fa[maxn];
/*dfs2*/
int did[maxn];//dfs序对应的原数据的节点值 --- 通过节点得知dfs序号
int rnk[maxn];//这个节点的值对应的dfs序 --- 通过序号得知节点号
int top[maxn];
int tot;
struct node{
    int to,pre;
}e[maxn << 1];
int id[maxn],cnt;

两次dfs得到我们所需要的东西

void dfs1(int rt,int f,int depth)
{
    fa[rt] = f;
    dep[rt] = depth;
    siz[rt] = 1;

    for(int i = id[rt];~i;i = e[i].pre)
    {
        int to = e[i].to;
        if(to != f)
        {
            dfs1(to,rt,depth+1);
            siz[rt] += siz[to];
            if(siz[to] > siz[son[rt]])
                son[rt] = to;
        }
    }

}
void dfs2(int now,int rt)
{
    top[now] = rt;
    did[now] = ++tot;
    rnk[tot] = now;

    if(son[now])
        dfs2(son[now],rt);
    else
        return;

    for(int i = id[now];~i;i = e[i].pre)
    {
        int to = e[i].to;
        if(to != fa[now] && to != son[now])
        {
            dfs2(to,to);
        }
    }
}

然后对一些必要数据的初始化

void init()
{
    memset(id,-1,sizeof(id));
    memset(siz,0,sizeof(siz));
    memset(son,0,sizeof(son));
    cnt = 0;
    tot = 0;
}
void add(int from,int to)
{
    e[cnt].to = to;
    e[cnt].pre = id[from];
    id[from] = cnt++;
}

然后针对线段树的常规操作

void pup(int rt)
{
    val[rt] = val[ls] + val[rs];
}
void build(int rt,int left,int right)
{
    lazy[rt] = 0;
    if(left == right)
        val[rt] = V[rnk[left]];
    else
    {
        int mid = (left + right) >> 1;
        build(lson);
        build(rson);
        pup(rt);
    }

    /*
    PS:rt就是rt，我要访问也是通过left和right来访问操作，所以不必如此
    */
}
void pdown(int rt,int left,int right)
{
    if(lazy[rt])
    {
        int lt = lazy[rt];
        int mid = (left + right) >> 1;
        val[ls] += (mid - left + 1) * lt;
        val[rs] += (right - mid) * lt;

        lazy[rs] += lt;
        lazy[ls] += lt;
        lazy[rt] = 0;
    }
}
void update(int rt,int left,int right,int l,int r,ll k)
{
    if(l <= left && right <= r)
    {
        val[rt] += (right - left + 1) * k;
        lazy[rt] += k;
        return;
    }
    if(left > r || right < l)return;

    pdown(rt,left,right);

    int mid = (left + right) >> 1;
    if(left <= mid)
        update(lson,l,r,k);
    if(right > mid)
        update(rson,l,r,k);
    pup(rt);
}
ll query(int rt,int left,int right,int l,int r)
{
    ll res = 0;

    if(l <= left && right <= r)
    {
        return val[rt];
    }
    if(left > r || right < l)return 0 ;
    pdown(rt,left,right);

    int mid = (left + right) >> 1;

    if(left <= mid)
        res += query(lson,l,r);
    res %= Mod;
    if(right > mid)
        res += query(rson,l,r);
    return res % Mod;
}

最主要的就是LCA查询操作

线段树可以提供查询连续的区间值，但如果区间不连续，我们可以利用LCA将深度低的点利用top数组往上跳，记录中间的权值

一旦在一条链上则直接利用线段树，改查都是这样的思想

ll query_lca(int x,int y)
{
    ll res = 0;
    while(top[x] != top[y])
    {
        if(dep[top[x]] < dep[top[y]])swap(x,y);
        res += query(1,1,tot,did[top[x]],did[x]);
        x = fa[top[x]];
        res %= Mod;
    }
    if(dep[x] < dep[y])swap(x,y);

    res += query(1,1,tot,did[y],did[x]);

    return res % Mod;
}
void updata_lca(int x,int y,int z)
{
    while(top[x] != top[y])
    {
        if(dep[top[x]] < dep[top[y]])swap(x,y);
        update(1,1,tot,did[top[x]],did[x],z);
        x = fa[top[x]];
    }
    if(dep[x] < dep[y])swap(x,y);
    update(1,1,tot,did[y],did[x],z);
}

最后就简单略

int main()
{
    while(~scanf("%d%d%d%d",&n,&m,&root,&Mod))
    {
        init();
        for(int i = 1;i <= n;i++ )
        {
            scanf("%d",&V[i]);
        }
        int from, to;
        for(int i = 0;i < n-1;i++)
        {
            scanf("%d%d",&from,&to);
            add(from,to);
            add(to,from);
        }
        dfs1(root,root,1);
        dfs2(root,root);
        //cout<<tot<<endl;对
        build(1,1,tot);
        int op,x,y,z;
        for(int i = 0;i < m;i++)
        {
            scanf("%d",&op);
            if(op == 1)
            {
                scanf("%d%d%d",&x,&y,&z);
                updata_lca(x,y,z);
            }
            else if(op == 2)
            {
                scanf("%d%d",&x,&y);
                printf("%lld\n",query_lca(x,y));

            }
            else if(op == 3)
            {
                scanf("%d%d",&x,&z);
                update(1,1,tot,did[x],did[x]+siz[x] - 1,z);
            }
            else if(op == 4)
            {
                scanf("%d",&x);
                printf("%lld\n",query(1,1,tot,did[x],did[x] + siz[x] - 1));
            }
        }
    }
    return 0;
}

PS所要注意一点的是 longlong的情况，都要考虑到略，别有的地方longlong了有的地方没有longlong

猜你喜欢