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 + ;
const int inf =  << ;

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 = ; char ch = ; int op = ;
    for(; ch > '' || ch < ''; ch = getchar())
        if(ch == '-') op = -;
    for(; ch >= '' && ch <= ''; ch = getchar())
        X = (X << ) + (X << ) + ch - ;
    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 = ;
            lmax = rmax = -inf;
        }

    } s[N * ];

    int root[N], nodeCnt = ;

    #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) = ;
            return;
        }

        build(lc(p), l, mid);
        build(rc(p), mid + , 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 + , 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 + , 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 = ;

    if(r1 +  <= l2 - ) {
        now.init();
        now = query(root[mid], , n, r1 + , l2 - );
        res += now.sum;
    }

    now.init();
    now = query(root[mid], , n, l1, r1);
    res += now.rmax;

    now.init();
    now = query(root[mid], , n, l2, r2);
    res += now.lmax;

    return res >= ;
}

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

int main() {
    read(n);
    for(int i = ; i <= n; i++) {
        read(a[i]);
        b[i].val = a[i], b[i].id = i;
    }

    s[].lmax = s[].rmax = -inf;
    build(root[], , n);
    sort(b + , b +  + n, cmp);
    for(int i = ; i <= n; i++)
        modify(root[i], , n, b[i - ].id, -, root[i - ]);

    read(qn);
    for(int ans = , q[]; qn--; ) {
        for(int i = ; i < ; i++) {
            read(q[i]);
            q[i] = (q[i] + ans) % n + ;
        }
        sort(q, q + );
        ans = solve(q[], q[], q[], q[]);
        printf("%d\n", ans);
    }    

    return ;
}