Luogu 3521 [POI2011]ROT-Tree Rotations

BZOJ 2212

从下到上线段树合并。

考虑到每一个子树内部产生的贡献不可能通过换儿子消除，所以一次更换只要看看把哪个儿子放在左边产生的逆序对数少就可以了。

逆序对数可以在线段树合并的时候顺便算出来。

由于只有叶子结点有权值 + 二叉树的特性，大大方便了这道题的代码和细节处理。

注意点数总共要开到$2 * n$。

时间复杂度$O(nlogn)$。

Code：

#include <cstdio>
#include <cstring>
using namespace std;
typedef long long ll;

const int N = 4e5 + ;

int m, n = , rt = ;
ll ans = 0LL;

struct Node {
    int lc, rc, w;
} a[N];

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 ll min(ll x, ll y) {
    return x > y ? y : x;
}

void build(int &now) {
    now = ++n;
    read(a[now].w);
    if(a[now].w) return;
    build(a[now].lc), build(a[now].rc);
}

namespace SegT {
    struct Node {
        int lc, rc;
        ll siz;
    } s[N * ];

    int sta[N * ], top = , root[N], nodeCnt = ;
    ll res1, res2;

    inline void push(int now) {
        sta[++top] = now;
    }

    inline int newNode() {
        if(top) return sta[top--];
        else return ++nodeCnt;
    }

    #define lc(p) s[p].lc
    #define rc(p) s[p].rc
    #define siz(p) s[p].siz
    #define mid ((l + r) >> 1)

    inline void up(int p) {
        if(!p) return;
        siz(p) = siz(lc(p)) + siz(rc(p));
    }

    void ins(int &p, int l, int r, int x) {
        if(!p) p = newNode();
        ++siz(p);
        if(l == r) return;

        if(x <= mid) ins(lc(p), l, mid, x);
        else ins(rc(p), mid + , r, x);
    }

    int merge(int u, int v, int l, int r) {
        if(!u || !v) return u + v;

        res1 += siz(rc(u)) * siz(lc(v));
        res2 += siz(rc(v)) * siz(lc(u));    

        int p = newNode();
        if(l == r) siz(p) = siz(u) + siz(v);
        else {
            lc(p) = merge(lc(u), lc(v), l, mid);
            rc(p) = merge(rc(u), rc(v), mid + , r);
            up(p);
        }
        push(u), push(v);
        return p;
    }

    void print(int p, int l, int r) {
        if(l == r) {
            printf("%lld", siz(p));
            return;
        }

        print(lc(p), l, mid), print(rc(p), mid + , r);
    }

    inline void deb(int x) {
        print(root[x], , m);
    }

    #undef lc
    #undef rc
    #undef mid
    #undef siz

} using namespace SegT;

void solve(int now) {
    if(a[now].w) return;
    solve(a[now].lc), solve(a[now].rc);

    res1 = res2 = 0LL;
    root[now] = merge(root[a[now].lc], root[a[now].rc], , m);
    ans += min(res1, res2);
}

int main() {
    read(m);
    build(rt);

/*    for(int i = 1; i <= n; i++)
        printf("%d %d %d\n", a[i].lc, a[i].rc, a[i].w);
    printf("\n");    */

    for(int i = ; i <= n; i++)
        if(a[i].w) ins(root[i], , m, a[i].w);

/*    for(int i = 1; i <= n; i++) {
        if(!a[i].w) continue;
        deb(i);
        printf("\n");
    }     */

    solve(rt);

    printf("%lld\n", ans);
    return ;
}