hdu 4605 Magic Ball Game (在线主席树/离线树状数组)

版权声明：本文为博主原创文章，未经博主允许不得转载。

hdu 4605

题意：

　　有一颗树，根节点为1，每一个节点要么有两个子节点，要么没有，每个节点都有一个权值wi 。然后，有一个球，附带值x 。

　　球到达某个节点上，如果x==wi，那么球停在这个节点上 。当然，这个点是叶子节点也会停止 。

　　如果x<wi，那么有1/2的概率走向左子树，有1/2的概率走向右子树 。

　　如果x>wi，那么有1/8的概率走向左子树，有7/8的概率走向右子树 。

　　问球经过v节点的概率 。（停在v节点也算）

解法：

　　在线的话每一个节点建一棵根节点到该节点的线段树，离线的话就先把询问按DFS序排序，然后瞎搞搞就ok了 。。。

在线主席树

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <map>
#define ll long long

using namespace std;

const int N=;

int Ls[N*],Rs[N*],cnt[N*][];
int root[N],tot;

int e[N][];
int w[N],sort_w[N];

int n;

inline int Hash(int x){
    return upper_bound(sort_w+,sort_w+n+,x)-sort_w-;
}

inline void init(){
    tot=;
    memset(e,-,sizeof(e));
}

inline int bulidtree(int L,int R){
     int k=tot++;
     cnt[k][]=cnt[k][]=;
     if (L==R) return k;
     int mid=(L+R)>>;
     Ls[k]=bulidtree(L,mid);
     Rs[k]=bulidtree(mid+,R);
     return k;
}

inline void copy(int x,int y){
    Ls[x]=Ls[y];
    Rs[x]=Rs[y];
    cnt[x][]=cnt[y][];
    cnt[x][]=cnt[y][];
}

// to 0 左子树  1 右子树
inline int update(int o,int p,int to,int L,int R){
    int k=tot++;
    copy(k,o);
    cnt[k][to]++;
    if (L==R) return k;
    int mid=(L+R)>>;
    if (p<=mid) Ls[k]=update(Ls[k],p,to,L,mid);
    else Rs[k]=update(Rs[k],p,to,mid+,R);
    return k;
}

inline int query(int o,int x,int y,int to,int L,int R){
    if (x>y) return ;
    if (L==x && R==y) return cnt[o][to];
    int mid=(L+R)>>;
    if (y<=mid) return query(Ls[o],x,y,to,L,mid);
    else if (x>mid) return query(Rs[o],x,y,to,mid+,R);
    else return query(Ls[o],x,mid,to,L,mid)+query(Rs[o],mid+,y,to,mid+,R);
}

inline void dfs(int u){
    for (int i=;i<=;i++) if (~e[u][i]) {
        int v=e[u][i];
        root[v]=update(root[u],Hash(w[u]),i,,n);
        dfs(v);
    }
}

int main(){
    int t,m,q;
    scanf("%d",&t);
    while (t--){
        init();

        scanf("%d",&n);
        for (int i=;i<=n;i++) {
            scanf("%d",&w[i]);
            sort_w[i]=w[i];
        }
        sort(sort_w+,sort_w+n+);

        scanf("%d",&m);
        while (m--){
            int u,a,b;
            scanf("%d %d %d",&u, &a, &b);
            e[u][]=a;
            e[u][]=b;
        }

        root[]=bulidtree(,n);

        dfs();

        scanf("%d",&q);
        while (q--){
            int v,x;
            scanf("%d %d",&v,&x);
            int id=Hash(x);
            if (x==sort_w[id]){
                if (query(root[v],id,id,,,n) || query(root[v],id,id,,,n)){
                    puts("");
                    continue;
                }
            }

            int L_down=query(root[v],,id,,,n);
            int L_up=query(root[v],id+,n,,,n);
            int R_down=query(root[v],,id,,,n);
            int R_up=query(root[v],id+,n,,,n);

            printf("%d %d\n",R_down,L_up+R_up+*L_down+*R_down);
        }
    }

    return ;
}

离线树状数组

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <queue>
 #include <set>
 #include <vector>
 #include <map>
 #define ll long long

 using namespace std;

 const int N=;

 int w[N],e[N][];
 int sort_w[N];
 int c[N][];  // 树状数组
 int n,Q;
 int pos[N];
 int ans[N][];

 struct QUERY{
     int v,x,id;
     int s;
     bool operator < (const QUERY & t) const {
         return s<t.s;
     }
 }q[N];

 inline int Hash(int x){
     return upper_bound(sort_w+,sort_w+n+,x)-sort_w-;
 }

 inline void init(){
     memset(c,,sizeof(c));
     memset(e,,sizeof(e));
 }    

 inline int lowbit(int x){
     return x&(-x);
 }

 inline void add(int x,int d,int to){
     while (x<=n){
         c[x][to]+=d;
         x+=lowbit(x);
     }
 }

 inline int sum(int x,int to){
     int ret=;
     while (x){
         ret+=c[x][to];
         x-=lowbit(x);
     }
     return ret;
 }

 inline int query(int L,int R,int to){
     return sum(R,to)-sum(L-,to);
 }

 int cnt;
 inline void dfs1(int u){
     pos[u]=++cnt;
     for (int i=;i<=;i++) if (e[u][i])
         dfs1(e[u][i]);
 }

 inline void dfs2(int u){
     while (cnt<=Q && q[cnt].v==u){
         int id=Hash(q[cnt].x);
         if (sort_w[id]==q[cnt].x){
             if (query(id,id,) || query(id,id,)){
                 ans[q[cnt].id][]=-;
                 cnt++;
                 continue;
             }
         }

         int L_down=query(,id,);
         int L_up=query(id+,n,);
         int R_down=query(,id,);
         int R_up=query(id+,n,);

         ans[q[cnt].id][]=R_down;
         ans[q[cnt].id][]=L_up+R_up+*L_down+*R_down;
         cnt++;
     }

     int id=Hash(w[u]);
     for (int i=;i<=;i++) if (e[u][i]) {
         add(id,,i);
         dfs2(e[u][i]);
         add(id,-,i);
     }
 }

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

         scanf("%d",&n);
         for (int i=;i<=n;i++) {
             scanf("%d",&w[i]);
             sort_w[i]=w[i];
         }
         sort(sort_w+,sort_w+n+);

         scanf("%d",&m);
         for (int i=;i<=m;i++){
             int u,a,b;
             scanf("%d %d %d",&u, &a, &b);
             e[u][]=a;
             e[u][]=b;
         }

         scanf("%d",&Q);
         for (int i=;i<=Q;i++){
             scanf("%d%d",&q[i].v,&q[i].x);
             q[i].id=i;
         }

         cnt=;
         dfs1();

         for (int i=;i<=Q;i++) q[i].s=pos[q[i].v];
         sort(q+,q+Q+);

         cnt=;
         dfs2();

         for (int i=;i<=Q;i++){
             if (~ans[i][]) printf("%d %d\n",ans[i][],ans[i][]);
             else puts("");
         }
     }

     return ;
 }