bzoj 3110[Zjoi2013]K大数查询 - 整体二分

3110: [Zjoi2013]K大数查询

Time Limit: 20 Sec  Memory Limit: 512 MB

Description

有N个位置，M个操作。操作有两种，每次操作如果是1 a b c的形式表示在第a个位置到第b个位置，每个位置加入一个数c
如果是2 a b c形式，表示询问从第a个位置到第b个位置，第C大的数是多少。

Input

第一行N，M
接下来M行，每行形如1 a b c或2 a b c

Output

输出每个询问的结果

Sample Input

2 5
1 1 2 1
1 1 2 2
2 1 1 2
2 1 1 1
2 1 2 3

Sample Output

1
2
1

HINT

 

【样例说明】

第一个操作 后位置 1 的数只有 1 ， 位置 2 的数也只有 1 。 第二个操作 后位置 1

的数有 1 、 2 ，位置 2 的数也有 1 、 2 。 第三次询问 位置 1 到位置 1 第 2 大的数 是

1 。 第四次询问 位置 1 到位置 1 第 1 大的数是 2 。 第五次询问 位置 1 到位置 2 第 3

大的数是 1 。‍

N,M<=50000,N,M<=50000

a<=b<=N

1操作中abs(c)<=N

2操作中c<=Maxlongint

 

这种问题树套树什么的肯定是无脑刚啊可以用整体二分来做

首先肯定要二分答案，验证 >= mid 的数的个数和 K 的大小关系 

对于一个插入操作，如果他插入的数是比 mid 大的， 那么下一步二分的(l, mid) 的区间这个插入就不会产生贡献

我们可以直接把他放入到 (mid + 1, r) 的区间中，反之同理

如何查询 > mid 的个数呢

用一个线段树维护区间 (l, r) 中> mid数的个数

如果插入的数 > mid 就把他加入到线段树中

查询的时候，如果 > mid 的个数 >= qk 

说明第 qk 个数比mid大， 加入到(mid + 1, r)的区间中

如果少，说明第K大的数在(l, mid) 的区间中， 把qk - > mid的个数

放入到(l, mid)的区间中

 

于是就完成了

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define LL long long

using namespace std;

const int MAXN = 5e4 + 10;
const int MAXM = 5e4 + 10;

int qq[MAXN];
int temp[MAXM];
LL ans[MAXN];

struct query {
    int l, r;
    int c;
    int opr;    
}  q[MAXN];

struct segment {
    LL sum;
    int lazy;
    int clear;
    void init()
    {
        sum = 0;
        lazy = 0;
    }
} seg[MAXN * 10];

inline LL read()
{
    LL x = 0, w = 1; char ch = 0;
    while(ch < '0' || ch > '9') {
        if(ch == '-') {
            w = -1;
        }
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * w;
}

int N, M;

void pushdown(int k, LL l, LL r)
{
    LL mid = (l + r) >> 1;
    if(seg[k].clear) {
        seg[k].clear = 0;
        seg[k << 1].init(), seg[k << 1 | 1].init();
        seg[k << 1].clear = seg[k << 1 | 1].clear = 1;
    }
    if(seg[k].lazy) {
        seg[k << 1].lazy += seg[k].lazy;
        seg[k << 1 | 1].lazy += seg[k].lazy;
        seg[k << 1].sum += (mid - l + 1) * seg[k].lazy;
        seg[k << 1 | 1].sum += (r - mid) * seg[k].lazy;
        seg[k].lazy = 0;
    }
}

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

LL query(int ql, int qr, int l, int r, int root)
{
    //cout<<l<<" "<<r<<endl;
    if(ql <= l && qr >= r) {
        //cout<<ql<<" "<<qr<<" "<<l<<" "<<r<<" "<<seg[root].sum<<endl;
        return seg[root].sum;
    }
    int mid = (l + r) >> 1;
    pushdown(root, l, r);
    LL s = 0;
    //cout<<mid<<" "<<ql<<" "<<qr<<endl;
    if(ql <= mid) {
        s += query(ql, qr, l, mid, root << 1);
    } 
    //cout<<mid<<" "<<ql<<" "<<qr<<endl;
    if(qr > mid) {
        //cout<<mid<<" "<<ql<<" "<<qr<<endl;
        s += query(ql, qr, mid + 1, r, root << 1 | 1);
    }
    pushup(root);
    return s;
}

void add(int ul, int ur, int l, int r, int root)
{
    if(ul <= l && ur >= r) {
        seg[root].sum += (r - l + 1);
        //cout<<ul<<" "<<ur<<" "<<l<<" "<<r<<" "<<seg[root].sum<<endl;
        seg[root].lazy++;
        return;
    }
    int mid = (l + r) >> 1;
    pushdown(root, l, r);
    if(ul <= mid) {
        add(ul, ur, l, mid, root << 1);
    }
    if(ur > mid) {
        add(ul, ur, mid + 1, r, root << 1 | 1);
    }
    pushup(root);
    return;
}

void solve(int l, int r, int a, int b)
{
    /*cout<<l<<" "<<r<<" "<<a<<" "<<b<<endl;
    for(int i = l; i <= r; i++) {
        cout<<qq[i]<<" ";
    }
    cout<<endl<<endl;*/
    int mid = (a + b) >> 1;
    if(l > r) {
        return;
    }
    if(a == b) {
        for(int i = l; i <= r; i++) {
            int t = qq[i];
            if(q[t].opr == 2) {
                ans[t] = mid;
            }
        }
        return;
    }
    int L = l, R = r;
    seg[1].init();
    seg[1].clear = 1;
    for(int i = l; i <= r; i++) {
        int t = qq[i];
        if(q[t].opr == 1) {
            if(q[t].c > mid) {
                //cout<<q[t].l<<" "<<q[t].r<<endl;
                add(q[t].l, q[t].r, 1, N, 1);
                temp[R--] = t;    
            } else {
                temp[L++] = t;
            }
        } else {
        //    cout<<q[t].l<<" "<<q[t].r<<endl;
            LL num = query(q[t].l, q[t].r, 1, N, 1);
        //    cout<<num<<endl;
            if(q[t].c > num) {
                q[t].c -= num;
                temp[L++] = t;
            } else {
                temp[R--] = t;
            }
        }
    }
    //cout<<L<<" "<<R<<endl;
    for(int i = l; i < L; i++) {
        qq[i] = temp[i];
    }
    for(int i = r; i >= L; i--) {
        qq[i] = temp[++R];
    }
    solve(l, L - 1, a, mid);
    solve(L, r, mid + 1, b);
}

void open()
{
    freopen("sequence1.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
}

int main()
{
    //open();
    N = read(), M = read();
    for(int i = 1; i <= M; i++) {
        q[i].opr = read();
        q[i].l = read(), q[i].r = read(), q[i].c = read();
        qq[i] = i;
    }
    solve(1, M, -N, N);
    for(int i = 1; i <= M; i++) {
        if(q[i].opr == 2) {
            printf("%lld\n", ans[i]);
        }
    }
    return 0;
}