Luogu 2824 [HEOI2016/TJOI2016]排序

BZOJ 4552

挺妙的解法。

听说这题直接用一个桶能拿到$80 \ pts$

发现如果是一个排列的话，要对这个序列排序并不好做，但是假如是$01$序列的话，要对一个区间排序还是很简单的。

发现最后的询问其实只有一个，所以我们考虑二分这个答案（其实感觉在这题中答案的单调性并不是很明显），每一次二分得到一个$mid$，对于所有的$a_i$，我们把$a_i \geq mid$的$i$都记为$1$，把所有$a_i < mid$的值都记为$0$，然后对于每一次排序，我们只要获取这个区间的$0$和$1$的个数，然后区间覆盖一下就可以了。

区间覆盖，区间求和，岂不是线段树。

这样子所有操作完成了之后，我们只要看一看原来询问的这个位置的数是不是$1$，如果是$1$，那么说明这里的数$\geq mid$，移动左端点，否则移动右端点。

答案的单调性在这个时候就显现出来了。

这个思想值得借鉴。

时间复杂度$O(nlog^2n)$。

Code：

#include <cstdio>
#include <cstring>
using namespace std;

const int N = 1e5 + ;

int n, m, K, a[N], b[N];

struct Option {
    int type, x, y;
} q[N];  

inline void read(int &X) {
    X = ; char ch = ; int op = ;
    for(; ch > ''|| ch < ''; ch = getchar())
        if(ch == '-') op = -;
    for(; ch >= '' && ch <= ''; ch = getchar())
        X = (X << ) + (X << ) + ch - ;
    X *= op;
}

namespace SegT {
    int s[N << ], tag[N << ];

    #define lc p << 1
    #define rc p << 1 | 1
    #define mid ((l + r) >> 1)

    inline void up(int p) {
        if(p) s[p] = s[lc] + s[rc];
    }

    inline void down(int p, int l, int r) {
        if(tag[p] == -) return;
        s[lc] = tag[p] * (mid - l + ), tag[lc] = tag[p];
        s[rc] = tag[p] * (r - mid), tag[rc] = tag[p];
        tag[p] = -;
    }

    void build(int p, int l, int r) {
        tag[p] = -;
        if(l == r) {
            s[p] = b[l];
            return;
        }

        build(lc, l, mid);
        build(rc, mid + , r);
        up(p);
    }

    void modify(int p, int l, int r, int x, int y, int v) {
        if(x <= l && y >= r) {
            s[p] = (r - l + ) * v;
            tag[p] = v;
            return;
        }

        down(p, l, r);
        if(x <= mid) modify(lc, l, mid, x, y, v);
        if(y > mid) modify(rc, mid + , r, x, y, v);
        up(p);
    }

    int query(int p, int l, int r, int x, int y) {
        if(x <= l && y >= r) return s[p];

        down(p, l, r);

        int res = ;
        if(x <= mid) res += query(lc, l, mid, x, y);
        if(y > mid) res += query(rc, mid + , r, x, y);
        return res;
    }

    #undef lc
    #undef rc
    #undef mid

} using namespace SegT;

inline bool chk(int mid) {
    for(int i = ; i <= n; i++)
        if(mid <= a[i]) b[i] = ;
        else b[i] = ;

    build(, , n);
    for(int i = ; i <= m; i++) {
        int num1 = query(, , n, q[i].x, q[i].y);
        int num0 = q[i].y - q[i].x +  - num1;
        if(!q[i].type) {
            if(num0) modify(, , n, q[i].x, q[i].x + num0 - , );
            modify(, , n, q[i].x + num0, q[i].y, );
        } else {
            if(num1) modify(, , n, q[i].x, q[i].x + num1 - , );
            modify(, , n, q[i].x + num1, q[i].y, );
        }
    }

    int res = query(, , n, K, K);
    return (res > );
}

int main() {
    read(n), read(m);
    for(int i = ; i <= n; i++) read(a[i]);
    for(int i = ; i <= m; i++)
        read(q[i].type), read(q[i].x), read(q[i].y);
    read(K);

    int ln = , rn = n, mid, res;
    for(; ln <= rn; ) {
        mid = (ln + rn) / ;
        if(chk(mid)) ln = mid + , res = mid;
        else rn = mid - ;
    }

    printf("%d\n", res);
    return ;
}