洛谷P2824 排序

题意

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

这个难题是这样子的：给出一个 1 到 n 的排列，现在对这个排列序列进行 m 次局部排序，排序分为两种：

• 0 l r 表示将区间 [l,r] 的数字升序排序

• 1 l r 表示将区间 [l,r] 的数字降序排序

注意，这里是对下标在区间 [l,r] 内的数排序。

最后询问第 q 位置上的数字。

思路

这道题有在线做法和离线做法，这里介绍一种离线做法：

二分搜索q位置上的数字，对于每个待确定的答案（以下称为mid），模拟一遍排序。

每次模拟”排序“之前将这个排列变成01串（大于等于mid即为1 小于mid即为0）之后，就能得到一个新的数组，我们无法知道0和1具体对应哪个数字，但有一点是很关键的："0"<"1"，我们可以通过对模拟结束后q位置上的数字是0或1来得知q位置上的数字和mid的大小关系（有一种猜数字游戏的感觉，对吧？）。

然后就是模拟”排序“的过程了，这里我们掏出线段树！显然对01串上的某区间进行一次排序后该区间会分为两段：一段只有1，一段只有0；因此我们可以先查询该区间和（即1的数量），然后根据操作来划分区间并修改。

代码

#include <iostream>
#define MAXN 100005
using namespace std;
int n, m, a[MAXN], d[MAXN << 2], lazyB[MAXN << 2];
int ansL, ansR, x[MAXN], y[MAXN], op[MAXN], q, ans;

inline int cmp(int x, int y) {
    if (x >= y)
        return 1;
    else
        return 0;
}

int getSum(int p) {
    return d[p * 2] + d[p * 2 + 1];
}

void init(int l, int r, int p, int stand) {        //standard 标准（比这个数大就是1）
    lazyB[p] = 0;
    if (l == r) {
        d[p] = cmp(a[l], stand);
        //cout << d[p] << " ";
        return;
    }
    int mid = l + ((r - l) >> 1);
    init(l, mid, p * 2, stand), init(mid + 1, r, p * 2 + 1, stand);
    d[p] = getSum(p);
}

void f(int p, int len, int tag) {
    if (tag == 0)
        return;
    if (tag == 1) {
        d[p] = len;
    } else {
        d[p] = 0;
    }
    lazyB[p] = tag;
}

void update(int l, int r, int xl, int xr, int p, int mode) {        //mode = -1 时全0 mode = 1时全1
    if (l >= xl && xr >= r) {
        f(p, r + 1 - l, mode);
        return;
    }
    if (xl > r || xr < l)        //不加这句话喜提RE（当一个区间内全是1的时候可能会搞到外面去）
        return;
    int mid = l + ((r - l) >> 1);
    f(p * 2, mid + 1 - l, lazyB[p]), f(p * 2 + 1, r - mid, lazyB[p]);
    lazyB[p] = 0;
    if (xl <= mid)
        update(l, mid, xl, xr, p * 2, mode);
    if (xr > mid)
        update(mid + 1, r, xl, xr, p * 2 + 1, mode);
    d[p] = getSum(p);
}

int find(int l, int r, int xl, int xr, int p) {
    if (l >= xl && xr >= r) {
        return d[p];
    }
    int mid = l + ((r - l) >> 1);
    f(p * 2, mid + 1 - l, lazyB[p]), f(p * 2 + 1, r - mid, lazyB[p]);
    lazyB[p] = 0;
    int sum = 0;
    if (xl <= mid)
        sum += find(l, mid, xl, xr, p * 2);
    if (xr > mid)
        sum += find(mid + 1, r, xl, xr, p * 2 + 1);
    return sum;
}

int main() {

    cin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }

    for (int i = 1; i <= m; ++i) {
        cin >> op[i] >> x[i] >> y[i];
    }
    cin >> q;

    ansL = 1, ansR = n;        //先确定l和r
    while (ansL <= ansR) {
        int mid = ansL + ((ansR - ansL) >> 1);
        init(1, n, 1, mid);
        for (int i = 1; i <= m; ++i) {            //接下来维护这个01线段树。
            int cnt = find(1, n, x[i], y[i], 1);
            if (op[i] == 0) {                    //[x,y-cnt]全0,[y-cnt+1,y[i]]全1
                update(1, n, x[i], y[i] - cnt, 1, -1);
                update(1, n, y[i] - cnt + 1, y[i], 1, 1);
            } else {                            //[x,x+cnt-1]全1,[x+cnt,y[i]]全0
                update(1, n, x[i], x[i] + cnt - 1, 1, 1);
                update(1, n, x[i] + cnt, y[i], 1, -1);
            }
        }
        int u = find(1, n, q, q, 1);
        if (u == 1) {
            ans = mid;
            ansL = mid + 1;
        } else {
            ansR = mid - 1;
        }
        //cout << u << " " <<  ansL << " " << ansR << '\n';
    }
    cout << ans;

    return 0;
}