hdu4441 Queue Sequence(线段树+splay)

题目请戳这里

题目大意：有对队列的一系列操作，+i表示i入队，-i表示i出队，现在对这些操作进行操作。

insert p表示在当前操作序列的第p号位置插入一个操作+i，其中i是当前操作序列中未出现的最小的正整数，p从0开始，i从1开始；同时将-i操作插入某个恰当的位置，保证这个位置尽量靠右，并且当从左往右扫描这个操作序列的时候，扫到-i的时候，当前队首元素为i；

remove i表示将操作序列中的+i操作和-i操作删除；

query i表示查询+i操作和-i操作中间数的和；

题目分析：数据结构不错的题目。解法是线段树+splay。

这题充分发挥了线段树和splay二者的优点，并将各自的操作取长补短，有机的结合了起来。

先来看看这题要我们做什么吧；

首先insert操作中要在p位置插入当前未出现的最小正整数的操作，这个线段树比较擅长，统计出现过的正整数，然后直接查找就ok，将其插入p位置，因为有大量的删除操作，也就是说整个操作序列是不断变化的，不仅仅是内容，长度也在不断改变，所以每个位置的数的序号也在时刻改变着，所以线段树就不适合完成这样的功能，而这正是splay所擅长的。所以这部分操作交给splay完成。考虑到-i操作的插入限制，看似复杂，其实也简单，就是保证每个-i在负数序列中的序号和+i在正数序列中的序号相同即可，要保证尽量靠右的话，直接在-i下一个负数前面插入-i即可，通过splay的伸展功能，变换姿势，轻松完成。

remove操作和query操作此处省略很多字。。

remove操作中要迅速定位+i和-i操作的位置，那么直接在线段树中维护2个值pos1和pos2，这样每次直接可以定位，轻松删除。

这题其实并不难想，只可惜比赛的时候卡在麻将上了，这题都没有读。我不敢说读了这题就一定能过，但是下次比赛还是要坚持读完题目。。

还有，打死你我也不会告诉你我竟然被__int64卡了半天。。。太坑了，，，没有数据范围，求和的时候会爆int的。。。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100005;
typedef __int64 ll;
struct smt
{
    int num,pos1,pos2;
}lcm[N<<2];
struct spt
{
    int size,l,r,f,key,negative,positive;
    ll sum;
}tree[N<<1];
int next[N<<1];
int n;
void show(int rt)
{
    if(rt)
    {
        show(tree[rt].l);
        printf("结点%2d:左儿子 %2d 右儿子 %2d 父结点 %2d key = %2d size = %2d ,sum = %2d\n",rt,tree[rt].l,tree[rt].r,tree[rt].f,tree[rt].key,tree[rt].size,tree[rt].sum);
        show(tree[rt].r);
    }
}
void debug(int rt)
{
    printf("root:%d\n",rt);
    show(rt);
}

void init()
{
    tree[0].f = tree[0].l = tree[0].r = tree[0].key = tree[0].sum = tree[0].size = 0;
    tree[0].negative = tree[0].positive = 0;
    for(int i = 0;i < 200002;i ++)
        next[i] = i + 1;
}

int newnode(int ky)
{
    int p = next[0];
    next[0] = next[p];
    tree[p].key = tree[p].sum = ky;
    tree[p].l = tree[p].r = tree[p].f = 0;
    tree[p].positive = tree[p].negative = 0;
    if(ky > 0)
        tree[p].positive = 1;
    if(ky < 0)
        tree[p].negative = 1;
    tree[p].size = 1;
    return p;
}
void delnode(int p)
{
    tree[p].l = tree[p].r = tree[p].f = tree[p].key = tree[p].size = tree[p].sum = 0;
    tree[p].positive = tree[p].negative = 0;
    next[p] = next[0];
    next[0] = p;
}
void pushup(int rt)
{
    if(rt)
    {
        tree[rt].size = tree[tree[rt].l].size + tree[tree[rt].r].size + 1;
        tree[rt].sum = tree[tree[rt].l].sum + tree[tree[rt].r].sum + tree[rt].key;
        tree[rt].negative = tree[tree[rt].l].negative + tree[tree[rt].r].negative;
        tree[rt].positive = tree[tree[rt].l].positive + tree[tree[rt].r].positive;
        if(tree[rt].key > 0)
            tree[rt].positive ++;
        if(tree[rt].key < 0)
            tree[rt].negative ++;
    }
}
void zig(int x)
{
    int p = tree[x].f;
    tree[p].l = tree[x].r;
    if(tree[x].r)
        tree[tree[x].r].f = p;
    pushup(p);
    tree[x].r = p;
    tree[x].f = tree[p].f;
    pushup(x);
    tree[p].f = x;
    if(tree[x].f == 0)
        return;
    if(tree[tree[x].f].l == tree[x].r)
        tree[tree[x].f].l = x;
    else
        tree[tree[x].f].r = x;
}
void zag(int x)
{
    int p = tree[x].f;
    tree[p].r = tree[x].l;
    if(tree[x].l)
        tree[tree[x].l].f = p;
    pushup(p);
    tree[x].l = p;
    tree[x].f = tree[p].f;
    pushup(x);
    tree[p].f = x;
    if(tree[x].f == 0)
        return;
    if(tree[tree[x].f].l == tree[x].l)
        tree[tree[x].f].l = x;
    else
        tree[tree[x].f].r = x;
}
int splay(int x,int goal)
{
    while(tree[x].f != goal)
    {
        int p = tree[x].f;
        int g = tree[p].f;
        if(g == goal)
        {
            if(tree[p].l == x)
                zig(x);
            if(tree[p].r == x)
                zag(x);
        }
        else
        {
            if(tree[g].l == p && tree[p].l == x)
                zig(p),zig(x);
            else if(tree[g].l == p && tree[p].r == x)
                    zag(x),zig(x);
            else if(tree[g].r == p && tree[p].l == x)
                    zig(x),zag(x);
                else if(tree[g].r == p && tree[p].r == x)
                        zag(p),zag(x);
        }
    }
    pushup(x);
    return x;
}
void prepare(int &root)
{
    root = newnode(0);
    tree[root].r = newnode(0);
    tree[tree[root].r].f = root;
    pushup(tree[root].r);
    pushup(root);
}
int get(int pos,int rt)
{
    if(!rt)
        return 0;
    if(tree[tree[rt].l].size == pos - 1)
        return rt;
    if(tree[tree[rt].l].size >= pos)
        return get(pos,tree[rt].l);
    else
        return get(pos - tree[tree[rt].l].size - 1,tree[rt].r);

}
int getneg(int pos,int rt)
{
    if(!rt)
        return 0;
    if(tree[tree[rt].l].negative == pos - 1 && tree[rt].key < 0)
        return rt;
    if(tree[tree[rt].l].negative >= pos)
        return getneg(pos,tree[rt].l);
    else
    {
        if(tree[rt].key > 0)
            return getneg(pos - tree[tree[rt].l].negative,tree[rt].r);
        else
            return getneg(pos - tree[tree[rt].l].negative - 1,tree[rt].r);
    }
}
void delspt(int rt)
{
    if(!rt)
        return;
    delspt(tree[rt].l);
    delspt(tree[rt].r);
    delnode(rt);
}
/*********************splay tree*******************/
void build(int num,int s,int e)
{
    lcm[num].num = lcm[num].pos1 = lcm[num].pos2 = 0;
    if(s == e)
        return;
    int mid = (s + e)>>1;
    build(num<<1,s,mid);
    build(num<<1|1,mid + 1,e);
}
int find(int num,int s,int e)
{
    if(s == e)
        return s;
    int mid = (s + e)>>1;
    if(lcm[num<<1].num < mid - s + 1)
        return find(num<<1,s,mid);
    else
        return find(num<<1|1,mid + 1,e);
}
void insert(int num,int s,int e,int pos,int p1,int p2)
{
    if(s == e)
    {
        lcm[num].num = 1;
        lcm[num].pos1 = p1;
        lcm[num].pos2 = p2;
        return;
    }
    int mid = (s + e)>>1;
    if(pos <= mid)
        insert(num<<1,s,mid,pos,p1,p2);
    else
        insert(num<<1|1,mid + 1,e,pos,p1,p2);
    lcm[num].num = lcm[num<<1].num + lcm[num<<1|1].num;
}
void getpos(int num,int s,int e,int pos,int &p1,int &p2,int del)
{
    if(s == e)
    {
        p1 = lcm[num].pos1;
        p2 = lcm[num].pos2;
        if(del)
            lcm[num].num = lcm[num].pos1 = lcm[num].pos2 = 0;
        return;
    }
    int mid = (s + e)>>1;
    if(pos <= mid)
        getpos(num<<1,s,mid,pos,p1,p2,del);
    else
        getpos(num<<1|1,mid + 1,e,pos,p1,p2,del);
    lcm[num].num = lcm[num<<1].num + lcm[num<<1|1].num;
}
/*******************segment tree**********************/
void insertspt(int x,int &root)
{
    int i = find(1,1,n);
    int p1 = newnode(i);
    int p2 = newnode(-i);
    int l = get(x + 1,root);
    int r = get(x + 2,root);
    root = splay(l,0);
    tree[root].r = splay(r,root);
    tree[tree[root].r].l = p1;
    tree[p1].f = tree[root].r;
    root = splay(p1,0);
    int pos = tree[tree[root].l].positive + 1;
    int neg = tree[tree[root].l].negative;
    if(tree[tree[root].r].negative < pos - neg)
        l = get(tree[root].size,root);
    else
        l = getneg(pos - neg,tree[root].r);
    root = splay(l,0);
    r = get(tree[tree[root].l].size,tree[root].l);
    tree[root].l = splay(r,root);
    tree[tree[root].l].r = p2;
    tree[p2].f = tree[root].l;
    root = splay(p2,0);
    insert(1,1,n,i,p1,p2);
}
void remove(int x,int &root)
{
    int p1,p2;
    getpos(1,1,n,x,p1,p2,1);
    root = splay(p1,0);
    int r = get(1,tree[root].r);
    tree[root].r = splay(r,root);
    tree[tree[root].r].l = tree[root].l;
    tree[tree[root].l].f = tree[root].r;
    int p = root;
    root = tree[root].r;
    tree[root].f = 0;//important
    delnode(p);
    pushup(root);
    root = splay(p2,0);
    r = get(1,tree[root].r);
    tree[root].r = splay(r,root);
    tree[tree[root].r].l = tree[root].l;
    tree[tree[root].l].f = tree[root].r;
    p = root;
    root = tree[root].r;
    tree[root].f = 0;
    delnode(p);
    pushup(root);
}
void query(int x,int &root)
{
    int p1,p2;
    getpos(1,1,n,x,p1,p2,0);
    root = splay(p1,0);
    tree[root].r = splay(p2,root);
    printf("%I64d\n",tree[tree[tree[root].r].l].sum);
}

int main()
{
    int cas = 0;
    char op[20];
    int root;
    int x,m;

    init();
    while(scanf("%d",&n) != EOF)
    {
        m = n;
        build(1,1,n);
        prepare(root);
        printf("Case #%d:\n",++cas);
        while(m --)
        {
            scanf("%s",op);
            scanf("%d",&x);
            switch(*op)
            {
            case 'i':insertspt(x,root);break;
            case 'r':remove(x,root);break;
            case 'q':query(x,root);break;
            }
        }
        delspt(root);
    }
    return 0;
}
//1171MS	11152K
/*
6
insert 0
insert 0
remove 2
query 1
insert 1
query 2
10
insert 0
insert 1
query 1
query 2
insert 2
query 2
remove 1
remove 2
insert 2
query 3

19
insert 0
insert 0
insert 0
insert 0
query 1
query 2
query 3
query 4
remove 2
query 1
query 3
query 4
remove 4
query 1
query 3
insert 3
query 1
query 2
query 3

8
insert 0
insert 2
insert 1
insert 3
query 1
query 2
query 3
query 4

11
insert 0
insert 2
insert 4
query 1
query 2
query 3
remove 2
insert 3
query 1
query 2
query 3
*/