HDU 5649 DZY Loves Sorting （二分 + 线段树）

题意：

给你n 个数（1~n的排列）， m 个操作， 

操作1： 将指定区间 升序排序

操作2： 将指定区间降序排列。

最后问你某一个的位置的数是多少？

思路：

神题~~~

没想到这能二分去做。。

直接二分那个数是啥。 然后模拟整个操作。

将比二分的值小的赋为0， 大的赋为1，  

然后就是模拟操作

对于升序排序， 直接看看这个区间有多少个0， 多少个1，（线段树维护0的个数即可。）

将前面赋值0 ， 后面赋值1即可。

降序同理。

只要看最后那个位置是0 还是1 还是答案即可。

这样 这个问题转换成了  二分 + 线段树区间赋值。

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

const int maxn = 100000 + 10;
int n, m, K;
int a[maxn];
struct node{

int op;
int l,r;
void read(){
scanf("%d%d%d",&op ,&l, &r);
}
}p[maxn];

int b[maxn];

struct neode{
int l,r;
int setv;
int sum;
}nod[maxn<<2];

void pushup(int o){
nod[o].sum = nod[o<<1].sum + nod[o<<1|1].sum;
}

void pushdown(int o){
if (nod[o].setv != -1){
int lson = o << 1;
int rson = o << 1 | 1;
nod[lson].setv = nod[rson].setv = nod[o].setv;
if (nod[o].setv == 0){
nod[lson].sum = nod[lson].r - nod[lson].l + 1;
nod[rson].sum = nod[rson].r - nod[rson].l + 1;
}
else {
nod[lson].sum = 0;
nod[rson].sum = 0;
}
nod[o].setv = -1;
}
}
void build(int l,int r,int o){
nod[o].l = l;
nod[o].r = r;
nod[o].setv = -1;
if (l == r){
nod[o].sum = (b[l] == 0 ? 1 : 0);
return ;
}
int m = l + r >> 1;
build(l, m, o<<1);
build(m+1, r, o<<1|1);
pushup(o);
}

void update(int L,int R,int c, int l,int r,int o){
if (L > R) return ;
if (L <= l && r <= R){
nod[o].setv = c;
if (c == 0){
nod[o].sum = r - l + 1;
}
else {
nod[o].sum = 0;
}
return;
}
pushdown(o);
int m = l + r >> 1;
if (m >= L){
update(L,R, c, l, m, o<<1);

}
if (m < R){
update(L, R, c, m+1, r, o<<1|1);

}
pushup(o);
}
int query(int pos,int l,int r,int o){
if (l == r){
if (nod[o].setv != -1) return nod[o].setv;
return nod[o].sum == 0;
}

pushdown(o);
int m = l + r >> 1;

if (m >= pos){
return query(pos, l, m ,o<<1);
}
else {
return query(pos, m+1, r, o<<1|1);
}
}

int Query(int L,int R,int l,int r,int o){

if (L <= l && r <= R){

return nod[o].sum;
}
int m = l + r >> 1;
int ans = 0;
pushdown(o);
if (m >= L){
ans += Query(L,R,l, m, o<<1);
}
if (m < R){
ans += Query(L, R, m+1, r, o<<1|1);
}
return ans;
}

int pos;
void deal(int mid){

for (int i = 1; i <= n; ++i){
if (a[i] == mid) pos = i;

if (a[i] < mid) b[i] = 0;
else if (a[i] > mid) b[i] = 1;
else b[i] = mid;
}

build(1, n, 1);

for (int i = 0; i < m; ++i){
if (p[i].op == 0){
int zero = Query(p[i].l, p[i].r, 1, n, 1);
if (pos >= p[i].l && pos <= p[i].r){
update(p[i].l, p[i].l + zero - 1, 0, 1, n, 1);
update(p[i].l + zero, p[i].l + zero, mid, 1, n, 1);
pos = p[i].l + zero;
update(p[i].l + zero + 1, p[i].r, 1, 1, n, 1);
}
else {
update(p[i].l, p[i].l + zero - 1, 0, 1, n, 1);
update(p[i].l + zero, p[i].r, 1, 1, n, 1);
}
}
else {
int zero = Query(p[i].l, p[i].r, 1, n, 1);
if (pos >= p[i].l && pos <= p[i].r){
update(p[i].r - zero + 1, p[i].r, 0, 1, n, 1);
update(p[i].r - zero , p[i].r - zero, mid, 1, n, 1);
update(p[i].l, p[i].r - zero - 1, 1, 1, n, 1);
pos = p[i].r - zero;
}
else {
update(p[i].r - zero + 1, p[i].r, 0, 1, n, 1);
update(p[i].l, p[i].r - zero, 1, 1, n, 1);
}
}
}
}

void solve(){

int l = 1, r = n;
while(l <= r){
int m = l + r >> 1;
deal(m);
if (pos == K) {
printf("%d\n", m);
return;
}
int val = query(K, 1, n, 1);

if (val == 0){
r = m -1;
}
else if (val == 1) l = m + 1;
}

}

int main(){

int T;
scanf("%d",&T);
while(T--){
scanf("%d %d",&n, &m);
for (int i = 1; i <= n; ++i){
scanf("%d", &a[i]);
}
for (int i = 0; i < m; ++i){

p[i].read();
}

scanf("%d",&K);
solve();
}
return 0;
}
/**
1
6 3
1 6 2 5 3 4
0 1 4
1 3 6
0 2 4
3

ans = 5;

**/

DZY Loves Sorting

Time Limit: 12000/6000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)

Total Submission(s): 547    Accepted Submission(s): 162


Problem Description

DZY has a sequence a[1..n].
It is a permutation of integers 1∼n.

Now he wants to perform two types of operations:

0lr:
Sort a[l..r] in
increasing order.

1lr:
Sort a[l..r] in
decreasing order.

After doing all the operations, he will tell you a position k,
and ask you the value of a[k].

 

Input

First line contains t,
denoting the number of testcases.

t testcases
follow. For each testcase:

First line contains n,m. m is
the number of operations.

Second line contains n space-separated
integers a[1],a[2],⋯,a[n],
the initial sequence. We ensure that it is a permutation of 1∼n.

Then m lines
follow. In each line there are three integers opt,l,r to
indicate an operation.

Last line contains k.

(1≤t≤50,1≤n,m≤100000,1≤k≤n,1≤l≤r≤n,opt∈{0,1}.
Sum of n in
all testcases does not exceed 150000.
Sum of m in
all testcases does not exceed 150000)

 

Output

For each testcase, output one line - the value of a[k] after
performing all m operations.

 

Sample Input

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

 

Sample Output

5

Hint
1 6 2 5 3 4 -> [1 2 5 6] 3 4 -> 1 2 [6 5 4 3] -> 1 [2 5 6] 4 3. At last $a[3]=5$.

 

Source

BestCoder Round #76 (div.1)

 

Recommend

wange2014   |   We have carefully selected several similar problems for you:  6107 6106 6105 6104 6103 

 

Statistic | Submit | Discuss | Note