JZOJ4600 有标记技巧的链剖

最新推荐文章于 2016-08-29 11:12:16 发布

YxuanwKeith

最新推荐文章于 2016-08-29 11:12:16 发布

阅读量1.6k

点赞数 2

分类专栏：算法-树链剖分

本文链接：https://blog.csdn.net/YxuanwKeith/article/details/51912467

版权

算法-树链剖分专栏收录该内容

6 篇文章 0 订阅

订阅专栏

题目大意

现在有一颗 $N$ 个节点的树，每个节点上都有一个权值，现在有些人会入住树上的这些节点，每个人都会有个自身的权值，而当他入住到某个节点后他新的权值就是自身的权值加上节点的权值。一开始每个节点的权值是0，每个节点上都会住着一个给定权值为 $A_i$ 的人。现在有 $M$ 个操作。每种操作读入四个数 $type,u,v,Val$ 。
$type = 0$ 把树上节点 $u$ 到 $v$ 的权值增加 $Val$
$type = 1$ 树上节点 $u$ 到 $v$ 每个节点都入住一个初始权值为 $Val$ 的人。
$type = 2$ 询问树上节点 $u$ 到 $v$ 之间，当 $Val = 0$ 时输出权值最大的人，当 $Val = 1$ 时输出权值最小的人。（这里的权值为每个人自身的权值加上节点的权值）

$N,M \leq 10^5$

解题思路

这种维护树上信息的题很显然就要用树链剖分。可是这题需要维护的信息比较复杂，答案需要的值由两个不相关的值组成，我么我们维护时就要有点技巧。

首先显然的我们维护时肯定是将节点的权值和人的权值分开维护，并且都要维护最大最小值。但是维护答案时，如果我们某个结点中存下的是两个子节点中权值的最值，那么我们是不可以直接把最值加起来来更新这个点的答案，因为当前点最大（或最小）的点权和人的权值可能不是来源于一个儿子，所以我们当前点的答案的一个来源是儿子节点的答案。

但是我们修改操作就会显得有点麻烦了。当我们将这个区间的点权增加时，那么比较简单，把点权的极值都增加，答案也增加就好了。而加人是就不能这样了，我们在一个结点只需保存当前权值最大的人和权值最小的人来下传标记，而更新答案时则只需用新加入的人和点权的极值加一下跟答案比较，维护一下就可以了。

程序

//YxuanwKeith
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 1e5 + 5;

struct Tree {
    int Min, Max, tag, MinA, MaxA, MinAns, MaxAns, MinNum, MaxNum;
} Tr[MAXN * 4];

int N, M, time, Val[MAXN];
int tot, Next[MAXN * 2], Go[MAXN * 2], Last[MAXN];
int Size[MAXN], MSon[MAXN], Ord[MAXN], Bel[MAXN], Top[MAXN], Deep[MAXN], Fa[MAXN];

void Link(int u, int v) {
    Next[++ tot] = Last[u], Last[u] = tot, Go[tot] = v;
}

void Basis(int Now, int Pre) {
    Size[Now] = 1, MSon[Now] = 0;
    Deep[Now] = Deep[Pre] + 1, Fa[Now] = Pre;
    for (int p = Last[Now]; p; p = Next[p]) {
        int v = Go[p];
        if (v == Pre) continue;
        Basis(v, Now);
        Size[Now] += Size[v];
        if (Size[v] > Size[MSon[Now]]) MSon[Now] = v;
    }
}

void Promote(int Now, int top) {
    if (!Now) return;
    Ord[Now] = ++ time, Bel[time] = Now;
    Top[Now] = top;
    Promote(MSon[Now], top);
    for (int p = Last[Now]; p; p = Next[p]) {
        int v = Go[p];
        if (v == Fa[Now] || v == MSon[Now]) continue;
        Promote(v, v);
    }
}

void Update(int Now) {
    Tr[Now].Min = min(Tr[Now * 2].Min, Tr[Now * 2 + 1].Min);
    Tr[Now].Max = max(Tr[Now * 2].Max, Tr[Now * 2 + 1].Max);
    Tr[Now].MinNum = min(Tr[Now * 2].MinNum, Tr[Now * 2 + 1].MinNum);
    Tr[Now].MaxNum = max(Tr[Now * 2].MaxNum, Tr[Now * 2 + 1].MaxNum);
    Tr[Now].MinAns = min(Tr[Now * 2].MinAns, Tr[Now * 2 + 1].MinAns);
    Tr[Now].MaxAns = max(Tr[Now * 2].MaxAns, Tr[Now * 2 + 1].MaxAns);
}

void Build(int Now, int l, int r) {
    if (l == r) {
        Tr[Now].Min = Tr[Now].Max = Tr[Now].MinAns = Tr[Now].MaxAns = Val[Bel[l]];
        Tr[Now].MinA = Tr[Now].MaxA = -1;
        Tr[Now].MinNum = Tr[Now].MaxNum = 0;
        Tr[Now].tag = 0;
        return;
    }
    int Mid = (l + r) >> 1;
    Build(Now * 2, l, Mid), Build(Now * 2 + 1, Mid + 1, r);
    Tr[Now].Min = min(Tr[Now * 2].Min, Tr[Now * 2 + 1].Min);
    Tr[Now].Max = max(Tr[Now * 2].Max, Tr[Now * 2 + 1].Max);
    Tr[Now].MinNum = min(Tr[Now * 2].MinNum, Tr[Now * 2 + 1].MinNum);
    Tr[Now].MaxNum = max(Tr[Now * 2].MaxNum, Tr[Now * 2 + 1].MaxNum);
    Update(Now);
    Tr[Now].MinA = Tr[Now].MaxA = -1;
    Tr[Now].tag = 0;
}

void BuildTree() {
    Basis(1, 0);
    Promote(1, 1);
    Build(1, 1, N);
}

void MakeTag(int Now, int Val) {
    Tr[Now].MinNum += Val;
    Tr[Now].MaxNum += Val;
    Tr[Now].MinAns += Val;
    Tr[Now].MaxAns += Val;
    Tr[Now].tag += Val;
}

void MakeAdd(int Now, int Min, int Max) {
    Tr[Now].Min = min(Tr[Now].Min, Min);
    Tr[Now].Max = max(Tr[Now].Max, Max);
    if (Tr[Now].MinA == -1 || Min < Tr[Now].MinA) Tr[Now].MinA = Min;
    if (Tr[Now].MaxA == -1 || Max > Tr[Now].MaxA) Tr[Now].MaxA = Max;
    Tr[Now].MinAns = min(Tr[Now].MinAns, Min + Tr[Now].MinNum);
    Tr[Now].MaxAns = max(Tr[Now].MaxAns, Max + Tr[Now].MaxNum);
}

void Push(int Now, int l, int r) {
    if (l != r) {
        if (Tr[Now].tag != 0) {
            MakeTag(Now * 2, Tr[Now].tag);
            MakeTag(Now * 2 + 1, Tr[Now].tag);
        }
        if (Tr[Now].MinA != -1) {
            MakeAdd(Now * 2, Tr[Now].MinA, Tr[Now].MaxA);
            MakeAdd(Now * 2 + 1, Tr[Now].MinA, Tr[Now].MaxA);
        }
    }
    Tr[Now].tag = 0, Tr[Now].MinA = Tr[Now].MaxA = -1;
}

int QueryMin(int Now, int l, int r, int lx, int rx) {
    Push(Now, l, r);
    if (l == lx && r == rx) return Tr[Now].MinAns;
    int Mid = (l + r) >> 1;
    if (rx <= Mid) return QueryMin(Now * 2, l, Mid, lx, rx); else
    if (lx > Mid) return QueryMin(Now * 2 + 1, Mid + 1, r, lx, rx); else
        return min(QueryMin(Now * 2, l, Mid, lx, Mid), QueryMin(Now * 2 + 1, Mid + 1, r, Mid + 1, rx));
}

int QueryMax(int Now, int l, int r, int lx, int rx) {
    Push(Now, l, r);
    if (l == lx && r == rx) return Tr[Now].MaxAns;
    int Mid = (l + r) >> 1;
    if (rx <= Mid) return QueryMax(Now * 2, l, Mid, lx, rx); else
    if (lx > Mid) return QueryMax(Now * 2 + 1, Mid + 1, r, lx, rx); else
        return max(QueryMax(Now * 2, l, Mid, lx, Mid), QueryMax(Now * 2 + 1, Mid + 1, r, Mid + 1, rx));
}

void Modify(int Now, int l, int r, int lx, int rx, int Val) {
    Push(Now, l, r);
    if (l == lx && r == rx) {
        MakeTag(Now, Val);
        return;
    }
    int Mid = (l + r) >> 1;
    if (rx <= Mid) Modify(Now * 2, l, Mid, lx, rx, Val); else
    if (lx > Mid) Modify(Now * 2 + 1, Mid + 1, r, lx, rx, Val); else {
        Modify(Now * 2, l, Mid, lx, Mid, Val);
        Modify(Now * 2 + 1, Mid + 1, r, Mid + 1, rx, Val);
    }
    Update(Now);
}

void Add(int Now, int l, int r, int lx, int rx, int Val) {
    Push(Now, l, r);
    if (l == lx && r == rx) {
        MakeAdd(Now, Val, Val);
        return;
    }
    int Mid = (l + r) >> 1;
    if (rx <= Mid) Add(Now * 2, l, Mid, lx, rx, Val); else
    if (lx > Mid) Add(Now * 2 + 1, Mid + 1, r, lx, rx, Val); else {
        Add(Now * 2, l, Mid, lx, Mid, Val);
        Add(Now * 2 + 1, Mid + 1, r, Mid + 1, rx, Val);
    }
    Update(Now);
}

void Modify(int u, int v, int Val) {
    while (Top[u] != Top[v]) {
        if (Deep[Top[v]] > Deep[Top[u]]) swap(u, v);
        Modify(1, 1, N, Ord[Top[u]], Ord[u], Val);
        u = Fa[Top[u]];
    }
    if (Deep[v] < Deep[u]) swap(u, v);
    Modify(1, 1, N, Ord[u], Ord[v], Val);
}

void Add(int u, int v, int Val) {
    while (Top[u] != Top[v]) {
        if (Deep[Top[v]] > Deep[Top[u]]) swap(u, v);
        Add(1, 1, N, Ord[Top[u]], Ord[u], Val);
        u = Fa[Top[u]];
    }
    if (Deep[v] < Deep[u]) swap(u, v);
    Add(1, 1, N, Ord[u], Ord[v], Val);
}

int QueryMax(int u, int v) {
    int Ans = 0;
    while (Top[u] != Top[v]) {
        if (Deep[Top[v]] > Deep[Top[u]]) swap(u, v);
        Ans = max(Ans, QueryMax(1, 1, N, Ord[Top[u]], Ord[u]));
        u = Fa[Top[u]];
    }
    if (Deep[v] < Deep[u]) swap(u, v);
    Ans = max(Ans, QueryMax(1, 1, N, Ord[u], Ord[v]));
    return Ans;
}

int QueryMin(int u, int v) {
    int Ans = 1e9 + 7;
    while (Top[u] != Top[v]) {
        if (Deep[Top[v]] > Deep[Top[u]]) swap(u, v);
        Ans = min(Ans, QueryMin(1, 1, N, Ord[Top[u]], Ord[u]));
        u = Fa[Top[u]];
    }
    if (Deep[v] < Deep[u]) swap(u, v);
    Ans = min(Ans, QueryMin(1, 1, N, Ord[u], Ord[v]));
    return Ans;
}

void Solve() {
    for (int i = 1; i <= M; i ++) {
        int type, u, v, Value;
        scanf("%d%d%d%d", &type, &u, &v, &Value);
        if (type == 0) Modify(u, v, Value); else
        if (type == 1) Add(u, v, Value); else {
            if (Value == 1) printf("%d\n", QueryMax(u, v)); else
                printf("%d\n", QueryMin(u, v));
        }
    }
}

int main() {
    scanf("%d%d", &N, &M);
    for (int i = 1; i <= N; i ++) scanf("%d", &Val[i]);
    for (int i = 1; i < N; i ++) {
        int x, y;
        scanf("%d%d", &x, &y);
        Link(x, y), Link(y, x);
    }
    BuildTree();
    Solve();
}

YxuanwKeith

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JZOJ4600 有标记技巧的链剖

题目大意现在有一颗NN个节点的树，每个节点上都有一个权值，现在有些人会入住树上的这些节点，每个人都会有个自身的权值，而当他入住到某个节点后他新的权值就是自身的权值加上节点的权值。一开始每个节点的权值是0，每个节点上都会住着一个给定权值为AiA_i的人。现在有MM个操作。每种操作读入四个数type,u,v,Valtype,u,v,Val。 type=0type = 0 把树上节点uu到vv的权值增加
复制链接

扫一扫