[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);
}