BZOJ3306 树

记当前根为 root，查询的节点为 x

• 若 x = root，答案即为所有结点的最小值
• 若 x 与 root 在 1 的不同子树中，答案即为 x 的子树最小值
• 若 x 与 root 在 1 的同一子树中
  • 若 x 在 以 root 为根的子树中，答案为 x 的子树最小值；
  • 若 x 不在 1 到 root 的路径中，则换根后以 x 为根的子树不变，答案即为 x 的子树最小值
  • 若 x 在 1 到 root 的路径中，则答案为除去 x 的 root 所在的子树的其它所有结点的最小值

因为只是查询子树最小值，所以并不需要树剖。

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>

const int MAXN = 1e5 + 10;
int n, q, num, root = 1, w[MAXN], minw[MAXN << 2], subtr[MAXN], f[MAXN][20], dep[MAXN];
int dfn[MAXN], size[MAXN], idx[MAXN];
std::vector<int> son[MAXN];

void dfs(int u, int fa) {
    dep[u] = dep[fa] + 1;
    f[u][0] = fa;
    for (int i = 0; i < 19; ++i) {
        f[u][i + 1] = f[f[u][i]][i];
    }
    if (fa == 1) subtr[u] = u;
    else subtr[u] = subtr[fa];
    dfn[u] = ++num;
    idx[num] = u;
    size[u] = 1;
    minw[u] = w[u];
    for (auto v : son[u]) {
        dfs(v, u);
        size[u] += size[v];
        minw[u] = std::min(minw[u], minw[v]);
    }
}

int LCA(int x, int y) {
    if (dep[x] < dep[y]) std::swap(x, y);
    for (int i = 19; i >= 0; --i) {
        if(dep[f[x][i]] >= dep[y]) x = f[x][i];
        if(x == y) return x;
    }
    for(int i = 19; i >= 0; --i){
        if(f[x][i] != f[y][i]){
            x = f[x][i];
            y = f[y][i];
        }
    }
    x = f[x][0];
    return x;
}

void build(int k, int l, int r) {
    if (l == r) {
        minw[k] = w[idx[l]]; 
        return;
    }
    int mid = (l + r) >> 1;
    build(k << 1, l, mid);
    build(k << 1 | 1, mid + 1, r);
    minw[k] = std::min(minw[k << 1], minw[k << 1 | 1]);
}

void modify(int k, int l, int r, int x, int v) {
    if (l == r) {
        w[idx[l]] = minw[k] = v;
        return;
    }
    int mid = (l + r) >> 1;
    if (x <= mid) modify(k << 1, l, mid, x, v);
    else modify(k << 1 | 1, mid + 1, r, x, v);
    minw[k] = std::min(minw[k << 1], minw[k << 1 | 1]);
}

int query(int k, int l, int r, int x, int y) {
    if (x <= l && r <= y) return minw[k];
    int mid = (l + r) >> 1, res = 0x7fffffff;
    if (x <= mid) res = std::min(res, query(k << 1, l, mid, x, y));
    if (y > mid) res = std::min(res, query(k << 1 | 1, mid + 1, r, x, y));
    return res;
}

int main() {
    scanf("%d%d", &n, &q);
    int x, y;
    for (int i = 1; i <= n; ++i) {
        scanf("%d%d", &x, &w[i]);
        if (x) son[x].push_back(i);
    }
    dfs(1, 0);
    memset(minw, 0x7f, sizeof(minw));
    build(1, 1, n);
    char opt[10];
    while (q--) {
        scanf("%s%d", opt, &x);
        if (opt[0] == 'V') {
            scanf("%d", &y);
            modify(1, 1, n, dfn[x], y);
        } else if (opt[0] == 'E') {
            root = x;
        } else {
            if (x == root) {
                printf("%d\n", query(1, 1, n, 1, n));
            } else if ((subtr[x] != subtr[root] && x != 1) || LCA(x, root) == root || LCA(x, root) != x) {
                printf("%d\n", query(1, 1, n, dfn[x], dfn[x] + size[x] - 1));
            } else {
                for (auto v : son[x]) {
                    if (LCA(v, root) == v) {
                        y = v;
                        break;
                    }
                }
                int ans = query(1, 1, n, 1, dfn[y] - 1);
                if (dfn[y] + size[y] <= n) ans = std::min(ans, query(1, 1, n, dfn[y] + size[y], n));
                printf("%d\n", ans);
            }
        }
    }
    return 0;
}