• 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=100007;
    
    int Ls[N*20],Rs[N*20],cnt[N*20][2];
    int root[N],tot;
    
    int e[N][2];
    int w[N],sort_w[N];
    
    int n;
    
    inline int Hash(int x){
        return upper_bound(sort_w+1,sort_w+n+1,x)-sort_w-1;
    }
    
    inline void init(){
        tot=0;
        memset(e,-1,sizeof(e));
    }
    
    inline int bulidtree(int L,int R){
         int k=tot++;
         cnt[k][0]=cnt[k][1]=0;
         if (L==R) return k;
         int mid=(L+R)>>1;
         Ls[k]=bulidtree(L,mid);
         Rs[k]=bulidtree(mid+1,R);
         return k;
    }
    
    inline void copy(int x,int y){
        Ls[x]=Ls[y];
        Rs[x]=Rs[y];
        cnt[x][0]=cnt[y][0];
        cnt[x][1]=cnt[y][1];
    }
    
    // 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)>>1;
        if (p<=mid) Ls[k]=update(Ls[k],p,to,L,mid);
        else Rs[k]=update(Rs[k],p,to,mid+1,R);
        return k;
    }
    
    inline int query(int o,int x,int y,int to,int L,int R){
        if (x>y) return 0;
        if (L==x && R==y) return cnt[o][to];
        int mid=(L+R)>>1;
        if (y<=mid) return query(Ls[o],x,y,to,L,mid);
        else if (x>mid) return query(Rs[o],x,y,to,mid+1,R);
        else return query(Ls[o],x,mid,to,L,mid)+query(Rs[o],mid+1,y,to,mid+1,R);
    }
    
    inline void dfs(int u){
        for (int i=0;i<=1;i++) if (~e[u][i]) {
            int v=e[u][i];
            root[v]=update(root[u],Hash(w[u]),i,1,n);
            dfs(v);
        }
    }
    
    int main(){
        int t,m,q;
        scanf("%d",&t);
        while (t--){
            init();
    
            scanf("%d",&n);
            for (int i=1;i<=n;i++) {
                scanf("%d",&w[i]);
                sort_w[i]=w[i];
            }
            sort(sort_w+1,sort_w+n+1);
    
            scanf("%d",&m);
            while (m--){
                int u,a,b;
                scanf("%d %d %d",&u, &a, &b);
                e[u][0]=a;
                e[u][1]=b;
            }
    
            root[1]=bulidtree(1,n);
    
            dfs(1);
    
            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,0,1,n) || query(root[v],id,id,1,1,n)){
                        puts("0");
                        continue;
                    }
                }
                
                int L_down=query(root[v],1,id,0,1,n);
                int L_up=query(root[v],id+1,n,0,1,n);
                int R_down=query(root[v],1,id,1,1,n);
                int R_up=query(root[v],id+1,n,1,1,n);
    
                printf("%d %d
    ",R_down,L_up+R_up+3*L_down+3*R_down);
            }
        }
    
        return 0;
    }

    离线树状数组

      1 #include <iostream>
      2 #include <cstdio>
      3 #include <algorithm>
      4 #include <cmath>
      5 #include <cstring>
      6 #include <queue>
      7 #include <set>
      8 #include <vector>
      9 #include <map>
     10 #define ll long long
     11 
     12 using namespace std;
     13 
     14 const int N=100007;
     15 
     16 int w[N],e[N][2];
     17 int sort_w[N];
     18 int c[N][2];  // 树状数组 
     19 int n,Q;
     20 int pos[N];
     21 int ans[N][2];
     22 
     23 struct QUERY{
     24     int v,x,id;
     25     int s;
     26     bool operator < (const QUERY & t) const {
     27         return s<t.s;
     28     }
     29 }q[N];
     30 
     31 inline int Hash(int x){
     32     return upper_bound(sort_w+1,sort_w+n+1,x)-sort_w-1;
     33 }
     34 
     35 inline void init(){
     36     memset(c,0,sizeof(c));
     37     memset(e,0,sizeof(e));
     38 }    
     39 
     40 inline int lowbit(int x){
     41     return x&(-x);
     42 }
     43 
     44 inline void add(int x,int d,int to){
     45     while (x<=n){
     46         c[x][to]+=d;
     47         x+=lowbit(x);
     48     }
     49 }
     50 
     51 inline int sum(int x,int to){
     52     int ret=0;
     53     while (x){
     54         ret+=c[x][to];
     55         x-=lowbit(x);
     56     }
     57     return ret;
     58 }
     59 
     60 inline int query(int L,int R,int to){
     61     return sum(R,to)-sum(L-1,to);
     62 }
     63 
     64 int cnt;
     65 inline void dfs1(int u){
     66     pos[u]=++cnt;
     67     for (int i=0;i<=1;i++) if (e[u][i])
     68         dfs1(e[u][i]);
     69 }
     70 
     71 inline void dfs2(int u){
     72     while (cnt<=Q && q[cnt].v==u){
     73         int id=Hash(q[cnt].x);
     74         if (sort_w[id]==q[cnt].x){
     75             if (query(id,id,0) || query(id,id,1)){
     76                 ans[q[cnt].id][0]=-1;
     77                 cnt++;
     78                 continue;
     79             }
     80         }
     81 
     82         int L_down=query(1,id,0);
     83         int L_up=query(id+1,n,0);
     84         int R_down=query(1,id,1);
     85         int R_up=query(id+1,n,1);
     86 
     87         ans[q[cnt].id][0]=R_down;
     88         ans[q[cnt].id][1]=L_up+R_up+3*L_down+3*R_down;
     89         cnt++;
     90     }
     91 
     92     int id=Hash(w[u]);
     93     for (int i=0;i<=1;i++) if (e[u][i]) {
     94         add(id,1,i);
     95         dfs2(e[u][i]);
     96         add(id,-1,i);
     97     }
     98 }
     99 
    100 int main(){
    101     int t,m;
    102     scanf("%d",&t);
    103     while (t--){
    104         init();
    105 
    106         scanf("%d",&n);
    107         for (int i=1;i<=n;i++) {
    108             scanf("%d",&w[i]);
    109             sort_w[i]=w[i];
    110         }
    111         sort(sort_w+1,sort_w+n+1);
    112 
    113         scanf("%d",&m);
    114         for (int i=1;i<=m;i++){
    115             int u,a,b;
    116             scanf("%d %d %d",&u, &a, &b);
    117             e[u][0]=a;
    118             e[u][1]=b;
    119         }
    120         
    121         scanf("%d",&Q);
    122         for (int i=1;i<=Q;i++){
    123             scanf("%d%d",&q[i].v,&q[i].x);
    124             q[i].id=i;
    125         }
    126 
    127         cnt=1;
    128         dfs1(1);
    129 
    130         for (int i=1;i<=Q;i++) q[i].s=pos[q[i].v];
    131         sort(q+1,q+Q+1);
    132 
    133         cnt=1;
    134         dfs2(1);
    135 
    136         for (int i=1;i<=Q;i++){
    137             if (~ans[i][0]) printf("%d %d
    ",ans[i][0],ans[i][1]);
    138             else puts("0");
    139         }
    140     }
    141 
    142     return 0;
    143 }
  • 相关阅读:
    thinkphp 模板文件
    thinkphp 目录安全文件
    thinkphp 防止sql注入
    thinkphp 表单令牌
    thinkphp 表单合法性检测
    thinkphp 输入过滤
    thinkphp 静态缓存
    thinkphp sql解析缓存
    thinkphp 查询缓存
    thinkphp 快速缓存
  • 原文地址:https://www.cnblogs.com/without-ACM/p/5934658.html
Copyright © 2020-2023  润新知