Jamie and Tree( Codeforces 916E)

题意:

给出一个有n个点以及n-1条边的树,进行3个操作:
1. 将x变成整个树的根
2. 将以x,y相对于根的最近公共祖先的为根的那棵子树的所有根节点加上z.
3. 查询以x为根的子树的所有节点的和

算法:

LCA,DFS序,线段树区间维护

解题思路:

首先考虑不对根进行修改,通过对根与询问节点的相对位置关系分析,通过求LCA实现各个操作。由于每一次操作修改的点不确定,最差情况下暴力修改会达到O(),所以自然而然的考虑线段树维护。
然后我们先做好LCA算法的准备工作,以及通过DFS序建立区间更新的线段树。
接着分析每一个操作:
操作1:直接将root标记成x即可。
操作2:仔细分析根和x,y的可能存在位置关系,可能三种情况,分别分析很容易得出求解方法

这里写图片描述
这里写图片描述
这里写图片描述
操作3:通过分析root与x的关系,可以分为x是根与x不是根两种

对于第一种,直接输出所有值就ok了。
对于第二种,又可以分为root在x的子树中和不在x的子树中两种
如果root在x的子树中, 输出x对应的子树的和
如图:
这里写图片描述
否则:如图
这里写图片描述

代码:

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <stack>
#include <math.h>

#define LL long long
#define lson ins<<1
#define rson ins<<1|1
#define mid (r+l)/2
using namespace std;
const int Max = 1e5 + 100;
int data[Max], fa[Max][33], depth[Max], dep, fir[Max], las[Max];
vector<int> edge[Max];

struct Tree {
    int l, r;
    LL sum, lazy;

    void updata(LL x) {//更新点
        sum += (r - l + 1) * x;
        lazy += x;
    }
} tree[Max << 2];

void DFS(int u, int pos) {//为LCA准备顺便求出DFS序用与建树
    depth[u] = pos;
    fir[u] = ++dep;
    for (int i = 0; i < edge[u].size(); i++) {
        int v = edge[u][i];
        if (fa[u][0] != v) {
            fa[v][0] = u;
            DFS(v, pos + 1);
        }
    }
    las[u] = dep;
}

void make_lca(int n) {//LCA
    for (int j = 1; j <= 22; j++) {
        for (int i = 1; i <= n; i++)fa[i][j] = fa[fa[i][j - 1]][j - 1];
    }
}

int lca(int x, int y) {//LCA
    if (depth[x] < depth[y])swap(x, y);
    for (int i = 22; i >= 0; i--) {
        if (depth[fa[x][i]] >= depth[y])x = fa[x][i];
    }
    if (x == y)return x;
    for (int i = 22; i >= 0; i--) {
        if (fa[x][i] != fa[y][i])
            x = fa[x][i], y = fa[y][i];
    }
    return fa[x][0];
}

int lst(int x, int y) {//使x比y深1级,用于排除y节点,取子树
    for (int i = 22; i >= 0; i--)if (depth[fa[x][i]] > depth[y])x = fa[x][i];
    return x;
}

inline void push_down(int ins) {//下传lazy
    LL lazyval = tree[ins].lazy;
    if (lazyval) {
        tree[lson].updata(lazyval);
        tree[rson].updata(lazyval);
        tree[ins].lazy = 0;
    }
}

inline void push_up(int ins) {//合并子树,更新节点
    tree[ins].sum = tree[lson].sum + tree[rson].sum;
}

inline void build(int l, int r, int ins) {//建树
    tree[ins].l = l, tree[ins].r = r, tree[ins].sum = tree[ins].lazy = 0;
    if (r == l) {
        tree[ins].sum = 0;
    } else if (r > l) {
        build(l, mid, lson);
        build(mid + 1, r, rson);
        push_up(ins);
    }
}

inline void updata_tree(int ql, int qr, LL x, int ins = 1) {//树的更新
    int l = tree[ins].l, r = tree[ins].r;
    if (ql <= l && r <= qr)tree[ins].updata(x);
    else {
        push_down(ins);
        if (ql <= mid)updata_tree(ql, qr, x, lson);
        if (qr > mid)updata_tree(ql, qr, x, rson);
        push_up(ins);
    }
}

inline LL query(int ql, int qr, int ins = 1) {//查询
    int l = tree[ins].l, r = tree[ins].r;
    if (ql <= l && r <= qr)return tree[ins].sum;
    else {
        push_down(ins);
        LL res = 0;
        if (ql <= mid)res += query(ql, qr, lson);
        if (qr > mid)res += query(ql, qr, rson);
        return res;
    }
}

int main() {
    int n, m, u, v;
    scanf("%d%d", &n, &m);
    for (int a = 1; a <= n; a++)scanf("%d", &data[a]);
    for (int a = 1; a < n; a++)scanf("%d%d", &u, &v), edge[u].push_back(v), edge[v].push_back(u);
    int root = 1;
    DFS(root, 1);
    make_lca(n);
    build(1, dep, 1);
    for (int a = 1; a <= n; a++)updata_tree(fir[a], fir[a], data[a]);
    while (m--) {
        int ope, x, y;
        LL z;
        scanf("%d", &ope);
        if (ope == 1)scanf("%d", &x), root = x;
        else if (ope == 2) {
            scanf("%d%d%lld", &x, &y, &z);
            int i = lca(x, y), j = lca(root, i);
            if (i == j) {
                int lx = lca(root, x), ly = lca(root, y);
                updata_tree(1, n, z);
                if (lx != root && ly != root) {
                    i = lx + ly - i;//i与其中至少一个相等
                    i = lst(root, i);
                    updata_tree(fir[i], las[i], -z);
                }
            } else updata_tree(fir[i], las[i], z);
        } else {
            scanf("%d", &x);
            if (x == root)printf("%lld\n", query(1, n));
            else {
                if (lca(root, x) == x) {
                    x = lst(root, x);
                    printf("%lld\n", query(1, n) - query(fir[x], las[x]));
                } else printf("%lld\n", query(fir[x], las[x]));
            }
        }
    }
    return 0;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值