HDU4605---Magic Ball Game（主席树 好题）

题意：一颗二叉树，任意节点要么有两个孩子要么没孩子。

然后有一个球，从结点1开始往子孙结点走。

每碰到一个结点，有三种情况

如果此球重量等于该结点重量，球就停下了

如果此球重量小于该结点重量，则分别往左右儿子走的可能都是1/2

如果此球重量大于该结点重量，则走向左儿子的概率是1/8，右儿子的概率是7/8

然后若干个询问（10^5次），问一个重量为x的球经过结点v的概率

观察路径，可以发现路径可以分成两种，向左走的路径和向右走的路径，分成这两种是因为各自的计算公式，在向左走的路径中，设大于x的点权有a个，小于x的点权有b个，同理定义c d，我们只需要求出a b c d 就可以了。

做法：

貌似很多做法，，我是用主席树多的，对于节点V，建立根节点1到V的前缀线段树，（此过程bfs实现）利用主席树的性质。

然后主席树里面存两个信息，一个是向左走的一个是向右走的。（此题一些细节，二分的时候不注意的话就会一直wa）

 #include <cstdio>
 #include <cstdlib>
 #include <algorithm>
 #include <queue>
 #include <cstring>
 using namespace std;

 const int maxn = 1e5+;
 struct Edge
 {
     int to,next,kind;
 } e[maxn<<];
 int head[maxn],edge_idx;
 void add_edge(int x,int y,int kind)
 {
     e[edge_idx].to = y;
     e[edge_idx].next = head[x];
     e[edge_idx].kind = kind;
     head[x] = edge_idx++;
 }
 //----------------------------------
 int lcnt[maxn*],rcnt[maxn*],lson[maxn*],rson[maxn*];
 int tree[maxn<<],tot,tree_max;
 int build (int l,int r)
 {
     int root = tot++;
     lcnt[root] = rcnt[root] = ;
     if (l != r)
     {
         int mid = (l + r) >> ;
         lson[root] = build(l,mid);
         rson[root] = build(mid+,r);
     }
     return root;
 }
 int update (int root,int pos,int lval,int rval)
 {
     int newroot = tot++;
     int tmp = newroot;
     int l = ,r = tree_max;
     lcnt[newroot] = lcnt[root] + lval;
     rcnt[newroot] = rcnt[root] + rval;
     while (l < r)
     {
         int mid = (l + r) >> ;
         if (pos <= mid)
         {
             r = mid;
             rson[newroot] = rson[root];
             root = lson[root];
             lson[newroot] = tot++;
             newroot = lson[newroot];
         }
         else
         {
             l = mid + ;
             lson[newroot] =lson[root];
             root = rson[root];
             rson[newroot] = tot++;
             newroot = rson[newroot];
         }
         lcnt[newroot] = lcnt[root] + lval;
         rcnt[newroot] = rcnt[root] + rval;
     }
     return tmp;
 }
 int query(int root,int l,int r,int ua,int ub,int kind)
 {
     if (ub < ua)
         return ;
     if (ua <= l && ub >= r)
     {
         if (kind)
             return rcnt[root];
         else
             return lcnt[root];
     }
     int mid = (l + r) >> ;
     int t1 = , t2 = ;
     if (ua <= mid)
         t1 = query(lson[root],l,mid,ua,ub,kind);
     if (ub > mid)
         t2 = query(rson[root],mid+,r,ua,ub,kind);
     return t1 + t2;
 }

 int W[maxn],vec[maxn],idx;
 int hash_(int x)
 {
     return lower_bound(vec,vec+idx,x) - vec + ;
 }
 void init()
 {
     memset(head,-,sizeof(head));
     idx = tot = ;
     edge_idx = ;
 }
 int main(void)
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt","r",stdin);
 #endif
     int T;
     scanf ("%d",&T);
     while (T--)
     {
         init();
         int n,q,m;
         scanf ("%d",&n);
         for (int i = ; i < n ; i++)
         {
             scanf ("%d",W+i+);
             vec[idx++] = W[i+];
         }
         sort(vec,vec+idx);
         idx = unique(vec,vec+idx) - vec;
         scanf ("%d",&m);
         for (int i = ; i < m; i++)
         {
             int x,lf,rg;
             scanf ("%d%d%d",&x,&lf,&rg);
             add_edge(x,lf,);
             add_edge(x,rg,);
         }
         tree_max = n;
         tree[] = build(,n);

         queue<int>Q;
         while (!Q.empty())
             Q.pop();
         Q.push();
         while (!Q.empty())
         {
             int x = Q.front();
             Q.pop();
             for (int i = head[x]; ~i; i = e[i].next)
             {
                 int v,k;
                 v = e[i].to, k = e[i].kind;
                 tree[v] = update(tree[x],hash_(W[x]),k == , k == );
                 Q.push(v);
             }
         }
         scanf ("%d",&q);
         for (int i = ; i < q; i++)
         {
             int x,v;
             scanf ("%d%d",&v,&x);
             if (v == )
             {
                 printf("0 0\n");
                 continue;
             }
             int tmp = x;             //
             x = hash_(x);            // 二分得到的值可能原数组并不存在
             int ua = x-, ub = x;   //理论上要查询x+1，但是如果tmp在原数组中不存在，那么就不用+1了
             int flag = ;
             flag = query(tree[v],,n,x,x,) + query(tree[v],,n,x,x,);
             if (vec[x-] == tmp)
             {
                 if (flag)
                 {
                     printf("0\n");
                     continue;
                 }
                 ub++;
             }
             int lf_small = query(tree[v], , n, ,   ua, );
             int lf_big   = query(tree[v], , n, ub, n,   );
             int rg_small = query(tree[v], , n, ,   ua, );
             int rg_big   = query(tree[v], , n, ub, n,   );
             int ans1 = , ans2 = ;
             ans1 += rg_small;
             ans2 += *(rg_small+lf_small) + rg_big + lf_big;
             printf("%d %d\n",ans1,ans2);
         }
     }
     return ;
 }