可持久化普通线段树 ---- P2839 [国家集训队]middle 可持久化普通线段树 + 二分 求中位数最大值

题目链接

---

题目大意：

---

解题思路：

这个题思路很妙！！

1. 首先我们假设只有一次询问怎么做？
2. 那么我们可以二分出这个最大值$mid$,然后把大于等于$mid$设置成$1$，把小于$mid$的设置成$-1$，那么就是看看能否构造出一个区间的和大于等于$0$?
3. 因为区间两端在$[a,b]$和$[c,d]$之间移动，那么$[b+1,c-1]$之间是一定会取到的，为了中位数最大那么区间和肯定要最大！！
4. 那么就找$[a,b]$里面找最大后缀，和$[c,d]$里面最大的前缀
5. 所以，对于每一个二分的$mid$值，建一棵线段树。线段树以区间下标为下标，记录区间和，区间最大后缀，最大前缀。就可以$O(logn)$判断$mid$是否可以更优了。因为中位数一定是在序列里面的，你只要建$n$棵线段树就可以了！
6. 但是空间炸了呀！！
7. 要优化空间必须要可持久化去继承，首先我们看一下
8. 假设我们先排序，从$mid$到$mid+1$只有一个位置的数字变了就是$mid$位置上面的值变成了$-1$,那么这样子就可以动态开点去继承前面的值，每次修改加$O(logn)$空间完美解决

---

#include <bits/stdc++.h>
#define mid ((l + r) >> 1)
#define Lson rt << 1, l , mid
#define Rson rt << 1|1, mid + 1, r
#define ms(a,al) memset(a,al,sizeof(a))
#define log2(a) log(a)/log(2)
#define lowbit(x) ((-x) & x)
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define INF 0x3f3f3f3f
#define LLF 0x3f3f3f3f3f3f3f3f
#define f first
#define s second
#define endl '\n'
using namespace std;
const int N = 2e6 + 10, mod = 1e9 + 9;
const int maxn = 500010;
const long double eps = 1e-5;
const int EPS = 500 * 500;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef pair<double,double> PDD;
template<typename T> void read(T &x) {
   x = 0;char ch = getchar();ll f = 1;
   while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
   while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
   read(first);
   read(args...);
}
struct Segtree {
    int lson, rson;
    int lsum, rsum, sum;
}tr[maxn << 1];
// lsum 是从左端点起的最长的连续子段和
// rsum 是从右端点起的最长的连续子段和
//sum 是区间和
int n, cnt, root[maxn];
PII arr[maxn];

inline void pushup(int rt) {
    tr[rt].sum = tr[tr[rt].lson].sum + tr[tr[rt].rson].sum;
    tr[rt].lsum = max(tr[tr[rt].lson].lsum,tr[tr[rt].lson].sum + tr[tr[rt].rson].lsum);
    tr[rt].rsum = max(tr[tr[rt].rson].rsum,tr[tr[rt].rson].sum + tr[tr[rt].lson].rsum);
}

void build(int &rt, int l, int r) {
    rt = ++ cnt;
    if(l == r) {
        tr[rt].lsum = tr[rt].rsum = tr[rt].sum = 1;
        return;
    }
    build(tr[rt].lson,l,mid);
    build(tr[rt].rson,mid+1,r);
    pushup(rt);
}

void insert(int &now, int pre, int l, int r, int pos, int val = -1) {
    now = ++ cnt;
    tr[now] = tr[pre];
    if(l == r) {
        tr[now].lsum = tr[now].rsum = tr[now].sum = val;
        return;
    }
    if(pos <= mid) insert(tr[now].lson,tr[pre].lson,l,mid,pos); 
    else insert(tr[now].rson,tr[pre].rson,mid+1,r,pos);
    pushup(now); 
}

int quary_sum(int rt, int l, int r, int posl, int posr) {
    if(posl <= l && posr >= r) return tr[rt].sum;
    int res = 0;
    if(posl <= mid) res += quary_sum(tr[rt].lson,l,mid,posl,posr);
    if(posr > mid) res += quary_sum(tr[rt].rson,mid+1,r,posl,posr);
    return res; 
}

int quary_lsum(int rt, int l, int r, int posl, int posr) {
    if(posl <= l && posr >= r) return tr[rt].lsum;
    if(posr <= mid) return quary_lsum(tr[rt].lson,l,mid,posl,posr);
    if(posl > mid) return quary_lsum(tr[rt].rson,mid+1,r,posl,posr);
    else return max(quary_lsum(tr[rt].lson,l,mid,posl,posr),quary_sum(tr[rt].lson,l,mid,posl,mid)+quary_lsum(tr[rt].rson,mid+1,r,posl,posr));
}

int quary_rsum(int rt, int l, int r, int posl, int posr) {
    if(posl <= l && posr >= r) return tr[rt].rsum;
    if(posr <= mid) return quary_rsum(tr[rt].lson,l,mid,posl,posr);
    if(posl > mid) return quary_rsum(tr[rt].rson,mid+1,r,posl,posr);
    else return max(quary_rsum(tr[rt].rson,mid+1,r,posl,posr),quary_sum(tr[rt].rson,mid+1,r,mid+1,posr)+quary_rsum(tr[rt].lson,l,mid,posl,posr));
}

inline bool check(int rt, int a, int b, int c, int d) {
    int sum = 0;
    if(c - 1 >= b + 1) sum += quary_sum(root[rt],1,n,b+1,c-1);
    sum += quary_rsum(root[rt],1,n,a,b);
    sum += quary_lsum(root[rt],1,n,c,d);
    return (sum >= 0);
}

int main() {
    IOS;
    cin >> n;
    for(int i = 1; i <= n; ++ i) 
        cin >> arr[i].first, arr[i].second = i;
    sort(arr+1,arr+1+n);
    build(root[1],1,n);
    for(int i = 2; i <= n; ++ i)
      insert(root[i],root[i-1],1,n,arr[i-1].second);
    int q;
    cin >> q;
    int last = 0;
    while(q --) {
        int ask[4];
        for(int i = 0; i < 4; ++ i) {
            cin >> ask[i];
            ask[i] = (ask[i] + last) % n + 1;
        }
        sort(ask,ask+4);
        int l = 1, r = n;
        while(l < r) {
            int Mid = (l + r + 1) >> 1;
            if(check(Mid,ask[0],ask[1],ask[2],ask[3])) l = Mid;
            else r = Mid - 1;
        }
        cout << arr[l].first << "\n";
        last = arr[l].first;
    }
}