hdu 4605 Magic Ball Game（可持久化笛卡尔树）

题目链接：hdu 4605 Magic Ball Game

题目大意

给定一棵二叉树，保证节点没有孩子节点或者有两个孩子节点，并且每个节点有一个权值W[i]，1为根节点，树给定的方式m个关系u a b，表示u节点的左孩子为a，右孩子为b。现在从根节点放一个权值为X的小球：
- X = W[u]时：小球停留在该节点
- X > W[u]时：小球有1/8的概率移动到左孩子，7/8的概率移动到右孩子
- X < W[u]时：小球有1/2的概率移动到左孩子，1/2的概率移动到右孩子
给定询问，x u，求小球会经过节点u的概率是多少。

解题思路

本题可以用两个树状数组做离线算法。
这里用可持久化笛卡尔树做在线算法。对于每次询问，其实要求的即为节点u到根节点的路径上有多少个点的权值大于小球的质量，并且有多少个点是向右孩子移动的。
笛卡尔树中维护权值以及走向的个数。
以每个节点做一个版本的笛卡尔树，该版本的笛卡尔树维护的是节点u到根节点的情况。

代码

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>

using namespace std;
const int maxn = 1e5 + 5;

/***********************************/

int P;
struct Node {
    int key, val;
    int cnt, siz;
    int uri, sri, ch[2];
}nd[maxn * 20];

int newNode (int key, int rit) {
    P++;
    nd[P].key = key;
    nd[P].val = rand();
    nd[P].cnt = nd[P].siz = 1;
    nd[P].uri = nd[P].sri = rit;
    nd[P].ch[0] = nd[P].ch[1] = 0;
    return P;
}

void maintain(int u) {
    int ls = nd[u].ch[0], rs = nd[u].ch[1];
    nd[u].siz = nd[ls].siz + nd[rs].siz + nd[u].cnt;
    nd[u].sri = nd[ls].sri + nd[rs].sri + nd[u].uri;
}

void rotate(int& u, int d) {
    int k = nd[u].ch[d];    
    nd[u].ch[d] = nd[k].ch[d^1];  
    nd[k].ch[d^1] = u;  
    maintain(u);  
    maintain(k);    
    u = k; 
}

int insert(int v, int key, int rit) {

    if (v == 0) return newNode(key, rit);

    int u = ++P;
    nd[u] = nd[v];

    if (nd[u].key == key) {
        nd[u].cnt++;
        if (rit) nd[u].uri++;
    } else {
        int d = nd[u].key < key;
        nd[u].ch[d] = insert(nd[u].ch[d], key, rit);
        if (nd[u].val < nd[nd[u].ch[d]].val) rotate(u, d);
    }
    maintain(u);
    return u;
}

bool query(int u, int key, int& x, int& y) {
    if (u == 0) return true;

    if (nd[u].key == key) return false;

    if (nd[u].key > key)
        return query(nd[u].ch[0], key, x, y);

    int ls = nd[u].ch[0];
    x += nd[ls].sri + nd[u].uri;
    y += nd[ls].siz + nd[u].cnt;

    return query(nd[u].ch[1], key, x, y);
}

/***********************************/


int N, M, Q, F[maxn], W[maxn], L[maxn], R[maxn];
int T[maxn];

void dfs (int u, int rit) {
    if (u == 0) return;

    if (u != 1)
        T[u] = insert(T[F[u]], W[F[u]], rit);
    dfs(L[u], 0);
    dfs(R[u], 1);
}

void init () {
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
        scanf("%d", &W[i]);
    memset(L, 0, sizeof(L));
    memset(R, 0, sizeof(R));

    scanf("%d", &M);
    int u, a, b;
    while (M--) {
        scanf("%d%d%d", &u, &a, &b);
        F[a] = F[b] = u;
        L[u] = a; R[u] = b;
    }

    P = T[0] = 0;
    nd[P].cnt = nd[P].siz = 0;
    nd[P].uri = nd[P].sri = 0;
    nd[P].ch[0] = nd[P].ch[1] = 0;

    dfs(1, 0);
}

void solve (int u, int w) {
    int x = 0, y = 0;
    if (!query(T[u], w, x, y))
        printf("0\n");
    else
        printf("%d %d\n", x, y * 2 + nd[T[u]].siz);
}

int main () {
    int cas;
    scanf("%d", &cas);
    while (cas--) {
        init();

        scanf("%d", &Q);
        int v, x;
        while (Q--) {
            scanf("%d%d", &v, &x);
            solve(v, x);
        }
    }
    return 0;
}