AGC023E - Inversion

Description

\(n \le 2*10^5\)
给定限制序列 \(A\)
求满足 \(P_i\le A_i\) 的所有排列中
逆序对个数的和

Solution

考虑知道一个 \(A\) 序列时怎么计算排列个数
记 \(C[i]\) 表示 \(A\ge i\) 的个数
然后依次决定 \(n, n-1, \cdots 1\) 填在哪里
填 \(k\) 时有 \(C[k]\) 个可选位置, 其中 \(n-k\) 被占用
因此总排列个数为 \(\prod_{k=1}^n C[k]-(n-k)\)
不难证明无解时该式返回0

用期望线性性去统计答案
考虑 \(i < j, P_i>P_j\)
当 \(A_i\le A_j\) 时, 可知 \(P_j\le A_i\), 把 \(A_j\) 改为 \(A_i\), 此时的所有排列中有一半是满足逆序对的
当 \(A_i\gt A_j\) 时, 转为统计 \(P_i<P_j\) 的方案数, 用总的去减这个就好了

注意到修改时把 \((A_j, A_i]\) 的 \(C\) 都减了一, 定义这个是 \(C'\)
按权值从大到小枚举 \(A_j\)
我们要求的是 \(suff[A_i+1] * C'[A_j+1..A_i] * pref[A_j] * sign(j<i)\)
按标号维护线段树, 第一项维护在线段树里, 第二项通过打标记维护

Code

#include <bits/stdc++.h>
using namespace std;
#define ri rd<int>
#define rep(i, a, b) for (int i = (a), _ = (b); i <= _; ++i)
#define per(i, a, b) for (int i = (a), _ = (b); i >= _; --i)
#define For(i, a, b) for (int i = (a), _ = (b); i < _; ++i)
const int maxN = 2e5 + 7;
typedef long long LL;
const LL O = 1e9 + 7;

template<class T> T rd() {
    bool f = 1; char c = getchar(); for (; !isdigit(c); c = getchar()) if (c == '-') f = 0;
    T x = 0; for (; isdigit(c); c = getchar()) x = x * 10 + c - '0'; return f ? x : -x;
}

int n;
struct Node {
    int v, i;
    inline bool operator < (const Node &y) const {
        return v > y.v;
    }
}a[maxN];
LL c[maxN], d[maxN];
LL C[maxN], sufC[maxN];

namespace Seg {
    const int maxN = ::maxN << 1;
    struct Node;
    typedef Node* node;
    struct Node {
        node lc, rc;
        int l, mid, r;
        int sz;
        LL sum, tag;
        bool havtag;
        Node(int _sz = 0, LL _sum = 0) : sz(_sz), sum(_sum) { havtag = false; }

        Node operator + (const Node &v) const {
            return Node(sz + v.sz, (sum + v.sum) % O);
        }

        void totag(LL d) {
            (sum *= d) %= O;
            if (!havtag) havtag = true, tag = 1;
            (tag *= d) %= O;
        }

        void pushdown() {
            if (havtag) {
                lc->totag(tag);
                rc->totag(tag);
                havtag = false;
            }
        }
    }*rt, pool[maxN], *tpool = pool;

    void build(node &x, int l, int r) {
        x = tpool++;
        x->l = l, x->r = r, x->mid = (l + r) >> 1;
        if (l == r) return;
        build(x->lc, l, x->mid);
        build(x->rc, x->mid+1, r);
    }

    void init() {
        build(rt, 1, n);
    }

    void ins(node x, int to, LL d) {
        x->sz++;
        (x->sum += d) %= O;
        if (x->l == x->r) return;
        x->pushdown();
        if (to <= x->mid) ins(x->lc, to, d);
        else ins(x->rc, to, d);
    }

    void ins(int x, LL d) {
        ins(rt, x, d);
    }

    Node get(node x, int l, int r) {
        if (l <= x->l && x->r <= r) return *x;
        x->pushdown();
        if (r <= x->mid) return get(x->lc, l, r);
        if (x->mid < l) return get(x->rc, l, r);
        return get(x->lc, l, x->mid) + get(x->rc, x->mid+1, r);
    }

    Node get(int l, int r) {
        if (l > r) return Node();
        return get(rt, l, r);
    }
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("a.in", "r", stdin);
#endif

    n = ri();
    rep (i, 1, n) {
        c[a[i].v = ri()]++;
        a[i].i = i;
    }

    per (i, n, 1) c[i] += c[i+1];
    rep (i, 1, n) {
        c[i] = c[i] - (n-i);
        d[i] = c[i] - 1;
    }
    sufC[n] = 1; per (i, n-1, 0) sufC[i] = sufC[i+1] * c[i+1] % O;
    C[0] = 1; rep (i, 1, n) C[i] = C[i-1] * c[i] % O;

    Seg::init();
    sort(a+1, a+n+1);
    LL ans = 0, cnt = 0;
    for (int v = n, i = 1; v; --v) {
        LL res = 0;
        for (; i <= n && a[i].v == v; ++i) {
            Seg::Node tp = Seg::get(1, a[i].i-1);
            res -= tp.sum;
            cnt += tp.sz;
            tp = Seg::get(a[i].i+1, n);
            res += tp.sum;
            Seg::ins(a[i].i, sufC[v]);
        }
        ans += res % O * C[v] % O;
        Seg::rt->totag(d[v]);
    }
    ans = ans % O * (O+1) / 2 % O;
    ans += cnt % O * C[n] % O;
    printf("%lld\n", (ans % O + O) % O);

    return 0;
}