hdu3727Jewel(划分树+二分)

题目请戳这里

题目大意：给许多操作，4类：

1，insert x，插入一个数x，x范围2^31内（题目描述有误）

2，query_1 s t k，查询范围[s,t]内第k小的数，s<=t<=len(当前数字长度)

3,query_2 x   查询x的rank，从小到大。x保证出现过

4，query_3 x，查询[1,len]第x小的数。

输出3个数，为3个询问累加和。

题目分析：由于没有删除操作，所以加入的数字序列是不变的，所以离线处理。

q1和q3其实是一个操作，查询区间第k大值问题，划分树搞。

q2的话，其实也可以通过二分转化为划分树操作。如果愿意，写棵线段树单独维护一下也是可以的，不过要离散化。为了偷懒，选择二分+划分树啦

关于划分树，其实也是基于线段树的一个数据结构，模拟归并排序的过程，不断分治。详细讲解戳这里

详情请见代码：

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100005;
const int M = 110005;
const int DEEP = 20;
typedef __int64 ll;
ll ans[3];
struct node
{
    int optype;
    int a,b,c;
}op[M];
int n,m;
char str[20];
int num[DEEP][N],lefta[DEEP][N],lcm[N];

void build(int s,int e,int nm,int dp)
{
    if(s == e)
        return;
    int mid = (s + e)>>1;
    int lsame = mid - s + 1;
    int i,same = 0;
    for(i = s;i <= e;i ++)
        if(num[dp][i] < lcm[mid])
            lsame --;
    int lpos = s,rpos = mid + 1;
    for(i = s;i <= e;i ++)
    {
        if(i == s)
            lefta[dp][i] = 0;
        else
            lefta[dp][i] = lefta[dp][i - 1];
        if(num[dp][i] < lcm[mid])
        {
            lefta[dp][i] ++;
            num[dp + 1][lpos ++] = num[dp][i];
        }
        else
        {
            if(num[dp][i] > lcm[mid])
                num[dp + 1][rpos ++] = num[dp][i];
            else
            {
                if(same < lsame)
                {
                    same ++;
                    lefta[dp][i] ++;
                    num[dp + 1][lpos ++] = num[dp][i];
                }
                else
                    num[dp + 1][rpos ++] = num[dp][i];
            }
        }
    }
    build(s,mid,nm<<1,dp + 1);
    build(mid + 1,e,nm<<1|1,dp + 1);
}
int query(int s,int e,int nm,int dp,int l,int r,int k)
{
    if(s == e)
        return num[dp][s];
    int mid = (s + e)>>1;
    int sa,sb;
    if(s == l)
        sb = 0;
    else
        sb = lefta[dp][l - 1];
    sa = lefta[dp][r] - sb;
    if(sa >= k)
    {
        int newl = s + sb;
        int newr = s + sb + sa - 1;
        return query(s,mid,nm<<1,dp + 1,newl,newr,k);
    }
    else
    {
        int bb = l - s - sb;
        int b = r - l + 1 - sa;
        int newl = mid + bb + 1;
        int newr = mid + bb + b;
        return query(mid + 1,e,nm<<1|1,dp + 1,newl,newr,k - sa);
    }
}
ll getans1(int a,int b,int c)
{
    int mid,la,ra;
    la = a;ra = b;
    while(la <= ra)
    {
        mid = (la + ra)>>1;
        int tmp = query(1,n,1,0,a,b,mid);
        if(tmp == c)
            return mid - a + 1;
        else if(tmp > c)
                ra = mid - 1;
            else
                la = mid + 1;
    }
}
int main()
{
    int i;
    int t,q,a,b,c,cas = 0;
    while(~scanf("%d",&q))
    {
        n = m = 1;
        while(q --)
        {
            scanf("%s",str);
            if(str[0] == 'I')
            {
                scanf("%d",&lcm[n]);
                num[0][n] = lcm[n ++];
            }
            else
            {
                if(str[strlen(str) - 1] == '1')
                {
                    scanf("%d%d%d",&a,&b,&c);
                    op[m].optype = 0;
                    op[m].a = a;op[m].b = b;op[m ++].c = c;
                }
                else if(str[strlen(str) - 1] == '2')
                    {
                        scanf("%d",&a);
                        op[m].optype = 1;
                        op[m].a = 1;op[m].b = n - 1;
                        op[m ++].c = a;
                    }
                    else
                    {
                        scanf("%d",&a);
                        op[m].optype = 2;
                        op[m].a = 1;op[m].b = n - 1;
                        op[m ++].c = a;
                    }
            }
        }
        sort(lcm + 1,lcm + n);
        n --;
        build(1,n,1,0);
        ans[1] = ans[0] = ans[2] = 0;
        for(i = 1;i < m;i ++)
        {
            if(op[i].optype == 1)
            {
                int tmp = getans1(op[i].a,op[i].b,op[i].c);
                ans[op[i].optype] += tmp;
            }
            else
            {
                int tmp = query(1,n,1,0,op[i].a,op[i].b,op[i].c);
                ans[op[i].optype] += tmp;
            }
        }
        printf("Case %d:\n%I64d\n%I64d\n%I64d\n",++cas,ans[0],ans[1],ans[2]);
    }
    return 0;
}
//265MS	15908K