zoj 2112 块状链表 OR 线段树套treap 求动态第k大

块链：块内排序方便二分，然后进行类似于冒泡排序的更新即可。

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

const int INF = 1000000000;
const int N = 50000;
const int M = 400;
int a[N];
int b[M][M];
int n, m, ps, num;

void update( int pos, int val )
{
    int cur = pos / ps;
    if ( cur < num - 1 )
    {
        int p = lower_bound( b[cur], b[cur] + ps, a[pos] ) - b[cur];
        if ( val > a[pos] )
        {
            while ( p + 1 < ps && b[cur][p + 1] < val ) 
            {
                b[cur][p] = b[cur][p + 1];
                p++;
            }
        }
        else
        {
            while ( p - 1 >= 0 && b[cur][p - 1] > val )
            {
                b[cur][p] = b[cur][p - 1];
                p--;
            }
        }
        b[cur][p] = val;
    }
    a[pos] = val;
}

int query( int l, int r, int k )
{
    int cur = l / ps, ncur = r / ps;
    int lb = 0, ub = INF;
    while ( lb < ub )
    {
        int mid = ( lb + ub ) >> 1;
        int cnt = 0;
        if ( cur != ncur )
        {
            for ( int i = cur + 1; i <= ncur - 1; i++ )
            {
                cnt += upper_bound( b[i], b[i] + ps, mid ) - b[i];
            }
            for ( int i = l; i < ( cur + 1 ) * ps; i++ )
            {
                if ( a[i] <= mid ) cnt++;
            }
            for ( int i = ncur * ps; i <= r; i++ )
            {
                if ( a[i] <= mid ) cnt++;
            }
        }
        else
        {
            for ( int i = l; i <= r; i++ )
            {
                if ( a[i] <= mid ) cnt++;
            } 
        }
        if ( cnt >= k )
        {
            ub = mid;
        }
        else
        {
            lb = mid + 1;
        }
    }
    return ub;
}

int main ()
{
    int t;
    scanf("%d", &t);
    while ( t-- )
    {
        scanf("%d%d", &n, &m);
        ps = 400;
        for ( int i = 0; i < n; i++ )
        {
            scanf("%d", a + i);
            b[i / ps][i % ps] = a[i];
        }
        num = ( n + ps - 1 ) / ps;
        for ( int i = 0; i < num - 1; i++ )
        {
            sort( b[i], b[i] + ps );
        }
        while ( m-- )
        {
            char op[2];
            int x, y, k;
            scanf("%s", op);
            if ( op[0] == 'Q' )
            {
                scanf("%d%d%d", &x, &y, &k);
                x--, y--;
                printf("%d
", query( x, y, k ));
            }
            else
            {
                scanf("%d%d", &x, &y);
                x--;
                update( x, y );
            }
        }
    }
    return 0;
}

线段树套treap：线段树上的每个结点维护一个treap，里面有该区间的元素，查询时二分答案。

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

const int INF = 1000000000;
const int N = 100001;
int a[N];
int n, m;

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;
}

int ran()
{
    static int x = 1364684679;
    x += ( ( x << 2 ) | 1 );
    return x;
}

void insert( Node * & o, int x )
{
    if ( o == NULL )
    {
        o = new Node();
        o->ch[0] = o->ch[1] = NULL;
        o->v = x;
        o->r = ran();
        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 );
            }
            else
            {
                o->maintain();
            }
        }
    }
}

void remove( Node * & o, int x )
{
    int d = o->cmp(x);
    if ( d == -1 )
    {
        if ( o->cnt > 1 )
        {
            o->cnt--;
            o->size--;
        }
        else
        {
            if ( o->ch[0] != NULL && o->ch[1] != NULL )
            {
                int dd = ( o->ch[0]->r > o->ch[1]->r ? 1 : 0 );
                rotate( o, dd );
                remove( o->ch[dd], x );
            }
            else
            {
                Node * u = o;
                if ( o->ch[0] == NULL ) o = o->ch[1];
                else o = o->ch[0];
                delete u;
            }
            if ( o != NULL ) o->maintain();
        }
    }
    else
    {
        remove( o->ch[d], x );
        o->maintain();
    }
}

int ranker( Node * o, int x, int sum )
{
    if ( o == NULL ) return 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 );
    }
}

struct S
{
    int l, r;
    Node * rt;
} s[N << 2];

Node * build_treap( int l, int r )
{
    Node * o = NULL;
    for ( int i = l; i <= r; i++ )
    {
        insert( o, a[i] );
    }
    return o;
}

void build( int i, int l, int r )
{
    s[i].l = l, s[i].r = r;
    s[i].rt = build_treap( l, r );
    if ( l == r ) return ;
    int mid = ( l + r ) >> 1;
    build( i << 1, l, mid );
    build( i << 1 | 1, mid + 1, r );
}

void update( int i, int pos, int val )
{
    if ( s[i].l == pos && s[i].r == pos )
    {
        s[i].rt->v = val;
        return ;
    }
    remove( s[i].rt, a[pos] );
    insert( s[i].rt, val );
    int mid = ( s[i].l + s[i].r ) >> 1;
    if ( pos <= mid )
    {
        update( i << 1, pos, val );
    }
    else
    {
        update( i << 1 | 1, pos, val );
    }
}

int query( int i, int l, int r, int val )
{
    if ( s[i].l == l && s[i].r == r )
    {
        return ranker( s[i].rt, val, 0 );
    }
    int mid = ( s[i].l + s[i].r ) >> 1;
    if ( r <= mid )
    {
        return query( i << 1, l, r, val );
    }
    else if ( l > mid )
    {
        return query( i << 1 | 1, l, r, val );
    }
    else
    {
        return query( i << 1, l, mid, val ) + query( i << 1 | 1, mid + 1, r, val );
    }
}

int kth( int l, int r, int k )
{
    int lb = 1, ub = INF;
    while ( lb < ub )
    {
        int mid = ( lb + ub ) >> 1;
        int nn = query( 1, l, r, mid );
        if ( nn >= k )
        {
            ub = mid;
        }
        else
        {
            lb = mid + 1;
        }
    }
    return lb;
}

void clear( Node * o )
{
    if ( o == NULL ) return ;
    clear( o->ch[0] );
    clear( o->ch[1] );
    delete o;
}

void del( int i )
{
    if ( s[i].l == s[i].r )
    {
        delete s[i].rt;
        return ;
    }
    del( i << 1 );
    del( i << 1 | 1 );
    clear( s[i].rt );
}

int main ()
{
    while ( scanf("%d", &n) != EOF )
    {
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d", &a[i]);
        }
        build( 1, 1, n );
        scanf("%d", &m);
        while ( m-- )
        {
            int op, x, y, k;
            scanf("%d", &op);
            if ( op == 1 )
            {
                scanf("%d%d", &x, &y);
                update( 1, x, y );
                a[x] = y;
            }
            else
            {
                scanf("%d%d%d", &x, &y, &k);
                printf("%d
", kth( x, y, k ));
            }
        }
        del(1);
    }
    return 0;
}