POJ 2352 Star Treap||树状数组

                   发现这道题目用Treap居然可以做。。好吧，我从来没有想过，但是稍微思考一下发现这样也确实是有可行性，用Treap写完以后发现，用了500ms+,于是想看看用树状数组写要用多久，树状数组用了接近400ms，其实时间是差不多的，但是代码长度树状数组几乎是Treap的一半。。果然还是树状数组好写呀。

                  Treap的想法是插入横坐标，因为纵坐标单调递增，所以每一次只需要在Treap里面查询那些横坐标小于等于当前坐标的即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<iostream>
using namespace std;
typedef long long ll;

ll cnt=1,rt;
struct Node{
    ll son[2],pri,val,sz;
    void set_size();
    void newnode(ll v){son[0]=son[1]=0;sz=1,pri=rand(),val=v;}
}tree[100010];

void Node::set_size(){
     sz=1+tree[son[0]].sz+tree[son[1]].sz;
}

void rot(bool p,ll &x){
    ll k=tree[x].son[!p];
    tree[x].son[!p]=tree[k].son[p];
    tree[k].son[p]=x;
    tree[x].set_size();
    tree[k].set_size();
    x=k;
}

void ins(ll key,ll &x){
    if(x){
        bool p=key>=tree[x].val;
        //printf("ins:%d %d %d\n",key,tree[x].val,key>=tree[x].val);
        ins(key,tree[x].son[p]);
        if(tree[tree[x].son[p]].pri>tree[x].pri)
            rot(!p,x);
    }
    else
        tree[x=cnt++].newnode(key);
    tree[x].set_size();
}

void del(ll key,ll &x){
    if(key==tree[x].val){
        if(!tree[x].son[0])
            x=tree[x].son[1];
        else if(!tree[x].son[1])
            x=tree[x].son[0];
        else{
            bool p=tree[tree[x].son[0]].pri>tree[tree[x].son[1]].pri;
            rot(p,x);
            del(key,tree[x].son[p]);
        }
    }
    else
        del(key,tree[x].son[key>=tree[x].val]);
    if(x)
        tree[x].set_size();
}

ll find_num(ll key,ll &x){
    if(!x)
        return 0;
    if(tree[x].val>key)
        return find_num(key,tree[x].son[0]);
    else
        return tree[tree[x].son[0]].sz+1+find_num(key,tree[x].son[1]);
}

ll find_rank(ll level,ll &x){
    if(level==tree[tree[x].son[0]].sz+1)
        return x;
    else if(level>tree[tree[x].son[0]].sz+1)
        return find_rank(level-tree[tree[x].son[0]].sz-1,tree[x].son[1]);
    else
        return find_rank(level,tree[x].son[0]);
}

int n,x,y,level[15010];

int main(){
    while(scanf("%d",&n)!=EOF){
        for(int i=0;i<n;++i)
            scanf("%d%d",&x,&y),level[find_num(x,rt)]++,ins(x,rt);
        for(int i=0;i<n;++i)
            printf("%d\n",level[i]);
        memset(level,0,sizeof(int)*n);
        cnt=1,rt=0;
    }
    return 0;
}

if(!x) tree[x=cnt++]=Tree(key,rand(),1); else{ ++tree[x].sz; bool p=key<tree[x].key; ins(key,tree[x].son[!p]); if(tree[x].pri<tree[tree[x].son[!p]].pri) rot(p,x); }}int find_num(int key,int &x){ if(!x) return 0; else if(tree[x].key<=key) return tree[tree[x].son[0]].sz+1+find_num(key,tree[x].son[1]); else return find_num(key,tree[x].son[0]);}

                   树状数组的想法也是一样的，插入横坐标，查询小于等于当前横坐标的个数即可

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

using namespace std;

int n,level[15010],bit[32010],x,y;
void update(int index);
int query(int index);

int main(){
    while(scanf("%d",&n)!=EOF){
        for(int i=1;i<=n;++i){
            scanf("%d%d",&x,&y);
            level[query(x+1)]++;
            update(x+1);
        }
        for(int i=0;i<n;++i)
            printf("%d\n",level[i]);
        memset(level,0,sizeof(int)*n);
        memset(bit,0,sizeof bit);
    }
    return 0;
}

void update(int index){
    while(index<=32001)
        bit[index]++,index+=index&-index;
}

int query(int index){
    int ans=0;
    while(index)
        ans+=bit[index],index-=index&-index;
    return ans;
}

               显然树状数组要短很多呀