ZOJ 4053 Couleur

4053

思路：

主席树

先分别求前缀和后缀的逆序数

然后要求某一段的逆序数，就可以根据前缀或着后缀根据容斥求出答案，

这样需要枚举这一段中的数，求之前或者之后有多少个比他大或比他小的数，

这个可以通过用主席数维护权值线段树来做

然后每次枚举断开后小的那段区间，这样最多需要枚举n*log(n)次

复杂度：n*log(n)*log(n)

代码：

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize(4)
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pi acos(-1.0)
#define LL long long
//#define mp make_pair
#define pb push_back
#define ls rt<<1, l, m
#define rs rt<<1|1, m+1, r
#define ULL unsigned LL
#define pll pair<LL, LL>
#define pii pair<int, int>
#define piii pair<pii, int>
#define mem(a, b) memset(a, b, sizeof(a))
#define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define fopen freopen("in.txt", "r", stdin);freopen("out.txt", "w", stout);
//head

const int N = 1e5 + , M = 2e6 + ;
int a[N], p[N], root[N], bit[N], lson[M], rson[M], value[M], tot = , n;
LL tmp[N], ans[N], pre[N], suf[N];
multiset<LL> s;
void build(int &x, int l, int r) {
    x = ++tot;
    if(l == r) {
        value[x] = ;
        return ;
    }
    int m = l+r >> ;
    build(lson[x], l, m);
    build(rson[x], m+, r);
    value[x] = value[lson[x]] + value[rson[x]];
}
void update(int old, int &x, int p, int v, int l, int r) {
    x = ++tot;
    lson[x] = lson[old], rson[x] = rson[old], value[x] = value[old] + v;
    if(l == r) return ;
    int m = l+r >> ;
    if(p <= m) update(lson[x], lson[x], p, v, l, m);
    else update(rson[x], rson[x], p, v, m+, r);
}
int query(int L, int R, int x, int l, int r) {
    if(L > R) return ;
    if(L <= l && r <= R) return value[x];
    int m = l+r >> , ans = ;
    if(L <= m) ans += query(L, R, lson[x], l, m);
    if(R > m) ans += query(L, R, rson[x], m+, r);
    return ans;
}
void add(int x, int v) {
    while(x <= n+) bit[x] += v, x += x&-x;
}
int sum(int x) {
    int ans = ;
    while(x) ans += bit[x], x -= x&-x;
    return ans;
}
int Find_pre(int pos) {
    int l = , r = pos, m = l+r >> ;
    while(l < r) {
        if(sum(pos) - sum(m-) > ) l = m + ;
        else r = m;
        m = l+r >> ;
    }
    return m;
}
int Find_nxt(int pos) {
    int l = pos, r = n, m = l+r+ >> ;
    while(l < r) {
        if(sum(m) - sum(pos-) > ) r = m - ;
        else l = m;
        m = l+r+ >> ;
    }
    return m;
}
void solve(int l, int m, int r) {
    if(l == r) return ;
    else if(l +  == r) {
        if(l == m) tmp[l] = , s.insert();
        else tmp[l-] = , s.insert();
    }
    else {
        if(l == m) {
            LL t = tmp[l-];
            t -= (query(, a[m]-, root[r], , n) - query(, a[m]-, root[l], , n));
            tmp[l] = t;
            s.insert(t);
        }
        else if(r == m) {
            LL t = tmp[l-] - (query(a[m]+, n, root[r-], , n) - query(a[m]+, n, root[l-], , n));
            tmp[l-] = t;
            s.insert(t);
        }
        else {
            LL t = tmp[l-], t1, t2;
            if(m-l+ < r-m) {
                t1 = pre[m-] - pre[l-];
                for (int i = l; i < m; i++) {
                    t1 -= query(a[i]+, n, root[l-], , n);
                }

                t2 = t - t1;
                for (int i = l; i < m; i++) {
                    t2 -= query(, a[i]-, root[r], , n) - query(, a[i]-, root[m-], , n);
                }
                t2 -= query(, a[m]-, root[r], , n) - query(, a[m]-, root[m], , n);
             }
            else {
                t2 = suf[m+] - suf[r+];
                for (int i = m+; i <= r; i++) {
                    if(r+ <= n) t2 -= query(, a[i]-, root[n], , n) - query(, a[i]-, root[r], , n);
                }

                t1 = t - t2;
                for (int i = m+; i <= r; i++) {
                    t1 -= query(a[i]+, n, root[m], , n) - query(a[i]+, n, root[l-], , n);
                }
                t1 -= query(a[m]+, n, root[m-], , n) - query(a[m]+, n, root[l-], , n);
            }
            tmp[l-] = t1;
            tmp[m] = t2;
            s.insert(t1);
            s.insert(t2);
        }
    }

}
int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &n);
        for (int i = ; i <= n; i++) scanf("%d", &a[i]);
        for (int i = ; i <= n; i++) scanf("%d", &p[i]);
        pre[] = suf[n+] = ;
        s.clear();
        tot = ;
        build(root[], , n);
        for (int i = ; i <= n; i++) update(root[i-], root[i], a[i], , , n);
        for (int i = n; i >= ; i--) {
            suf[i] = suf[i+] + query(, a[i]-, root[n], , n) - query(, a[i]-, root[i], , n);
        }
        for (int i = ; i <= n; i++) {
            pre[i] = pre[i-] + query(a[i]+, n, root[i-], , n);
        }
        for (int i = ; i <= n+; i++) bit[i] = ;
        tmp[] = suf[];
        s.insert(tmp[]);
        for (int i = ; i <= n; i++) {
            ans[i] = *s.rbegin();
            int t = ans[i]^p[i];
            int l = Find_pre(t), r = Find_nxt(t);
            s.erase(s.find(tmp[l-]));
            solve(l, t, r);
            add(t, );
        }
        for (int i = ; i <= n; i++) printf("%lld%c", ans[i], " \n"[i==n]);
    }
    return ;
}