BZOJ 4551 树 dfs序+线段树 / 并查集

题目链接

题意

给定一颗有根树（根为1），有以下两种操作：
1. 标记操作：对某个结点打上标记（在最开始，只有结点1有标记，其他结点均无标记，而且对于某个结点，可以打多次标记）；
2. 询问操作：询问某个结点最近的一个打了标记的祖先（这个结点本身也算自己的祖先）。

法一：dfs序+线段树

分析

类似于区间修改，单点查询，因为给某个结点打上标记会对它的整棵子树产生影响。
修改的注意点是只有当前修改的情况优于当前标记的情况才需要修改。

（还是第一次写区间修改，单点查询的$Lazy\ Tag$，略神奇，只需要$push\_down$，不需要$push\_up$）

Code

#include <bits/stdc++.h>
#define maxn 100010
#define lson (rt << 1)
#define rson (rt << 1 | 1)
struct Edge {
    int to, ne;
    Edge(int a = 0, int b = 0) : to(a), ne(b) {}
}edge[maxn * 2];
struct node { int l, r, c; }tr[maxn * 4];
inline int midi(int l, int r) { return l + r >> 1; }
int le[maxn], ri[maxn], tot, cnt, ne[maxn], depth[maxn];
void add(int u, int v) {
    edge[tot] = Edge(v, ne[u]);
    ne[u] = tot++;
}
void dfs(int u, int fa, int dep) {
    le[u] = ++cnt; depth[u] = dep;
    for (int i = ne[u]; ~i; i = edge[i].ne) {
        int v = edge[i].to;
        if (v == fa) continue;
        dfs(v, u, dep + 1);
    }
    ri[u] = cnt;
}
void build(int rt, int l, int r) {
    tr[rt].l = l, tr[rt].r = r; tr[rt].c = 0;
    if (l == r) { tr[rt].c = 1; return; }
    int mid = midi(l, r);
    build(lson, l, mid); build(rson, mid + 1, r);
}
inline void push_down(int rt) {
    if (tr[rt].c) {
        tr[lson].c = depth[tr[rt].c] > depth[tr[lson].c] ? tr[rt].c : tr[lson].c;
        tr[rson].c = depth[tr[rt].c] > depth[tr[rson].c] ? tr[rt].c : tr[rson].c;
        tr[rt].c = 0;
    }
}
void modify(int rt, int l, int r, int c) {
    if (tr[rt].l == l && tr[rt].r == r) {
        tr[rt].c = depth[c] > depth[tr[rt].c] ? c : tr[rt].c;
        return;
    }
    push_down(rt);
    int mid = midi(tr[rt].l, tr[rt].r);
    if (r <= mid) modify(lson, l, r, c);
    else if (l > mid) modify(rson, l, r, c);
    else { modify(lson, l, mid, c); modify(rson, mid + 1, r, c); }
}
int query(int rt, int x) {
    if (tr[rt].l == tr[rt].r) return tr[rt].c;
    push_down(rt);
    int mid = midi(tr[rt].l, tr[rt].r);
    if (x <= mid) return query(lson, x);
    else if (x > mid) return query(rson, x);
}
int n, q;
void work() {
    tot = cnt = 0; memset(ne, -1, sizeof(ne));
    for (int i = 1; i < n; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        add(u, v); add(v, u);
    }
    dfs(1, -1, 0);
    build(1, 1, n);
    while (q--) {
        int x;
        char c;
        scanf("\n%c%d", &c, &x);
        if (c == 'Q') printf("%d\n", query(1, le[x]));
        else {
            modify(1, le[x], ri[x], x);
        }
    }
}
int main() {
    while (scanf("%d%d", &n, &q) != EOF) work();
    return 0;
}

法二：并查集

参考

bzoj4551【TJOI2016&HEOI2016】树 ——AaronPolaris

分析

离线处理：先全部读入，然后倒着处理，即先给所有要打标记的点打上标记，然后一个个撤销标记（只有在第一次打标记的位置才能撤销）。
记 $fa[x]$ 为 $x$ 最近的一个打了标记的祖先。
询问的时候直接 find(x); 即可，撤销的时候fa[x] = find(treeFa[x]);
注意：因为标记可以重复打，所以对 $1$ 号节点的标记要尤其注意，毕竟 $1$ 号节点的标记是永远不可能被撤销的。如果是存储每个节点第一次打标记的位置，可以将其设置为 $inf$；如果存储打标记的次数，可以将其初始化为 $1$.（之前一直$WA$不知道错在哪$Orz$）

（越来越觉得并查集妙不可言了$O\_O$）

Code

#include <bits/stdc++.h>
#include <vector>
#define maxn 100010
#define inf 0x3f3f3f3f
using namespace std;
struct Edge {
    int to, ne;
    Edge(int a = 0, int b = 0) : to(a), ne(b) {}
}edge[maxn * 2];
struct op {
    char c; int x;
    op(char a = ' ', int b = 0) : c(a), x(b) {}
}a[maxn];
int tot, ne[maxn], setfa[maxn], trfa[maxn], col[maxn], first[maxn];
vector<int> ans;
void add(int u, int v) {
    edge[tot] = Edge(v, ne[u]);
    ne[u] = tot++;
}
inline int find(int x) {
    if (setfa[x] == x) return x;
    return setfa[x] = find(setfa[x]);
}
inline void unionn(int x, int y) { setfa[x] = find(y); }
void dfs(int u, int fa, int c) {
    for (int i = ne[u]; ~i; i = edge[i].ne) {
        int v = edge[i].to;
        if (v == fa) continue;
        trfa[v] = u;
        if (!setfa[v]) setfa[v] = c;
        dfs(v, u, setfa[v]);
    }
}
int n, q;
void work() {
    tot = 0; memset(ne, -1, sizeof(ne));
    memset(setfa, 0, sizeof(setfa));
    memset(first, 0, sizeof(first));
    for (int i = 1; i < n; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        add(u, v); add(v, u);
    }
    for (int i = 1; i <= q; ++i) {
        int x; char c;
        scanf("\n%c%d", &c, &x);
        a[i] = op(c, x);
        if (c == 'C') setfa[x] = x, col[i] = x;
    }
    for (int i = q; i > 0; --i) first[col[i]] = i;
    first[1] = inf;
    setfa[1] = 1;
    dfs(1, -1, 1);
    ans.clear();
    for (int i = q; i > 0; --i) {
        op oper = a[i];
        if (oper.c == 'Q') ans.push_back(find(oper.x));
        else if (i == first[oper.x]) unionn(oper.x, trfa[oper.x]);
    }
    for (vector<int>::reverse_iterator it = ans.rbegin(); it != ans.rend(); ++it) printf("%d\n", *it);
}
int main() {
    while (scanf("%d%d", &n, &q) != EOF) work();
    return 0;
}