HDU 4942 [线段树][平衡树]

$Description$

给定一棵平衡树，每个点有一个权值$w_u$。
定义一个$value_u$为$u$子树的$w_v$之和。
要求满足以下操作：

• $0~x$：对$x$左旋。
• $1~x$：对$x$右旋。
• $2~x$：查询$x$子树中所有$value$的乘积。

$Solution$

首先左右旋是不会改变这棵树的中序遍历的（改变就不是平衡树了QAQ）。
然后是一次操作只会改变两个节点的值。
那么只要边模拟平衡树，边用线段树维护一下区间积就好了。

#pragma comment (linker,"/STACK:102400000,102400000")
#include <bits/stdc++.h>
using namespace std;

const int N = 101010;
const int MOD = 1000000007;
typedef long long ll;

inline char get(void) {
    static char buf[100000], *S = buf, *T = buf;
    if (S == T) {
        T = (S = buf) + fread(buf, 1, 100000, stdin);
        if (S == T) return EOF;
    }
    return *S++;
}
inline void read(int &x) {
    static char c; x = 0;
    for (c = get(); c < '0' || c > '9'; c = get());
    for (; c >= '0' && c <= '9'; c = get()) x = x * 10 + c - '0';
}

int n, m, test, clc, opt, x, y;
int pre[N], L[N], R[N];
int f[N], l[N], r[N], w[N], sm[N], sum[N];
int pro[N << 2];

inline void Maintain(int x) {
    L[x] = R[x] = pre[x];
    if (l[x]) {
        L[x] = min(L[x], L[l[x]]);
        R[x] = max(R[x], R[l[x]]);
    }
    if (r[x]) {
        L[x] = min(L[x], L[r[x]]);
        R[x] = max(R[x], R[r[x]]);
    }
}
inline void Mod(int &x) {
    while (x < 0) x += MOD;
    while (x >= MOD) x -= MOD;
}
inline int dfs(int u) {
    sm[u] = w[u];
    if (l[u]) Mod(sm[u] += dfs(l[u]));
    L[u] = R[u] = pre[u] = ++clc;
    if (r[u]) Mod(sm[u] += dfs(r[u]));
    Maintain(u); return sum[pre[u]] = sm[u];
}
inline void Modify(int o, int l, int r, int pos, int x) {
    if (l == r) return (void)(pro[o] = x);
    int mid = (l + r) >> 1;
    if (pos <= mid) Modify(o << 1, l, mid, pos, x);
    else Modify(o << 1 | 1, mid + 1, r, pos, x);
    pro[o] = (ll)pro[o << 1] * pro[o << 1 | 1] % MOD;
}
inline void Build(int o, int l, int r) {
    if (l == r) return (void)(pro[o] = sum[l]);
    int mid = (l + r) >> 1;
    Build(o << 1, l, mid);
    Build(o << 1 | 1, mid + 1, r);
    pro[o] = (ll)pro[o << 1] * pro[o << 1 | 1] % MOD;
}
inline int Query(int o, int l, int r, int L, int R) {
    if (l >= L && r <= R) return pro[o];
    int mid = (l + r) >> 1, res = 1;
    if (L <= mid) res = (ll)res * Query(o << 1, l, mid, L, R) % MOD;
    if (R > mid) res = (ll)res * Query(o << 1 | 1, mid + 1, r, L, R) % MOD;
    return res;
}

int main(void) {
    read(test);
    for (int t = 1; t <= test; t++) {
        printf("Case #%d:\n", t);
        read(n); read(m);
        for (int i = 1; i <= n; i++) f[i] = 0;
        for (int i = 1; i <= n; i++) {
            read(w[i]); read(l[i]); read(r[i]);
            f[l[i]] = i; f[r[i]] = i;
        }
        clc = 0; dfs(1); Build(1, 1, n);
        for (int i = 1; i <= m; i++) {
            read(opt);
            if (opt == 0) {
                read(y); x = l[y];
                if (!x) continue;
                Mod(sm[y] -= sm[x] - sm[r[x]]);
                Mod(sm[x] -= sm[r[x]] - sm[y]);
                Modify(1, 1, n, pre[x], sm[x]);
                Modify(1, 1, n, pre[y], sm[y]);
                if (y == l[f[y]]) l[f[y]] = x;
                else r[f[y]] = x;
                f[x] = f[y]; l[y] = r[x]; f[r[x]] = y;
                r[x] = y; f[y] = x;
                Maintain(y); Maintain(x);
            } else if (opt == 1) {
                read(x); y = r[x];
                if (!y) continue;
                Mod(sm[x] -= sm[y] - sm[l[y]]);
                Mod(sm[y] -= sm[l[y]] - sm[x]);
                Modify(1, 1, n, pre[x], sm[x]);
                Modify(1, 1, n, pre[y], sm[y]);
                if (x == l[f[x]]) l[f[x]] = y;
                else r[f[x]] = y;
                f[y] = f[x]; r[x] = l[y]; f[l[y]] = x;
                l[y] = x; f[x] = y;
                Maintain(x); Maintain(y);
            } else {
                read(x);
                printf("%d\n", Query(1, 1, n, L[x], R[x]));
            }
        }
    }
}