Sherlock and Inversions CodeChef - IITI15

 

After a long series of jobless days, Sherlock and Watson frustated by the lack of new cases, decide to turn their minds toward something interesting like solving few logical problems. One of the problems they have to solve now is as follows:
Given an array A of size N and a list of Q number of queries, where each query has two numbers L and R, find for each query the number of inversions in the subarray from Lth to Rth position (both inclusive) of the array A( array has 1-based index).
For an array A two elements A[i] and A[j] form an inversion if A[i] > A[j] and i < j. Help them to solve this problem.

 

Input

• First line contains a single integer, length N of the array.
• Second line has N space separated numbers, where ith element is A[i].
• Third line has a single integer Q.
• Next Q lines have 2 space separated integers L and R of that query.

Output

• Output Q lines, ith line having a single integer, the answer to the ith query

 

Constraints

• 1 ≤ N ≤ 20000
• 0 ≤ A[i] ≤ 10^9
• 1 ≤ Q ≤ 20000
• 1 ≤ L ≤ R ≤ N

 

题解：莫队+树状数组，找每个区间的逆序对（i<j,a[i]>a[j])，用树状数组统计就行（BZOJ 3298，同一种做法)。

感受：每个元素对区间的贡献还没想明白！！！

懂了一点点，每个数的贡献是相对于原来的状态，即上一个ans而言，这里，加入一个数或者减少一个数，原来的逆序对会变化。

每次在最后添加一个数，比这个数大的数都会与其形成一个逆序对
每次在最后移除一个数，比这个数大的数都会与其形成一个逆序对
每次在最前添加一个数，比这个数小的数都会与其减少一个逆序对
每次在最前移除一个数，比这个数小的数都会与其减少一个逆序对 ------------摘自https://www.cnblogs.com/zcysky/p/6847290.html

#pragma warning(disable:4996)
#include<cmath>
#include<map>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn = 20005;

int n, m, k, unit;
int a[maxn], bit[maxn], res[maxn], b[maxn];

struct node { int l, r, id; } q[maxn];

bool cmp(const node& a, const node& b) {
    if (a.l / unit == b.l / unit) return a.r < b.r;
    return a.l < b.l;
}

void Inite() {
    unit = sqrt(n);
    memset(bit, 0, sizeof(bit));
}

int sum(int i) {
    int s = 0;
    while (i > 0) {
        s += bit[i];
        i -= i & -i;
    }
    return s;
}

void add(int i, int x) {
    while (i <= n) {
        bit[i] += x;
        i += i & -i;
    }
}

int main()
{
    while (scanf("%d", &n) != EOF) {
        Inite();

        for (int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            b[i] = a[i];
        }

        sort(a + 1, a + n + 1);
        k = unique(a + 1, a + n + 1) - (a + 1);

        map<int, int> p;
        for (int i = 1; i <= k; i++) if (!p[a[i]]) p[a[i]] = i;

        scanf("%d", &m);
        for (int i = 1; i <= m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            q[i].l = u;
            q[i].r = v;
            q[i].id = i;
        }

        sort(q + 1, q + m + 1, cmp);

        int L = q[1].l, R = L - 1;
        int ans = 0;
        for (int i = 1; i <= m; i++) {
            while (L < q[i].l) {
                ans -= sum(p[b[L]] - 1);
                add(p[b[L]], -1);
                L++;
            }
            while (L > q[i].l) {
                L--;
                ans += sum(p[b[L]] - 1);
                add(p[b[L]], 1);
            }
            while (R < q[i].r) {
                R++;
                ans += (R - L - sum(p[b[R]]));
                add(p[b[R]], 1);
            }
            while (R > q[i].r) {
                ans -= (R - L - sum(p[b[R]]) + 1);
                add(p[b[R]], -1);
                R--;
            }
            res[q[i].id] = ans;
        }
        for (int i = 1; i <= m; i++) printf("%d\n", res[i]);
    }
    return 0;
}