树状数组求两种逆序对 || P1908 逆序对

1.对于给定的一段正整数序列，逆序对就是序列中 i < j && a[i] > a[j] 的有序对。 

首先可以运用归并排序来求(可惜我还没有完全自然地理解归并排序)，好消息是树状数组也可以求。

那么对于逆序对有两种，一种较为简单的是给定的数组是一个排列（意味着没有重复数组并且最大数字n可能较小），在这个情况下，我们可以将这个静态的问题转化为动态的问题（类似于扫描线的想法）：

我们开一个树状数组不断维护我们这个序列此时的情况，数组里维护的是在j ~ n中有多少a[i] > a[j]，那么树状数组c中按照序列从左到右将数据的值对应的位置的数加一，代表又有一个数出现，那么这个数字后面的数的和就是这个数所构成的逆序对的数量。那么其实就是单点修改和区间查询，已经差不多是树状数字板子了，但是还有一个小问题就是我们要求的是这个数到n之间的和，而树状数组只能求前缀和，我们只需要读入a[i]是作a[i] = n + 1 - a[i]即可（将1变成n），此时就相当于求后缀了。

这种静态转化成动态的思想值得思考。

代码 ：

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
//using i64 = long long;
const string YES = "Yes";
const string NO = "No";
template <typename T>
class BIT {
    public:
    vector<T> c;
    int n;
    BIT(int _n) : n(_n) {
        c.resize(n);
    }
    void modify(int x, T v) {
    while (x < n) {
        c[x] += v;
        x |= (x + 1);
        }
    }
    T query(int x) {
        T v{};
        while (x >= 0) {
            v += c[x];
            x = (x & (x + 1)) - 1;
        }
        return v;
    }
    T get(int l, int r) {
        return query(r) - query(l - 1);
    }
};
int32_t main() { 
    gogo;
    int n;
    cin >> n;
    BIT<int> c(n + 1);
    int ans = 0;
    for (int i = 1;i <= n;i ++) {
        int x;
        cin >> x;
        x = n + 1 - x;
        ans += c.query(x);
        c.modify(x, 1);
    }
    cout << ans << endl;
}

 

2.对于给定的一段正整数序列，逆序对就是序列中 i < j && a[i] > a[j] 的有序对，但是此时不保证数组是排列（意味着有重复数字并且可能数字较大）。

此时遇到的问题就是如果数字范围是1e9，那么显然数组是开不了这么大的，但是这时候其实我们需要的只是一个相对大小的关系而不需要绝对大小关系，也就是意味着我们可以通过一次离散化来对原数组变成一个范围为n的新数组，不过这时候要注意如果有重复数字并且不处理的话，那么就会WA因为答案会多算，所以我们离散化的步骤是：首先记录一下每个数字的大小以及在原数组的位置，然后进行排序，排序按照大小作为第一关键字，以出现的顺序作为第二关键字（思考），然后离散化赋值，最后求逆序对的步骤就和排列的版本一模一样了。

代码 ：

 

#include <bits/stdc++.h>
#define gogo ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
//using i64 = long long;
const string YES = "Yes";
const string NO = "No";
template <typename T>
class BIT {
    public:
    vector<T> c;
    int n;
    BIT(int _n) : n(_n) {
        c.resize(n);
    }
    void modify(int x, T v) {
    while (x < n) {
        c[x] += v;
        x |= (x + 1);
        }
    }
    T query(int x) {
        T v{};
        while (x >= 0) {
            v += c[x];
            x = (x & (x + 1)) - 1;
        }
        return v;
    }
    T get(int l, int r) {
        return query(r) - query(l - 1);
    }
};
struct Node {
    int v, idx;
};
bool cmp(Node x, Node y) {
    if (x.v == y.v) 
        return x.idx < y.idx;
    return x.v < y.v;
}
int32_t main() { 
    gogo;
    int n;
    cin >> n;
    vector<Node> a(n + 1);
    for (int i = 1;i <= n;i ++) {
        cin >> a[i].v;
        a[i].idx = i;
    }
    sort(a.begin() + 1, a.end(), cmp);
    vector<int> hs(n + 1);
    for (int i = 1;i <= n;i ++) 
        hs[a[i].idx] = n + 1 - i;
    BIT<int> c(n + 1);
    long long ans = 0;
    for (int i = 1;i <= n;i ++) {
        ans += c.query(hs[i]);
        c.modify(hs[i], 1);
    }
    cout << ans << endl;
}

 

巧妙。

https://www.luogu.com.cn/problem/P1908

拓展: https://www.luogu.com.cn/problem/P1774 , https://www.luogu.com.cn/problem/P4378