BZOJ 1036 树的统计Count(树链剖分(点权)入门题)

最新推荐文章于 2024-03-28 21:51:44 发布

原创最新推荐文章于 2024-03-28 21:51:44 发布 · 553 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#BZOJ #树链剖分

dfs序&树链剖分专栏收录该内容

9 篇文章

订阅专栏

本文介绍了一道典型的树剖问题，通过树剖结合线段树实现高效的路径查询操作，包括路径上节点权值的最大值和总和，并提供了完整的C++代码实现。

题意：给你一个n个节点的一棵树，每个节点有一个权值，现在q次操作,操作有三种:

Change x y : 将x节点的权值改成y

QMAX x y : 问你x到y路径上的最大值

QSUM x y: 问你x到y路径上的权值和

思路：第一个树剖题，树剖裸题，剖完后直接线段树查询即可。

num[]数组，用来保存以x为根的子树节点个数
top[]数组，用来保存当前节点的所在链的顶端节点
son[]数组，用来保存重儿子
deep[]数组，用来保存当前节点的深度
fa[]数组，用来保存当前节点的父亲
tree[]数组，用来保存树中每个节点剖分后的新编号
pre[]数组，用来保存线段树当前点对应树节点的编号

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn = 1e5+5;
const int INF = 0x3f3f3f3f;
int deep[maxn], fa[maxn], top[maxn], tree[maxn], pre[maxn], son[maxn], num[maxn];
int n, tot, treeSum[maxn*4], treeMax[maxn*4], a[maxn];
vector<int> g[maxn];

void init()
{
    tot = 0;
    memset(son, 0, sizeof(son));
    memset(num, 0, sizeof(num));
    for(int i = 0; i <= n; i++) g[i].clear();
}

void dfs1(int u, int pre,  int d)
{
    deep[u] = d;
    fa[u] = pre;
    num[u] = 1;
    for(int i = 0; i < g[u].size(); i++)
    {
        int v = g[u][i];
        if(v == pre) continue;
        dfs1(v, u, d+1);
        num[u] += num[v];
        if(!son[u] || num[v] > num[son[u]])
            son[u] = v;
    }
}

void dfs2(int u, int tp)
{
    top[u] = tp;
    tree[u] = ++tot;
    pre[tree[u]] = u;
    if(!son[u]) return ;
    dfs2(son[u], tp);
    for(int i = 0; i < g[u].size(); i++)
    {
        int v = g[u][i];
        if(v != son[u] && v != fa[u])
            dfs2(v, v);
    }
}

void push_up(int root)
{
    treeMax[root] = max(treeMax[root*2], treeMax[root*2+1]);
    treeSum[root] = treeSum[root*2]+treeSum[root*2+1];
}

void build(int root, int l, int r)
{
    if(l == r)
    {
        treeMax[root] = a[pre[l]];
        treeSum[root] = a[pre[l]];
        return ;
    }
    int mid = (l+r)/2;
    build(root*2, l, mid);
    build(root*2+1, mid+1, r);
    push_up(root);
}

void update(int root, int l, int r, int pos, int val)
{
    if(l == r)
    {
        treeMax[root] = val;
        treeSum[root] = val;
        return ;
    }
    int mid = (l+r)/2;
    if(pos <= mid) update(root*2, l, mid, pos, val);
    else update(root*2+1, mid+1, r, pos, val);
    push_up(root);
}

int querySum(int root, int l, int r, int i, int j)
{
    if(i <= l && j >= r)
        return treeSum[root];
    int mid = (l+r)/2, sum = 0;
    if(i <= mid) sum += querySum(root*2, l, mid, i, j);
    if(j > mid) sum += querySum(root*2+1, mid+1, r, i, j);
    return sum;
}

int queryMax(int root, int l, int r, int i, int j)
{
    if(i <= l && j >= r)
        return treeMax[root];
    int mid = (l+r)/2;
    if(j <= mid) return queryMax(root*2, l, mid, i, j);
    else if(i > mid) return queryMax(root*2+1, mid+1, r, i, j);
    else return max(queryMax(root*2, l, mid, i, j), queryMax(root*2+1, mid+1, r, i, j));
}


int askSum(int x, int y)
{
    int f1= top[x], f2 = top[y], ans = 0;
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2]) swap(f1, f2), swap(x, y);
        ans += querySum(1, 1, n, tree[f1], tree[x]);
        x = fa[f1]; f1 = top[x];
    }
    ans += (deep[x]>deep[y]) ? querySum(1, 1, n, tree[y], tree[x]) : querySum(1, 1, n, tree[x], tree[y]);

    return ans;
}

int askMax(int x, int y)
{
    int f1 = top[x], f2 = top[y], ans = -INF;
    while(f1 != f2)
    {
        if(deep[f1] < deep[f2]) swap(f1, f2), swap(x, y);
        ans = max(ans, queryMax(1, 1, n, tree[f1], tree[x]));
        x = fa[f1]; f1 = top[x];
    }
    ans = max(ans, (deep[x]>deep[y]) ? queryMax(1, 1, n, tree[y], tree[x]) : queryMax(1, 1, n, tree[x], tree[y]));
    return ans;
}

int main(void)
{
    while(cin >> n)
    {
        init();
        for(int i = 1; i < n; i++)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            g[u].push_back(v);
            g[v].push_back(u);
        }
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        dfs1(1, 0, 1); dfs2(1, 1);
        build(1, 1, n);
        int q;
        char cmd[15];
        scanf("%d", &q);
        while(q--)
        {
            int x, y;
            scanf(" %s%d%d", cmd, &x, &y);
            if(cmd[0] == 'C') update(1, 1, n, tree[x], y);
            else if(cmd[1] == 'M') printf("%d\n", askMax(x, y));
            else printf("%d\n", askSum(x, y));
        }
    }
    return 0;
}