CF - 61E - Enemy is weak（树状数组）

传送门：CF 61E

题解：

1.

和求二重组逆序对， 类似， 这个是在其基础上求三重逆序对
因为每个数不同， 求两个数逆序对之后， 对于f[i]总共有n - f[i]个比他大的数， 左边已求为l[i]， 那么右边就是n - f[i] - l[i] = n - i -r[i] => r[i] = f[i] + r[i] - i; r[i]为右边比f[i]小的个数

2.

还有一种就是树状数组优化dp
也是需要离散化处理的

---

AC code:

#include<iostream>//code1
#include<algorithm>
#include<cstring>
using namespace std;

#define lowbit(x) (x & (-x))
#define LL long long 
#define debug 0

const int maxn(1000005);
const int mod(1e9 + 7);

int c[maxn], l[maxn], r[maxn], f[maxn];

int n;

struct node {
    int v, idx;

    bool operator < (const node& rhs) {
        return v < rhs.v;
    }
}a[maxn];


void add(int x, int v) {

    for (int i = x; i <= n; i += lowbit(i)) {
        c[i] += v;
    }

}

int getSum(int x) {
    int res = 0;

    for (int i = x; i; i -= lowbit(i)) {
        res += c[i];
    }

    return res;
}

int main() {
#if debug
    freopen("in.txt", "r", stdin);
#endif //debug



    while (cin >> n) {

        memset(c, 0, sizeof(c));

        for (int i = 1; i <= n; ++i) {
            cin >> a[i].v;
            a[i].idx = i;
        }
        sort(a + 1, a + n + 1);
        for (int i = 1; i <= n; ++i) f[a[i].idx] = i;//离散化

        for (int i = 1; i <= n; i++) {
            add(f[i], 1);
            l[i] = i - getSum(f[i]);
        }

        LL ans = 0;

        for (int i = 2; i < n; i++) {
            r[i] = l[i] + f[i] - i;
            ans += (LL)l[i] * r[i];//要(LL)
        }

        cout << ans << endl;
    }

    return 0;
}

code2:

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<map>
using namespace std;

typedef long long LL;
LL c[1000010][5], t[1000010], dp[1000010][5], a[1000010], n, f[1000010][5];

inline int lowbit(int x) { return x & (-x); }

void add(int i, int j, LL v) {
    while (i <= n) {
        c[i][j] += v;
        i += lowbit(i);
    }
}


LL getSum(int i, int j) {

    LL res = 0;

    while (i) {
        res += c[i][j];
        i -= lowbit(i);
    }

    return res;
}

int main() {

    //freopen("in.txt", "r", stdin);

    while (cin >> n) {

        map<int, int> mp;
        memset(c, 0, sizeof(c));

        for (int i = n; i > 0; --i) {
            cin >> a[i];
            t[i] = a[i];
        }

        sort(t + 1, t + 1 + n); 

        for (int i = n; i > 0; --i) mp[t[i]] = i;//离散化， 写的急了， 用结构体更好

        for (int i = 1; i <= n; ++i) {
            a[i] = mp[a[i]];
            dp[i][1] = i;
        }

        for (int i = 1; i <= n; ++i) {
            for (int j = min(3, i); j >= 2; --j) {
                f[i][j] = getSum(a[i], j - 1);
                add(a[i], j, f[i][j]);//优化dp
            }
            add(a[i], 1, 1);
        }

        for(int i = 2; i <= n; ++i)
            for (int j = 2; j <= min(i, 3); ++j) {
                dp[i][j] = dp[i - 1][j] + f[i][j];//dp
            }

        cout << dp[n][3] << endl;
    }

    return 0;
}