poj 2352 树状数组 OR Treap

由于星星是按照y从小到大，y相同x从小到大排好序的（其实没排好也没关系，我们有sort和cmp大法），所以只要不断地求某个位置的前缀和就好了，可以用树状数组或Treap来维护。

树状数组：

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 32002;
int c[N];
const int M = 15000;
int level[M];

int lb( int i )
{
    return i & -i;
}

void update( int i )
{
    while ( i < N )
    {
        c[i]++;
        i += lb(i);
    }
}

int get( int i )
{
    int ans = 0;
    while ( i )
    {
        ans += c[i];
        i -= lb(i);
    }
    return ans;
}

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

Treap：由于有重复元素所以结点多维护了一个cnt，表示x为该值的星星个数。

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;

struct Node 
{
    Node * ch[2];
    int v, r, size, cnt;
    int cmp( int x )
    {
        if ( x == v ) return -1;
        return x < v ? 0 : 1;
    }    
    void maintain()
    {
        size = cnt;
        if ( ch[0] != NULL ) size += ch[0]->size;
        if ( ch[1] != NULL ) size += ch[1]->size;
    }
};

void rotate( Node * & o, int d )
{
    Node * k = o->ch[d ^ 1];
    o->ch[d ^ 1] = k->ch[d];
    k->ch[d] = o;
    o->maintain();
    k->maintain();
    o = k;
}

void insert( Node * & o, int x )
{
    if ( o == NULL )
    {
        o = new Node();
        o->ch[0] = o->ch[1] = NULL;
        o->v = x;
        o->r = rand();
        o->size = o->cnt = 1;
    }
    else
    {
        int d = o->cmp(x);
        if ( d == -1 )
        {
            o->cnt++;
            o->size++;
        }
        else
        {
            insert( o->ch[d], x );
            if ( o->ch[d]->r > o->r )
            {
                rotate( o, d ^ 1 );
            }
            o->maintain();
        }
    }
}

int ranker( Node * o, int x, int sum )
{
    int d = o->cmp(x);
    if ( d == -1 )
    {
        return sum + ( o->ch[0] == NULL ? 0 : o->ch[0]->size ) + o->cnt;
    }
    else if ( d == 0 )    
    {
        return ranker( o->ch[0], x, sum );
    }
    else
    {
        int tmp = ( o->ch[0] == NULL ? 0 : o->ch[0]->size );
        return ranker( o->ch[1], x, sum + tmp + o->cnt );
    }
}

const int N = 15001;
int ans[N];

int main ()
{
    int n;
    while ( scanf("%d", &n) != EOF )
    {
        Node * root = NULL;
        memset( ans, 0, sizeof(ans) );
        for ( int i = 0; i < n; i++ )
        {
            int x, y;
            scanf("%d%d", &x, &y);
            insert( root, x );
            ans[ranker( root, x, 0 )]++;
        }
        for ( int i = 1; i <= n; i++ )
        {
            printf("%d
", ans[i]);
        }
    }
    return 0;
}