树链剖分入门

这几天学了一个树链剖分，觉得还不是很难，这里我试着讲一讲吧。

 

首先，我认为树链剖分是把在树上一个节点一个节点的走改为按照某种规则跳，从而降低了时间复杂度。

 

那这是什么规则呢？

首先我们得知道什么是重链，知道什么是重链就得先知道什么是重儿子，重儿子就是子树较大的儿子。然后对于一个点，我们总是往他的重儿子走，这样就构成了重链，那么剩下的就是轻链。

放张图直观些

 

然后我们同样可以对树进行dfs，只不过重儿子优先，这样我们也得到了一个dfs序，于是我们把树上问题成功转化成了线性问题。接着就可以用线段树等数据结构维护了。

 

那就拿这道板子体为例：https://www.luogu.org/problemnew/show/P3384

 

首先是两遍dfs，第一遍dfs维护子树大小size[]，节点深度dep[]，重儿子son[]，以及一个节点的父亲节点（因为如果跳到了一条链的顶端，就要再自己走到他的父亲节点）。

void dfs1(int now)
{
    vis[now] = 1;
    size[now] = 1;
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(!vis[v[now][i]])
        {
            dep[v[now][i]] = dep[now] + 1;
            fa[v[now][i]] = now;
            dfs1(v[now][i]);
            size[now] += size[v[now][i]];
            if(!son[now] || size[son[now]] < size[v[now][i]]) son[now] = v[now][i];
            //如果没有重儿子，或者当前子树大小大于重儿子的子树大小，就更新重儿子 
        }
    }
}

 

第二遍dfs是维护dfs序dfsx[]，每一条链的顶端是哪一个节点。但我们还要在维护一个pos[]，因为当我们将树转化成线性后，用线段树建树的时候需要添加节点，而这个节点的编号是dfs序的编号，所以需要再用一个数组记录dfs序的编号所对应的树上节点编号。

int cnt = 0, dfsx[maxn], pos[maxn], top[maxn];
void dfs2(int now)
{
    //dfsx[]因为智慧更新一次，所以可以当做vis[]用 
    dfsx[now] = ++cnt; pos[cnt] = now;
    if(son[now])
    {
        top[son[now]] = top[now];
        dfs2(son[now]);        //优先走重儿子，保证一条链在dfs序上的编号是连续的 
    }
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(!dfsx[v[now][i]] && son[now] != v[now][i])    //再走不是重儿子的节点 
        {
            top[v[now][i]] = v[now][i];        //轻儿子所在的链只有他自己一个节点，所以顶端节点就是他自己 
            dfs2(v[now][i]);
        }
    }
}

 

这两个预处理完事后就可以看看题了。

 

第一个询问，将树从x到y结点最短路径上所有节点的值都加上z。

首先我们要将x，y移到同一条链上，具体操作就是如果其中一个点所在链的顶端的深度更低，就将他跳到链的顶端，并更新他到顶端节点的区间。

移到同一条链上后，就更新这两个点的区间就行了

void pathUpdate(int x, int y, int z)
{
    while(top[x] != top[y])        //先把这俩搞到一条链上 
    {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);    //默认让x跳 
        update(dfsx[top[x]], dfsx[x], 1, z);
        x = fa[top[x]];
    }
    if(dfsx[x] > dfsx[y]) swap(x, y);
    update(dfsx[x], dfsx[y], 1, z);
}

 

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

和修改一样，先把两点移到同一条链上，然后计算跳的点在该链上的贡献

ll pathQuery(int x, int y)
{
    ll ret = 0;
    while(top[x] != top[y])
    {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        ret += query(dfsx[top[x]], dfsx[x], 1); ret %= mod;
        x = fa[top[x]];
    }
    if(dfsx[x] > dfsx[y]) swap(x, y);
    ret += query(dfsx[x], dfsx[y], 1); ret %= mod;
    return ret;
}

操作3： 将以x为根节点的子树内所有节点值都加上z

值得一提的是，尽管我们在维护dfs序时是重链优先遍历，但仍满足一个节点以及他的子树在dfs序上是一段长为子树大小的连续区间，自己画一画就明白了

这里和查询放一块

void sbtUpdate(int x, int z)
{
    update(dfsx[x], dfsx[x] + size[x] - 1, 1, z);
}
ll sbtQuery(int x)
{
    return query(dfsx[x], dfsx[x] + size[x] - 1, 1);
}

 

这样板子就写完了，是不是很简单？

然后最重要的一件事是别忘了取模，而且每一个运算后都要取，否则你就可能70分代码debug一小时……

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#include<cctype>
using namespace std;
#define enter printf("\n")
#define space printf(" ")
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch))
    {
        ans = ans * 10 + ch - '0'; ch = getchar();    
    }
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar('0' + x % 10);
}

int n, m, s, mod;
int a[maxn];
vector<int> v[maxn];

bool vis[maxn];
int fa[maxn], son[maxn], size[maxn], dep[maxn];
void dfs1(int now)
{
    vis[now] = 1;
    size[now] = 1;
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(!vis[v[now][i]])
        {
            dep[v[now][i]] = dep[now] + 1;
            fa[v[now][i]] = now;
            dfs1(v[now][i]);
            size[now] += size[v[now][i]];
            if(!son[now] || size[son[now]] < size[v[now][i]]) son[now] = v[now][i];
            //如果没有重儿子，或者当前子树大小大于重儿子的子树大小，就更新重儿子 
        }
    }
}
//第二遍dfs是维护dfs序dfsx[]，每一条链的顶端是哪一个节点

int cnt = 0, dfsx[maxn], pos[maxn], top[maxn];
void dfs2(int now)
{
    //dfsx[]因为智慧更新一次，所以可以当做vis[]用 
    dfsx[now] = ++cnt; pos[cnt] = now;
    if(son[now])
    {
        top[son[now]] = top[now];
        dfs2(son[now]);        //优先走重儿子，保证一条链在dfs序上的编号是连续的 
    }
    for(int i = 0; i < (int)v[now].size(); ++i)
    {
        if(!dfsx[v[now][i]] && son[now] != v[now][i])    //再走不是重儿子的节点 
        {
            top[v[now][i]] = v[now][i];        //轻儿子所在的链只有他自己一个节点，所以顶端节点就是他自己 
            dfs2(v[now][i]);
        }
    }
}

int l[maxn << 2], r[maxn << 2];
ll sum[maxn << 2], lazy[maxn << 2];
void build(int L, int R, int now)
{
    l[now] = L; r[now] = R;
    if(L == R) {sum[now] = a[pos[L]]; return;}
    int mid = (L + R) >> 1;
    build(L, mid, now << 1);
    build(mid + 1, R, now << 1 | 1);
    sum[now] = (sum[now << 1] + sum[now << 1 | 1]) % mod; 
}
void pushdown(int now)
{
    if(lazy[now])
    {
        lazy[now << 1] += lazy[now]; lazy[now << 1] %= mod;
        lazy[now << 1 | 1] += lazy[now]; lazy[now << 1 | 1] %= mod;
        sum[now << 1] += (ll)(r[now << 1] - l[now << 1] + 1) * lazy[now]; sum[now << 1] %= mod;
        sum[now << 1 | 1] += (ll)(r[now << 1 | 1] - l[now << 1 | 1] + 1) * lazy[now]; sum[now << 1 | 1] %= mod;
        lazy[now] = 0;
    }
}
void update(int L, int R, int now, int d)
{
    if(L == l[now] && R == r[now])
    {
        sum[now] += (ll)(r[now] - l[now] + 1) * d; sum[now] %= mod;
        lazy[now] += d; lazy[now] %= mod;
        return;
    }
    pushdown(now);
    int mid = (l[now] + r[now]) >> 1;
    if(R <= mid) update(L, R, now << 1, d);
    else if(L > mid) update(L, R, now << 1 | 1, d);
    else {update(L, mid, now << 1, d); update(mid + 1, R, now << 1 | 1, d);}
    sum[now] = sum[now << 1] + sum[now << 1 | 1];
}
ll query(int L, int R, int now)
{
    if(L == l[now] && R == r[now]) return sum[now];
    pushdown(now);
    int mid = (l[now] + r[now]) >> 1;
    if(R <= mid) return query(L, R, now << 1);
    else if(L > mid) return query(L, R, now << 1 | 1);
    else return (query(L, mid, now << 1) + query(mid + 1, R, now << 1 | 1)) % mod;
}

void pathUpdate(int x, int y, int z)
{
    while(top[x] != top[y])        //先把这俩搞到一条链上 
    {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);    //默认让x跳 
        update(dfsx[top[x]], dfsx[x], 1, z);
        x = fa[top[x]];
    }
    if(dfsx[x] > dfsx[y]) swap(x, y);
    update(dfsx[x], dfsx[y], 1, z);
}
ll pathQuery(int x, int y)
{
    ll ret = 0;
    while(top[x] != top[y])
    {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        ret += query(dfsx[top[x]], dfsx[x], 1); ret %= mod;
        x = fa[top[x]];
    }
    if(dfsx[x] > dfsx[y]) swap(x, y);
    ret += query(dfsx[x], dfsx[y], 1); ret %= mod;
    return ret;
}

void sbtUpdate(int x, int z)
{
    update(dfsx[x], dfsx[x] + size[x] - 1, 1, z);
}
ll sbtQuery(int x)
{
    return query(dfsx[x], dfsx[x] + size[x] - 1, 1);
}

int main()
{
    n = read(); m = read(); s = read(); mod = read();
    for(int i = 1; i <= n; ++i) a[i] = read();
    for(int i = 1 ; i < n; ++i)
    {
        int a = read(), b = read();
        v[a].push_back(b); v[b].push_back(a);
    }
    dfs1(s); 
    top[s] = s; dfs2(s);    
    build(1, n, 1);
    for(int i = 1; i <= m ; ++i)
    {
        int d = read();
        if(d == 1) 
        {
            int x = read(), y = read(), z = read();
            pathUpdate(x, y, z);
        }
        else if(d == 2)
        {
            int x = read(), y = read();
            write(pathQuery(x, y)); enter;
        }
        else if(d == 3)
        {
            int x = read(), z = read();
            sbtUpdate(x, z);
        }
        else
        {
            int x = read();
            write(sbtQuery(x)); enter;
        }
    }
    return 0;
}