[BZOJ]4552 [TJOI2016] 排序 二分 + 线段树

4552: [Tjoi2016&Heoi2016]排序

Time Limit: 60 Sec   Memory Limit: 256 MB
Submit: 1285   Solved: 667
[ Submit][ Status][ Discuss]

Description

在2016年，佳媛姐姐喜欢上了数字序列。因而他经常研究关于序列的一些奇奇怪怪的问题，现在他在研究一个难题

，需要你来帮助他。这个难题是这样子的：给出一个1到n的全排列，现在对这个全排列序列进行m次局部排序，排

序分为两种：1:(0,l,r)表示将区间[l,r]的数字升序排序2:(1,l,r)表示将区间[l,r]的数字降序排序最后询问第q

位置上的数字。

Input

输入数据的第一行为两个整数n和m。n表示序列的长度，m表示局部排序的次数。1 <= n, m <= 10^5第二行为n个整

数，表示1到n的一个全排列。接下来输入m行，每一行有三个整数op, l, r, op为0代表升序排序，op为1代表降序

排序, l, r 表示排序的区间。最后输入一个整数q，q表示排序完之后询问的位置, 1 <= q <= n。1 <= n <= 10^5

，1 <= m <= 10^5

Output

 输出数据仅有一行，一个整数，表示按照顺序将全部的部分排序结束后第q位置上的数字。

Sample Input

6 3
1 6 2 5 3 4
0 1 4
1 3 6
0 2 4
3

Sample Output

5

HINT

Source

[ Submit][ Status][ Discuss] 

HOME Back

    这道题还是很机智的~

   做过数字范围很小， 虽然同样是区间sort， 但是要输出所有位置的值. 然而这道题只用维护一个位置的值.

   我们可以对那个值进行猜测. 我们二分这个值， 序列上原来的值比这个值小的是0， 比这个值大的是1， 那么这个序列就是一个01序列， 区间sort就是一个01赋值， 线段树维护即可. 最后我们看p(题目中问的位置)这个位置的值， 如果是0， 就说明猜小了， 为1， 就说明猜大了. 那么就可以继续二分， 二分性也显然得出.

   我们用二分做过很多简单题， 没想到在这道看似是绝对的数据结构题还能用二分去套， 这不仅说明了二分的广大， 也说明了我们对很多基础算法还不够透彻.

#include<stdio.h>
const int maxn = 100005;
int n, m, q, ans, p, midd;
int l[maxn], r[maxn], opt[maxn], a[maxn];
inline const int read(){
    register int x = 0;
    register char ch = getchar();
    while(ch < '0' || ch > '9') ch = getchar();
    while(ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
    return x;
}
struct node{
    node *ls, *rs;
    int sum, flag;
    inline void pushdown(int lf, int rg){
        if(flag == 1){
            int mid = (lf + rg) >> 1;
            ls->sum = mid - lf + 1;
            rs->sum = rg - mid;
            ls->flag = rs->flag = 1;
        }
        if(flag == 2){
            ls->sum = 0;
            rs->sum = 0;
            ls->flag = rs->flag = 2;
        }
        flag = 0;
    }
    inline void update(){
        sum = ls->sum + rs->sum;
    }
}pool[maxn * 4], *root, *tail = pool;
node *build(int lf, int rg){
    node *bt = ++tail;
    if(lf == rg) {bt->sum = 0; return bt;}
    int mid = (lf + rg) >> 1;
    bt->ls = build(lf, mid), bt->rs = build(mid + 1, rg);
    bt->update();
    return bt;
}
void rebuild(node *bt, int lf, int rg){
    if(lf == rg) {bt->sum = (a[lf] < midd); bt->flag = 0; return;}
    int mid = (lf + rg) >> 1;
    rebuild(bt->ls, lf, mid), rebuild(bt->rs, mid + 1, rg);
    bt->flag = 0, bt->update();
}
void modify(node *bt, int lf, int rg, int L, int R, int type){
    if(L <= lf && rg <= R){
        if(!type) bt->sum = rg - lf + 1, bt->flag = 1;
        else bt->sum = 0, bt->flag = 2;
        return;
    }
    int mid = (lf + rg) >> 1;
    bt->pushdown(lf, rg);
    if(L <= mid) modify(bt->ls, lf, mid, L, R, type);
    if(R > mid)  modify(bt->rs, mid + 1, rg, L, R, type);
    bt->update();
}
int query(node *bt, int lf, int rg, int L, int R){
    if(L <= lf && rg <= R) return bt->sum;
    int mid = (lf + rg) >> 1, rt = 0;
    bt->pushdown(lf, rg);
    if(L <= mid) rt += query(bt->ls, lf, mid, L, R);
    if(R > mid)  rt += query(bt->rs, mid + 1, rg, L, R);
    bt->update();
    return rt;
}
inline bool check(){
    rebuild(root, 1, n);
    for(int i = 1; i <= q; ++i){
        int zero = query(root, 1, n, l[i], r[i]);
        if(!zero || zero == r[i] - l[i] + 1) continue;
        if(!opt[i]){
            modify(root, 1, n, l[i], l[i] + zero - 1, 0);
            modify(root, 1, n, l[i] + zero, r[i], 1);
        }
        if(opt[i]){
            modify(root, 1, n, l[i], r[i] - zero, 1);
            modify(root, 1, n, r[i] - zero + 1, r[i], 0);
        }
    }
    if(!query(root, 1, n, p, p)) return true;
    return false;
}
int main(){
    n = read(), q = read();
    for(int i = 1; i <= n; ++i) a[i] = read();
    root = build(1, n);
    for(register int i = 1; i <= q; ++i) opt[i] = read(), l[i] = read(), r[i] = read();
    p = read();
    int lf = 1, rg = n;
    while(lf <= rg){
        midd = (lf + rg) >> 1;
        if(check()) ans = midd, lf = midd + 1;
        else rg = midd - 1;
    }
    printf("%d\n", ans);
}