SBT专题训练

SBT的资料很多（陈启峰的论文以及下面的blog），在这里就不再叙述：给出下面几道题目以及代码：

http://www.cnblogs.com/reflec94/archive/2011/01/22/1942095.html

 

BZOJ   1208     [HNOI2002]营业额统计 {Insert , pred , succ , find}

/*

题目：
    最小波动值= min { | 该天以前某一天的营业额-该天的营业额 | }

分析：
    求前驱以及后继与当前的数相减的绝对值的最小值。

*/
#include <cstdio>
#include <cstring>
#include <iostream>
#include <cstdlib>

using namespace std;

const int X = 1111111;

int root,tol,n;
bool use[X] = {0};

struct node{
    int val,l,r,s;
    void init(int _val){
        l = r = 0;
        s = 1;
        val = _val;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init(val);
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int get_pre(int t,int val){
    if(!t)
        return val;
    if(val<=sbt[t].val)
        return get_pre(sbt[t].l,val);
    else{
        int temp = get_pre(sbt[t].r,val);
        return temp==val?sbt[t].val:temp;
    }
}

int get_succ(int t,int val){
    if(!t)
        return val;
    if(val>=sbt[t].val)
        return get_succ(sbt[t].r,val);
    else{
        int temp = get_succ(sbt[t].l,val);
        return temp==val?sbt[t].val:temp;
    }
}

int main(){
    freopen("sum.in","r",stdin);
    //freopen("sum.out","w",stdout);
    root = tol = 0;
    int ans = 0,x;
    cin>>n>>x;
    int qq = 1000000;
    ans = x;
    insert(root,x);
    use[x+qq] = true;
    int xx,yy;
    for(int i=1;i<n;i++){
        if(scanf("%d",&x)==EOF)
            x = 0;
        if(use[qq+x])
            continue;
        use[qq+x] = true;
        if(!(xx = x-get_pre(root,x)))
            xx = X;
        if(!(yy = get_succ(root,x)-x))
            yy = X;

        ans += min(xx,yy);
        insert(root,x);
    }
    cout<<ans<<endl;
    return 0;
}

 

BZOJ   1503     [NOI2004]郁闷的出纳员 {Insert , DeleteSmall , Select}

/*

题目：
    第一行有两个非负整数n和min。n表示下面有多少条命令，min表示工资下界。
    接下来的n行，每行表示一条命令。命令可以是以下四种之一：
    I命令(I k): 新建一个工资档案，初始工资为k。如果某员工的初始工资低
    于工资下界，他将立刻离开公司。
    A命令(A k): 把每位员工的工资加上k
    S命令(S k): 把每位员工的工资扣除k
    F命令(F k): 查询第k多的工资
    一旦某位员工发现自己的工资已经低于了合同规定的工资下界，他就会立刻
    气愤地离开公司，并且再也不会回来了。问现在工资第k多的员工拿多少工资

分析：
    像线段树的lazy标记一样，设置标记delay表示当前为止已经增加了的工资，
    若重新来了一名新员工的话，得要把他的工资减掉delay，表示他现在的工资
    （因为在delete操作中是SBT中的val值加上delay）。其他的基本如同SBT求
    第K大了。

*/
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int X = 100005;

int root,tol;

struct node{
    int l,r,val,s;
    void init(){
        l = r = 0;
        s = 1;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else
            return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else
            return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init();
        sbt[t].val = val;
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)
        return 0;
    sbt[t].s--;
    if(sbt[t].val==val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    else
        return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

void Delete(int &t,int delay,int min_val){
    if(!t)
        return;
    if(sbt[t].val+delay<min_val){
        t = sbt[t].r;
        Delete(t,delay,min_val);
    }
    else{
        Delete(sbt[t].l,delay,min_val);
        sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    }
}

int find_k(int &t,int k){
    if(k<=sbt[sbt[t].l].s)
        return find_k(sbt[t].l,k);
    else if(k>sbt[sbt[t].l].s+1)
        return find_k(sbt[t].r,k-sbt[sbt[t].l].s-1);
    else
        return sbt[t].val;
}

int find_k_max(int &t,int k){
    if(k<=sbt[sbt[t].r].s)
        return find_k_max(sbt[t].r,k);
    else if(k>sbt[sbt[t].r].s+1)
        return find_k_max(sbt[t].l,k-sbt[sbt[t].r].s-1);
    else
        return sbt[t].val;
}

int get_rank(int &t,int val){
    if(val<sbt[t].val)
        return get_rank(sbt[t].l,val);
    else if(val>sbt[t].val)
        return get_rank(sbt[t].r,val)+sbt[sbt[t].l].s+1;
    else
        return sbt[sbt[t].l].s+1;
}

void inorder(int &t){
    if(!t)
        return;
    inorder(sbt[t].l);
    printf("%d\n",sbt[t].val);
    inorder(sbt[t].r);
}

int get_min(int &t){
    while(sbt[t].l)
        t = sbt[t].l;
    return t;
}

int get_max(int &t){
    while(sbt[t].r)
        t = sbt[t].r;
    return t;
}

int main(){
    freopen("sum.in","r",stdin);
    int x;
    int n,min_val,delay;
    char str[5];
    while(cin>>n>>min_val){
        root = delay = tol = 0;
        while(n--){
            scanf("%s%d",str,&x);
            if(str[0]=='I'){
                if(x<min_val)
                    continue;
                insert(root,x-delay);
            }
            else if(str[0]=='A')
                delay += x;
            else if(str[0]=='S'){
                delay -= x;
                Delete(root,delay,min_val);
            }
            else
                printf("%d\n",sbt[root].s>=x?find_k_max(root,x)+delay:-1);
        }
        printf("%d\n",tol-sbt[root].s);
    }
    return 0;
}

 

BZOJ   1588     [HNOI2004]宠物收养所 {Insert , pred , succ , Delete}

/*

分析：
    SBT功能的应用：删除、前驱、后继
    这题就是简单的元素插入删除操作，注意一下绝对值相同的时候取较小的即可，
    还有就是每次收养所里要么都是人，要么都是宠物。
    当树种相同的时候，直接插入SBT中，当树种不一样的时候，从SBT中找到满足条
    件的前驱或者后继，更新答案后在SBT中删除该值即可

*/
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int X = 1000005;
const long long mod = 1000000;
#define debug puts("here");

int root,tol;

struct node{
    int l,r,s,val;
    void init(int _val){
        l = r = 0;
        s = 1;
        val = _val;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].l].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init(val);
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)  return 0;
    sbt[t].s--;
    if(val==sbt[t].val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int get_pre(int t,int val){
    if(!t)  return val;
    if(val<=sbt[t].val)
        return get_pre(sbt[t].l,val);
    else{
        int temp = get_pre(sbt[t].r,val);
        return temp==val?sbt[t].val:temp;
    }
}

int get_succ(int t,int val){
    if(!t)  return val;
    if(val>=sbt[t].val)
        return get_succ(sbt[t].r,val);
    else{
        int temp = get_succ(sbt[t].l,val);
        return val==temp?sbt[t].val:temp;
    }
}

int main(){
    freopen("sum.in","r",stdin);
    int n,x,y,pre,succ,op,val;
    while(cin>>n){
        long long ans = 0;
        root = tol = 0;
        int sum  = 0,kind = 0;
        for(int i=0;i<n;i++){
            scanf("%d%d",&op,&val);
            if(!sum||kind==op){
                kind = op;
                insert(root,val);
                sum++;
            }
            else{
                pre = get_pre(root,val);
                succ = get_succ(root,val);
                x = val-pre;
                y = succ-val;
                sum--;
                if(!x){
                    ans = (ans+y)%mod;
                    del(root,succ);
                    continue;
                }
                if(!y){
                    ans = (ans+x)%mod;
                    del(root,pre);
                    continue;
                }
                if(x<=y){
                    ans = (ans+x)%mod;
                    del(root,pre);
                }
                else{
                    ans = (ans+y)%mod;
                    del(root,succ);
                }
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

 

poj      3481     Double Queue {Insert , DeleteMax , DeleteMin}

/*

题目:
    三种操作:
    0    The system needs to stop serving
    1 K P    Add client K to the waiting list with priority P
    2    Serve the client with the highest priority and drop him or her from the waiting list
    3    Serve the client with the lowest priority and drop him or her from the waiting list
    问出队序列

分析：
    2号操作的时候，直接搜索右子树的最右儿子的val域
    3号操作的时候，直接搜索左子树的最左儿子的val域

*/
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int X = 1e6+5;

int root,tol;

struct node{
    int l,r,s,id,val;
    void init(int _val,int _id){
        l = r = 0;
        s = 1;
        val = _val;
        id = _id;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val,int id){
    if(!t){
        t = ++tol;
        sbt[t].init(val,id);
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val,id);
    else
        insert(sbt[t].r,val,id);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)  return 0;
    sbt[t].s--;
    if(val==sbt[t].val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    else
        return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int _val;

int get_min(int t){
    while(sbt[t].l)
        t = sbt[t].l;
    _val = sbt[t].val;
    return sbt[t].id;
}

int get_max(int t){
    while(sbt[t].r)
        t = sbt[t].r;
    _val = sbt[t].val;
    return sbt[t].id;
}

int main()
{
    freopen("aum.in","r",stdin);
    int op,val,id,temp;
    root = tol = 0;
    while(scanf("%d",&op),op){
        if(op==1){
            scanf("%d%d",&id,&val);
            insert(root,val,id);
        }
        else if(op==2){
            temp = get_max(root);
            printf("%d\n",temp);
            del(root,_val);
        }
        else{
            temp = get_min(root);
            printf("%d\n",temp);
            del(root,_val);
        }
    }
    return 0;
}

 

poj      2892     Tunnel Warfare 

/*

题目：
    现有n座城堡在一直线上，除了两端之外，其余的都各自与相邻的城堡有道路，
    现在有三种操作，摧毁城堡，修复城堡，询问城堡x与他相连的城堡数目（包括
    自己）。

分析:
    SBT，每当摧毁城堡的时候插入一个节点，当询问的时候，查找比栈顶元素小的
    以及大的位置，两者相减再减一。

*/
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

const int X = 200005;
#define debug puts("here");

int n,m;
int s[X],top;
int use[X];
int root,tol;

struct node{
    int l,r,val,s;
    void init(){
        l = r = 0;
        s = 1;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else
            return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else
            return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init();
        sbt[t].val = val;
    }
    else{
        sbt[t].s++;
        if(val<sbt[t].val)
            insert(sbt[t].l,val);
        else
            insert(sbt[t].r,val);
        maintain(t,val>=sbt[t].val);
    }
}

int del(int &t,int val){
    if(!t)
        return 0;
    sbt[t].s--;
    if(val==sbt[t].val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    else
        return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int less_than(int t,int val){
    if(!t)
        return 0;
    if(val<sbt[t].val)
        return less_than(sbt[t].l,val);
    else
        return max(sbt[t].val,less_than(sbt[t].r,val));
}

int greater_than(int t,int val){
    if(!t)
        return n+1;
    if(val>sbt[t].val)
        return greater_than(sbt[t].r,val);
    else
        return min(sbt[t].val,greater_than(sbt[t].l,val));
}

int main(){
    freopen("sum.in","r",stdin);
    char str[5];
    int x;
    while(cin>>n>>m){
        for(int i=0;i<=X;i++)
            sbt[i].init();
        memset(use,0,sizeof(use));
        top = 0;
        root = 0;
        tol = 0;
        while(m--){
            scanf("%s",str);
            if(str[0]=='D'){
                scanf("%d",&x);
                use[x]++;
                s[++top] = x;
                insert(root,x);
            }
            else if(str[0]=='R'){
                if(top>0){
                    del(root,s[top]);
                    use[s[top--]]--;
                }
            }
            else{
                scanf("%d",&x);
                if(use[x])
                    puts("0");
                else{
                    int r = greater_than(root,x);
                    int l = less_than(root,x);
                    //cout<<r<<" "<<l<<" ";
                    printf("%d\n",r-l-1);
                }
            }
        }
    }
    return 0;
}

 

解决约瑟夫环问题：

ural      1521      War Games 2   

/*

ural 1521
http://ac.jobdu.com/problem.php?pid=1188
题目1188：约瑟夫环
题目描述：
N个人围成一圈顺序编号，从1号开始按1、2、3......顺序报数，报p者退出圈外，其余的人再从1、2、3开始报数，报p的人再退出圈外，以此类推。
请按退出顺序输出每个退出人的原序号。

输入：
包括一个整数N(1<=N<=3000)及一个整数p。

输出：
测试数据可能有多组，对于每一组数据，
按退出顺序输出每个退出人的原序号。

样例输入：
7 3
样例输出：
3 6 2 7 5 1 4

*/

/*

分析：
    先把所有人插入到SBT中，然后出去的时候，把他从SBT中删除，而找到要删除的
    元素为pos = (pre+k-1)%n+1，n每出去一个人减一，而pre从0开始，若已经有人
    出队，则置为上一个人出队的位置减一，然后就是找到第pos小即可

*/

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int X = 100005;

int root,tol,n,m;

struct node{
    int val,l,r,s;
    void init(int _val){
        l = r = 0;
        s = 1;
        val = _val;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init(val);
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)  return 0;
    sbt[t].s--;
    if(val==sbt[t].val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    else
        return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int find_k_min(int &t,int k){   //找到第k小
    if(k<=sbt[sbt[t].l].s)
        return find_k_min(sbt[t].l,k);
    else if(k>sbt[sbt[t].l].s+1)
        return find_k_min(sbt[t].r,k-sbt[sbt[t].l].s-1);
    else
        return sbt[t].val;
}

int main()
{
    freopen("sum.in","r",stdin);
    freopen("sum.out","w",stdout);
    while(cin>>n>>m){
        int pos = 0,temp,val;
        root = tol = 0;
        for(int i=1;i<=n;i++)
            insert(root,i);
        while(n){
            temp = (pos+m-1)%n+1;
            pos = temp-1;
            val = find_k_min(root,temp);
            del(root,val);
            printf("%d",val);
            if(n>1)
                putchar(' ');
            n--;
        }
        puts("");
    }
    return 0;
}

 

poj       3750        小孩报数问题（跟上面一题基本一样）

/*

题目:
    约瑟夫环

*/
#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

const int X = 100;

char str[X][20];
int n;
int root,tol;

struct node{
    int l,r,val,s;
    void init(){
        l = r = 0;
        s = 1;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else
            return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].r].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else
            return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init();
        sbt[t].val = val;
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)
        return 0;
    sbt[t].s--;
    if(sbt[t].val==val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    else
        return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int find_k_min(int &t,int k){   //找到第k小
    if(k<=sbt[sbt[t].l].s)
        return find_k_min(sbt[t].l,k);
    else if(k>sbt[sbt[t].l].s+1)
        return find_k_min(sbt[t].r,k-sbt[sbt[t].l].s-1);
    else
        return sbt[t].val;
}

int main(){
    freopen("sum.in","r",stdin);
    int x,y;
    while(cin>>n){
        tol = root = 0;
        for(int i=1;i<=n;i++){
            scanf("%s",str[i]);
            insert(root,i);
        }
        scanf("%d,%d",&x,&y);
        x--;
        while(n){
            int temp = (x+y-1)%n+1;
            x = temp-1;
            temp = find_k_min(root,temp);
            printf("%s\n",str[temp]);
            del(root,temp);
            n--;
        }
    }
    return 0;
}

 

poj        3517        And Then There Was One

/*

题目：
    约瑟夫环问题，问最后只剩下的元素

*/
#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;

const int X = 100005;
#define debug puts("here");

int tol,root;

struct node{
    int l,r,val,s;
    void init(int _val){
        l = r = 0;
        s = 1;
        val = _val;
    }
}sbt[X];

void left_rotate(int &t){
    int k = sbt[t].r;
    sbt[t].r = sbt[k].l;
    sbt[k].l = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void right_rotate(int &t){
    int k = sbt[t].l;
    sbt[t].l = sbt[k].r;
    sbt[k].r = t;
    sbt[k].s = sbt[t].s;
    sbt[t].s = sbt[sbt[t].l].s+sbt[sbt[t].r].s+1;
    t = k;
}

void maintain(int &t,bool ok){
    if(!ok){
        if(sbt[sbt[sbt[t].l].l].s>sbt[sbt[t].r].s)
            right_rotate(t);
        else if(sbt[sbt[sbt[t].l].r].s>sbt[sbt[t].r].s){
            left_rotate(sbt[t].l);
            right_rotate(t);
        }
        else return;
    }
    else{
        if(sbt[sbt[sbt[t].r].r].s>sbt[sbt[t].l].s)
            left_rotate(t);
        else if(sbt[sbt[sbt[t].r].l].s>sbt[sbt[t].l].s){
            right_rotate(sbt[t].r);
            left_rotate(t);
        }
        else return;
    }
    maintain(sbt[t].l,0);
    maintain(sbt[t].r,1);
    maintain(t,0);
    maintain(t,1);
}

void insert(int &t,int val){
    if(!t){
        t = ++tol;
        sbt[t].init(val);
        return;
    }
    sbt[t].s++;
    if(val<sbt[t].val)
        insert(sbt[t].l,val);
    else
        insert(sbt[t].r,val);
    maintain(t,val>=sbt[t].val);
}

int del(int &t,int val){
    if(!t)  return 0;
    sbt[t].s--;
    if(sbt[t].val==val||(val<sbt[t].val&&!sbt[t].l)||(val>sbt[t].val&&!sbt[t].r)){
        if(sbt[t].l&&sbt[t].r){
            int pos = del(sbt[t].l,val+1);
            sbt[t].val = sbt[pos].val;
            return pos;
        }
        else{
            int pos = t;
            t = sbt[t].l+sbt[t].r;
            return pos;
        }
    }
    else
        return del(val<sbt[t].val?sbt[t].l:sbt[t].r,val);
}

int find_k_min(int &t,int k){
    if(k<=sbt[sbt[t].l].s)
        return find_k_min(sbt[t].l,k);
    else if(k>sbt[sbt[t].l].s+1)
        return find_k_min(sbt[t].r,k-sbt[sbt[t].l].s-1);
    return sbt[t].val;
}

int find_k_max(int &t,int k){
    if(k<sbt[sbt[t].r].s)
        return find_k_max(sbt[t].r,k);
    else if(k>sbt[sbt[t].r].s+1)
        return find_k_max(sbt[t].l,k-sbt[sbt[t].r].s-1);
    return sbt[t].val;
}

int get_pre(int &t,int val){
    if(!t)  return 0;
    if(val<sbt[t].val)
        return get_pre(sbt[t].l,val);
    else
        return max(sbt[t].val,get_pre(sbt[t].r,val));
}

int get_next(int &t,int val){
    if(!t)  return 0;
    if(val>sbt[t].val)
        return get_next(sbt[t].r,val);
    else
        return min(sbt[t].val,get_next(sbt[t].l,val));
}

int get_rank(int &t,int val){
    if(val<sbt[t].val)
        return get_rank(sbt[t].l,val);
    else if(val>sbt[t].val)
        return get_rank(sbt[t].r,val)+sbt[sbt[t].l].s+1;
    else
        return sbt[sbt[t].l].s+1;
}

int main(){
    freopen("sum.in","r",stdin);
    int n,k,s;
    while(cin>>n>>k>>s,n||k||s){
        if(n==1){
            puts("1");
            continue;
        }
        root = tol = 0;
        for(int i=1;i<=n;i++)
            insert(root,i);
        int pos = s+n-k;
        while(n){
            int temp = (pos+k-1)%n+1;
            pos = temp-1;
            temp = find_k_min(root,temp);
            del(root,temp);
            if(n==2){
                printf("%d\n",find_k_min(root,1));
                break;
            }
            n--;
        }
    }
    return 0;
}