Codeforces Round #285 (Div. 1) B - Misha and Permutations Summation 康拓展开+平衡树

思路：很裸的康拓展开。。 我的平衡树居然跑的比树状数组+二分还慢。。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define PII pair<int, int>
#define y1 skldjfskldjg
#define y2 skldfjsklejg
using namespace std;

const int N = 2e5 + ;
const int M = 1e7 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = ;

int n, a[N], b[N], c1[N], c2[N];

struct node {
    node* ch[];
    int key, fix, sz, cnt;
    void update() {
        sz = ch[]->sz + ch[]->sz + cnt;
    }
};

typedef node* P_node;

struct Treap {
    node base[N], nil;
    P_node root, null, len;

    Treap() {
        root = null = &nil;
        null->key = null->fix = 1e9;
        null->sz = null->cnt = ;
        null->ch[] = null->ch[] = null;
        len = base;
    }

    P_node newnode(int tkey) {
        len->key = tkey;
        len->fix = rand();
        len->ch[] = len->ch[] = null;
        len->sz = len->cnt = ;
        return len++;
    }

    void rot(P_node &p, int d) {
        P_node k = p->ch[d ^ ];
        p->ch[d ^ ] = k->ch[d];
        k->ch[d] = p;
        p->update();
        k->update();
        p = k;
    }

    void _Insert(P_node &p, int tkey) {
        if(p == null) {
            p = newnode(tkey);
        } else if(p->key == tkey) {
            p->cnt++;
        } else {
            int d = tkey > p->key;
            _Insert(p->ch[d], tkey);
            if(p->ch[d]->fix > p->fix) {
                rot(p, d ^ );
            }
        }
        p->update();
    }

    void _Delete(P_node &p, int tkey) {
        if(p == null) return;
        if(p->key == tkey) {
            if(p->cnt > ) p->cnt--;
            else if(p->ch[] == null) p = p->ch[];
            else if(p->ch[] == null) p = p->ch[];
            else {
                int d = p->ch[]->fix > p->ch[]->fix;
                rot(p, d);
                _Delete(p->ch[d], tkey);
            }
        } else {
            _Delete(p->ch[tkey > p->key], tkey);
        }
        p->update();
    }

    int _Kth(P_node p, int k) {
        if(p == null || k <  || k > p->sz) return ;
        if(k < p->ch[]->sz + ) return _Kth(p->ch[], k);
        if(k > p->ch[]->sz + p->cnt) return _Kth(p->ch[], k - p->ch[]->sz - p->cnt);
        return p->key;
    }

    int _Rank(P_node p, int tkey, int res) {
        if(p == null) return -;
        if(p->key == tkey) return p->ch[]->sz + res + ;
        if(tkey < p->key) return _Rank(p->ch[], tkey, res);
        return _Rank(p->ch[], tkey, res + p->ch[]->sz + p->cnt);
    }

    int _Pred(P_node p, int tkey){
        if(p == null) return -1e9;
        if(tkey <= p->key) return _Pred(p->ch[], tkey);
        return max(p->key, _Pred(p->ch[], tkey));
    }

    int _Succ(P_node p, int tkey){
        if(p == null) return 1e9;
        if(tkey >= p->key) return _Succ(p->ch[], tkey);
        return min(p->key, _Succ(p->ch[], tkey));
    }

    void Insert(int tkey){ _Insert(root,tkey); }
    void Delete(int tkey){ _Delete(root,tkey); }
    int Kth(int k){ return _Kth(root,k); }
    int Rank(int tkey){ return _Rank(root,tkey,); }
    int Pred(int tkey){ return _Pred(root,tkey); }
    int Succ(int tkey){ return _Succ(root,tkey); }
}tp;

void getOrder(int *a, int *c, int n) {
    tp.len = tp.base;
    for(int i = ; i < n; i++) tp.Insert(i);
    for(int i = ; i < n; i++) {
        c[n - i - ] = tp.Rank(a[i]) - ;
        tp.Delete(a[i]);
    }
}

void getPerm(int *c, int n) {
    tp.len = tp.base;
    for(int i = ; i < n; i++) tp.Insert(i);
    for(int i = n - ; i >= ; i--) {
        int val = tp.Kth(c[i] + );
        tp.Delete(val);
        printf("%d ", val);
    }
    puts("");
}
int main() {
    scanf("%d", &n);
    for(int i = ; i < n; i++) scanf("%d", &a[i]);
    for(int i = ; i < n; i++) scanf("%d", &b[i]);
    getOrder(a, c1, n);
    getOrder(b, c2, n);

    for(int i = ; i < n; i++) {
        c1[i] += c2[i];
        int cnt = c1[i] / (i + );
        c1[i] -= cnt * (i + );
        c1[i + ] += cnt;
    }

    c1[n - ] %= n;
    getPerm(c1, n);
    return ;
}

/*
*/