Luogu 2839 [国家集训队]middle

感觉这题挺好的。

首先对于中位数最大有一个很经典的处理方法就是二分，每次二分一个数组中的下标$mid$，然后我们把$mid$代回到原来的数组中检查，如果一个数$a_{i} \geq mid$，那么就把$s_{i}$记为$1$，否则把$s_{i}$记为$-1$，然后对$s_{i}$跑一遍前缀和，观察是否有一个区间的和不小于$0$。

读清楚题意之后发现在这题中，如果要对一个长度为偶数（记为$n$）的序列求中位数，那么答案为排好序的数组中下标为$n / 2 + 1$的元素。（下标从$1$开始），不同的中位数$s_{i}$的表示方法可能有少许不同，要具体题目具体yy。

证明应当也很简单，$+1$代表一个比当前的$mid$大的数，而$-1$表示一个比当前的$a_{mid}$小的数，那么当$a_{mid}$是中位数的条件在一个区间成立的时候，这个区间的$s_{i}$和应当恰好等于$0$。而当得到了一个区间和大于$0$的区间的时候，我们可以通过扔掉几个$1$使它变成$0$，相当于之前的条件成立。

但是这样还是太慢了。

对于本题来说，每次二分得到了一个$mid$，我们检验的时候得到的答案就一定是（区间是$a, b, c, d$）$sum(b + 1, c - 1) + lmax(c, d) + rmax(a, b)$。

其中$lmax$代表一定要选左端点的最大子段和，而$rmax$代表一定要选右端点的最大子段和。

显然可以用线段树来维护。

一个元素开一颗线段树是不可能的……

我们发现在排好序中的数组里面两个下标相差$1$的元素的值其实只有$1$个不同，这就是较小的元素在原数组中的下标，那么大多数结点的值可以继承过来。

于是可以可持久化了，变成了一个主席树。

时间复杂度$O(nlog^{2}n)$。

Code：

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

const int N = 2e4 + 5;
const int inf = 1 << 30;

int n, qn, a[N];

struct Innum {
    int val, id;
} b[N];

bool cmp(const Innum &x, const Innum &y) {
    if(x.val != y.val) return x.val < y.val;
    else return x.id < y.id;
}   

/*bool cmp(const Innum &x, const Innum &y) {
    return x.val < y.val;
}   */

inline void read(int &X) {
    X = 0; char ch = 0; int op = 1;
    for(; ch > '9' || ch < '0'; ch = getchar())
        if(ch == '-') op = -1;
    for(; ch >= '0' && ch <= '9'; ch = getchar())
        X = (X << 3) + (X << 1) + ch - 48;
    X *= op;
}

inline int max(int x, int y) {
    return x > y ? x : y;
}

inline void chkMax(int &x, int y) {
    if(y > x) x = y;
}

namespace PSegT {
    struct Node {
        int lc, rc, sum, lmax, rmax;
        
        inline void init() {
            lc = rc = sum = 0;
            lmax = rmax = -inf;
        }
        
    } s[N * 20];
    
    int root[N], nodeCnt = 0;
    
    #define lc(p) s[p].lc
    #define rc(p) s[p].rc
    #define sum(p) s[p].sum
    #define lmax(p) s[p].lmax
    #define rmax(p) s[p].rmax
    #define mid ((l + r) >> 1)
    
    inline void up(int p) {
        if(!p) return;
        sum(p) = sum(lc(p)) + sum(rc(p));
//        lmax(p) = rmax(p) = -inf;
        lmax(p) = max(lmax(lc(p)), lmax(rc(p)) + sum(lc(p)));
        rmax(p) = max(rmax(rc(p)), rmax(lc(p)) + sum(rc(p)));
    }

    void build(int &p, int l, int r) {
        p = ++nodeCnt;
        if(l == r) {
            sum(p) = lmax(p) = rmax(p) = 1;
            return;
        }
        
        build(lc(p), l, mid);
        build(rc(p), mid + 1, r);
        up(p);
    }
    
    void modify(int &p, int l, int r, int x, int v, int pre) {
        s[p = ++nodeCnt] = s[pre];
        if(l == r) {
            sum(p) = lmax(p) = rmax(p) = v;
            return;
        }
        
        if(x <= mid) modify(lc(p), l, mid, x, v, lc(pre));
        else modify(rc(p), mid + 1, r, x, v, rc(pre));
        up(p);
    }
    
    Node query(int p, int l, int r, int x, int y) {
        if(x <= l && y >= r) return s[p];
        
        Node res, ln, rn; 
        res.init(), ln.init(), rn.init();
        
        if(x <= mid) ln = query(lc(p), l, mid, x, y);
        if(y > mid) rn = query(rc(p), mid + 1, r, x, y);
        
        res.sum = ln.sum + rn.sum;
        res.lmax = max(ln.lmax, ln.sum + rn.lmax);
        res.rmax = max(rn.rmax, rn.sum + ln.rmax);
        
        return res;
    }
    
    #undef lc 
    #undef rc 
    #undef sum 
    #undef lmax 
    #undef rmax 
    #undef mid 
    
} using namespace PSegT;

inline bool chk(int mid, int l1, int r1, int l2, int r2) {
    Node now; int res = 0;
    
    if(r1 + 1 <= l2 - 1) {
        now.init();
        now = query(root[mid], 1, n, r1 + 1, l2 - 1);
        res += now.sum; 
    }
    
    now.init();
    now = query(root[mid], 1, n, l1, r1);
    res += now.rmax;
    
    now.init();
    now = query(root[mid], 1, n, l2, r2);
    res += now.lmax;
    
    return res >= 0;
}

inline int solve(int l1, int r1, int l2, int r2) {
    int ln = 1, rn = n, mid, res;
    for(; ln <= rn; ) {
        mid = (ln + rn) / 2;
        if(chk(mid, l1, r1, l2, r2)) res = mid, ln = mid + 1;
        else rn = mid - 1;
    }
    return b[res].val;
}

int main() {
    read(n);
    for(int i = 1; i <= n; i++) {
        read(a[i]);
        b[i].val = a[i], b[i].id = i;
    }
    
    s[0].lmax = s[0].rmax = -inf;
    build(root[1], 1, n);
    sort(b + 1, b + 1 + n, cmp);
    for(int i = 2; i <= n; i++)
        modify(root[i], 1, n, b[i - 1].id, -1, root[i - 1]);
    
    read(qn);
    for(int ans = 0, q[4]; qn--; ) {
        for(int i = 0; i < 4; i++) {
            read(q[i]);
            q[i] = (q[i] + ans) % n + 1;
        }
        sort(q, q + 4);
        ans = solve(q[0], q[1], q[2], q[3]);
        printf("%d\n", ans);
    }    
    
    return 0;
}