hdu3436Queue-jumpers（线段树）

链接

这题最不好求的一部分是rank部分 因为top每次都是把一个数放在队头 不会穿插在数组里 也就是说后面没有top过的一部分数 依旧保持有序

这样可以分为两部分来处理 比如 1 2 3 4 5 6 7 TOP 3 TOP 5 TOP 7后 会是这么一种状态 7 5 3    1 2 4 6 这样可以建立两颗线段树一个处理前面一个处理后面

对于N 值很大 肯定是需要离散化的 前面的那颗就可以用普通的求第k大 标记 求和来求出第几 以及x在哪个位置  后面的线段树的值 可以这么来表示 s[w] = num[i]-num[i-1]

这样对于询问rank x  就用线段树找第一个大于等于x的数。

虽然错了很多次，看见那个红红的AC还是很高兴的。。。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<stdlib.h>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
#define N 100010
#define LL long long
#define INF 0xfffffff
const double eps = 1e-8;
const double pi = acos(-1.0);
const double inf = ~0u>>2;
struct node
{
    char s[10];
    int d;
}p[N];
int s[N<<2],o[N<<2],ss[N<<2],oo[N<<2];
int po[N],fo[N],a[N];
bool vis[N];
map<int,int>f;
void up(int w)
{
    s[w] = s[w<<1]+s[w<<1|1];
}
void up1(int w)
{
    ss[w] = ss[w<<1]+ss[w<<1|1];
    oo[w] = oo[w<<1]+oo[w<<1|1];
}
void build(int l,int r,int w)
{
    if(l==r)
    {
        s[w] = oo[w] = 0;
        if(fo[l]>fo[l-1])
        ss[w] = fo[l]-fo[l-1];
        return ;
    }
    int m= (l+r)>>1;
    build(l,m,w<<1);
    build(m+1,r,w<<1|1);
    up(w);
    up1(w);
}

void update(int pos,int k,int d,int l,int r,int w)
{
    if(l==r)
    {
        s[w] = d;
        if(d)
        {
            po[k] = l;
            o[w] = fo[k];
           // cout<<k<<" "<<fo[k]<<endl;

        }
        return ;
    }
    int m = (l+r)>>1;
    if(pos>m) update(pos,k,d,m+1,r,w<<1|1);
    else update(pos,k,d,l,m,w<<1);
    up(w);
}
void update1(int k,int l,int r,int w)
{
    if(l==r)
    {
        ss[w]--;
        oo[w] = 1;
        return ;
    }
    int m = (l+r)>>1;
    if(k>m) update1(k,m+1,r,w<<1|1);
    else update1(k,l,m,w<<1);
    up1(w);
}
int query(int p,int l,int r,int w)
{
    if(l==r)
    {
        return o[w];
    }
    int m = (l+r)>>1;
    if(p>s[w<<1]) return query(p-s[w<<1],m+1,r,w<<1|1);
    else return query(p,l,m,w<<1);
}
int query1(int p,int l,int r,int w)
{//cout<<l<<" "<<r<<" "<<ss[w]<<" "<<p<<endl;
    if(l==r)
    {
        //cout<<l<<endl;
        if(vis[l])
        return fo[l]-1-(ss[w]-p);
        else
        return fo[l]-(ss[w]-p);
    }
    int m = (l+r)>>1;
    if(p<=ss[w<<1])
    return query1(p,l,m,w<<1);
    else
    return query1(p-ss[w<<1],m+1,r,w<<1|1);
}
int getsum(int a,int b,int l,int r,int w)
{
    if(a<=l&&b>=r)
    return s[w];
    int m = (l+r)>>1;
    int re = 0;
    if(a<=m)
    re+=getsum(a,b,l,m,w<<1);
    if(b>m)
    re+=getsum(a,b,m+1,r,w<<1|1);
    return re;
}
int getsum1(int a,int b,int l,int r,int w)
{
    if(a<=l&&b>=r)
    return oo[w];
    int m = (l+r)>>1;
    int re = 0;
    if(a<=m)
    re+=getsum1(a,b,l,m,w<<1);
    if(b>m)
    re+=getsum1(a,b,m+1,r,w<<1|1);
    return re;
}
int main()
{
    int i,n,q,kk=0,t;
    cin>>t;
    while(t--)
    {
        memset(vis,0,sizeof(vis));
        memset(fo,0,sizeof(fo));
        memset(o,0,sizeof(o));
        f.clear();
        scanf("%d%d",&n,&q);
        for(i = 0 ; i < q; i++)
        {
            scanf("%s%d",p[i].s,&p[i].d);
            a[i] = p[i].d;
        }
        sort(a,a+q);
        int g = 0;
        for(i = 0;i < q ;i++)
        {
            if(!f[a[i]])
            {
                g++;
                f[a[i]] = g;
                fo[g] = a[i];
                //cout<<g<<" "<<a[i]<<endl;
            }
        }
        g++;
        f[n+1] = g;
        fo[g] = n+1;
        g = q+1;
        build(1,g,1);
        int e = g+1;
        printf("Case %d:
",++kk);
        for(i = 0 ; i < q ; i++)
        {
            int k = f[p[i].d];
            if(strcmp(p[i].s,"Top")==0)
            {
                e--;
                if(vis[k])
                    update(po[k],k,0,1,g,1);
                else
                    update1(k,1,g,1);
                update(e,k,1,1,g,1);
                vis[k]= 1;
            }
            else if(strcmp(p[i].s,"Rank")==0)
            {
                //int sum = getsum(1,g,1,g,1);
                //cout<<s[1]<<endl;
               //cout<<getsum1(1,2,1,g,1)<<endl;
                if(p[i].d>s[1])
                {
                    int cnt = query1(p[i].d-s[1],1,g,1);
                    printf("%d
",cnt);
                }
                else
                {
                    printf("%d
",query(p[i].d,1,g,1));
                }
            }
            else
            {
                if(vis[k])
                {
                    int cnt = getsum(1,po[k],1,g,1);
                    //cout<<po[k]<<endl;
                    printf("%d
",cnt);
                }
                else
                {
                    if(k==g)
                    cout<<p[i].d<<endl;
                    else
                    {
                        int cnt = getsum1(k+1,g,1,g,1);
                        printf("%d
",cnt+p[i].d);
                    }
                }
            }
        }
    }
    return 0;
}