BZOJ4552: [Tjoi2016&Heoi2016]排序

题目大意

给你一个$n$的排列，要求支持$m$次把$(l_i,r_i)$区间内数字升序或降序排，最后求某一个位置上的值。

简要题解

一开始维护$n$棵权值线段树，然后你需要支持split一棵线段树或者merge一棵线段树，用平衡树来维护区间就好了。

关于线段树合并的复杂度分析。split复杂度显然和求第k大是一致的，而merge操作每次遍历到两个点都会删去一个，反正每次插入$log n$个节点，你删的点数总不会超过插入的点数啊。

果然认真写然后认真思考然后肉眼查错效果要好很多，大概写完也没怎么调试，把空间开到$1e7$在食堂吃饭的时候随手交了一发然后和老高谈笑风生中AC了233.

似乎跑的挺快（Rank5~）？

还有就是，我线段树换写法了，感觉这种写法蛮好玩的，直接把merge和split写成节点类的成员函数，以前是数组党233

//write by HuZhifeng(id : ichn(eumon) or sbit) @ 2017-02-20 周一 10:52 上午
// It    attains    sublime
// a-----------n----------d
// yet performs common task.
#include <bits/stdc++.h>
using namespace std;
namespace my_header {
#define pb push_back
#define mp make_pair
#define pir pair<int, int>
#define vec vector<int>
#define pc putchar
#define clr(t) memset(t, 0, sizeof t)
#define pse(t, v) memset(t, v, sizeof t)
#define bl puts("")
#define wn(x) wr(x), bl
#define ws(x) wr(x), pc(' ')
    const int INF = 0x3f3f3f3f;
    typedef long long LL;
    typedef double DB;
    inline char gchar() {
        char ret = getchar();
        for(; (ret == '
' || ret == '
' || ret == ' ') && ret != EOF; ret = getchar());
        return ret; }
    template<class T> inline void fr(T &ret, char c = ' ', int flg = 1) {
        for(c = getchar(); (c < '0' || '9' < c) && c != '-'; c = getchar());
        if (c == '-') { flg = -1; c = getchar(); }
        for(ret = 0; '0' <= c && c <= '9'; c = getchar())
            ret = ret * 10 + c - '0';
        ret = ret * flg; }
    inline int fr() { int t; fr(t); return t; }
    template<class T> inline void fr(T&a, T&b) { fr(a), fr(b); }
    template<class T> inline void fr(T&a, T&b, T&c) { fr(a), fr(b), fr(c); }
    template<class T> inline char wr(T a, int b = 10, bool p = 1) {
        return a < 0 ? pc('-'), wr(-a, b, 0) : (a == 0 ? (p ? pc('0') : p) : 
            (wr(a/b, b, 0), pc('0' + a % b)));
    }
    template<class T> inline void wt(T a) { wn(a); }
    template<class T> inline void wt(T a, T b) { ws(a), wn(b); }
    template<class T> inline void wt(T a, T b, T c) { ws(a), ws(b), wn(c); }
    template<class T> inline void wt(T a, T b, T c, T d) { ws(a), ws(b), ws(c), wn(d); }
    template<class T> inline T gcd(T a, T b) {
        return b == 0 ? a : gcd(b, a % b); }
    template<class T> inline T fpw(T b, T i, T _m, T r = 1) {
        for(; i; i >>= 1, b = b * b % _m)
            if(i & 1) r = r * b % _m;
        return r; }
};
using namespace my_header;
 
 
const int MAXN = 1e7 + 100;
#define SN SegNode
#define lc ch[0]
#define rc ch[1]
struct SegNode {
    SegNode *ch[2];
    int s;
    void update() {
        s = (lc ? lc->s : 0) + (rc ? rc->s : 0);
    }
    int kth(int l, int r, int k) {
        if (l == r)
            return l;
        int m = (l + r) >> 1;
        int ls = lc ? lc->s : 0;
        if (k <= ls)
            return lc->kth(l, m, k);
        return rc->kth(m + 1, r, k - ls);
    }
    void insert(int, int, int);
    pair<SegNode*, SegNode*> split(int, int, int);
    SegNode* merge(int, int, SegNode*);
} node_pool[MAXN], *loc = node_pool;
SegNode* newSegNode() {
    return loc++;
}
 
pair<SegNode*, SegNode*> SegNode::split(int l, int r, int k) {
    if (k == 0)
        return make_pair((SegNode*)NULL, this);
    if (l == r || k == this->s)
        return make_pair(this, (SegNode*)NULL);
    int m = (l + r) >> 1;
    int ls = lc ? lc->s : 0;
    if (k <= ls) {
        pair<SegNode*, SegNode*> res = lc->split(l, m, k);
        SegNode* nr = newSegNode();
        nr->lc = res.first;
        nr->rc = NULL;
        nr->update();
        this->lc = res.second;
        this->update();
        return make_pair(nr, this);
    } else {
        pair<SegNode*, SegNode*> res = rc->split(m + 1, r, k - ls);
        this->rc = res.first;
        this->update();
        SegNode* nr = newSegNode();
        nr->lc = NULL;
        nr->rc = res.second;
        nr->update();
        return make_pair(this, nr);
    }
}
 
SegNode* SegNode::merge(int l, int r, SegNode* x) {
    if (l != r && x != NULL) {
        int m = (l + r) >> 1;
        if (!this->lc)
            this->lc = x->lc;
        else {
            if (x->lc)
                this->lc->merge(l, m, x->lc);
        }
        if (!this->rc)
            this->rc = x->rc;
        else {
            if (x->rc)
                this->rc->merge(m + 1, r, x->rc);
        }
        this->update();
    }
    return this;
}
 
set<pair<int, pair<int, int> > > status;
set<pair<int, pair<int, int> > >::iterator tmp, tmp2;
pair<int, pair<int, int> > rec;
SegNode* root[MAXN];
 
void SegNode::insert(int l, int r, int v) {
    if (l == r)
        s = 1;
    else {
        int m = (l + r) >> 1;
        if (v <= m) {
            if (!this->lc)
                this->lc = newSegNode();
            this->lc->insert(l, m, v);
        } else {
            if (!this->rc)
                this->rc = newSegNode();
            this->rc->insert(m + 1, r, v);
        }
        this->update();
    }
}
 
int n, m;
// 沉下心来 细节是魔鬼 通过思考 战胜魔鬼！
void split(int p, int tp) {
    pair<SegNode*, SegNode*> res;
    tmp = status.upper_bound(make_pair(p, make_pair(0, 0)));
    if (tmp != status.begin() && tmp->first != p)
        --tmp;
    SegNode* nr = newSegNode();
    if (tmp->second.second == 0) {
        res = root[tmp->first]->split(1, n, p - tmp->first + tp);
        root[tmp->first] = res.first;
        nr->merge(1, n, res.second);
    } else {
        res = root[tmp->first]->split(1, n, tmp->second.first - p + tmp->first - tp);
        root[tmp->first] = res.second;
        nr->merge(1, n, res.first);
    }
    rec = *tmp;
    status.erase(tmp);
    if (root[rec.first])
        status.insert(make_pair(rec.first, make_pair(root[rec.first]->s, rec.second.second)));
    if (nr) {
        rec = *status.insert(make_pair(p + tp, make_pair(nr->s, rec.second.second))).first;
        if (rec.second.first == 0) {
            status.erase(rec);
        } else {
            root[rec.first] = nr;
        }
    }
}
 
int main() {
#ifdef lol
    freopen("4552.in", "r", stdin);
    freopen("4552.out", "w", stdout);
#endif
 
    fr(n, m);
    for (int i = 1; i <= n; ++i) {
        root[i] = newSegNode();
        root[i]->insert(1, n, fr());
        status.insert(make_pair(i, make_pair(1, 0)));
    }
    while (m--) {
        int op, l, r;
        fr(op, l, r);
        //for (auto &&i : status) {
        //  wt(i.first, i.second.first, i.second.second);
        //}
        //puts("");
        split(l, 0);
        split(r, 1);
        //for (auto &&i : status) {
        //  wt(i.first, i.second.first, i.second.second);
        //}
        //puts("");
        tmp2 = tmp = status.lower_bound(make_pair(l, make_pair(0, 0)));
        for (++tmp2; tmp2 != status.end() && tmp2->first <= r; ++tmp2) {
            root[l]->merge(1, n, root[tmp2->first]);
            root[tmp2->first] = NULL;
        }
        rec = *tmp;
        status.erase(tmp, tmp2);
        status.insert(make_pair(rec.first, make_pair(root[l]->s, op)));
    }
    //for (auto &&i : status) {
    //      wt(i.first, i.second.first, i.second.second);
    //  }
    //  puts("");
    //  
    fr(m);
    tmp = status.upper_bound(make_pair(m, make_pair(0, 0)));
    if (tmp != status.begin() && tmp->first != m)
        --tmp;
    m -= tmp->first;
    wt(root[tmp->first]->kth(1, n, tmp->second.second ? tmp->second.first - m : (m + 1)));
 
    return 0;
}