逆序对

逆序对是这样定义的：对于给定的一段正整数序列，逆序对就是序列中ai>aj且i<j的有序对。

说人话，就是一个数列中，一个数在你后面，去比你小，则这俩数就是一对逆序对。

怎么做呢？常规的算法是开一个结构体，记录每一个数的值和他在数组中的位置。然后按值从小到大排序。

在开一个标记数组，从1到n循环，对于排好序的数组中的元素i，将其对应的位置i.id标记成1，然后统计一下这个位置后面有多少个1，就是和这个数搭配的逆序对数。

可以这么理解，因为是越小的的数就越先去标记，所以对于一个数 i，比他小的数一定先标记过了，那么在i位置后面的标记一定满足既比他小，位置又比他靠后，不就是逆序对嘛。

而统计在他后面的标记有多少个，就可以用树状数组实现，单点修改，后缀查询。不过习惯是查询前缀，那只要改成从n到1循环就行了（当然从大到小排序也可以）。

不过这还没完，因为要考虑数字相同的情况。

比如1 1 1 1 1，逆序对数是0，但是我们排序的时候没有定义值相同的时候怎么排，是未定义行为，结果就不知道是啥了。

所以要考虑的是，值相同时，是位置靠前的排在前面，还是位置靠后的排在前面。

可以试验一下

若是值靠前的排在前面，那么上述排序结果是1 2 3 4 5，然后从n到1循环。先是a[5]，就vis[5] = 1，统计一下后面，是0；然后a[4]，则vis[4] = 1,统计后面被标记的，发现是1；a[3],vis[3] = 1,ans += 2……这么循环下去，答案就是1 + 2 + 3 + 4= 10,很显然错了。

再试一下位置靠后的排在前面，那么排序结果5 4 3 2 1，从5开始，vis[1] = 1,ans + 0;a[2], vis[2] = 1,ans += 0;a[3], vis[3] = 1,ans += 0……这样下去答案一直就是0了，对了。

所以这么做的话，就应该在值相同的情况下，位置靠后的排在前面。但这却不绝对，只是因为这种写法，若是从大到小循环就不一定了，感兴趣的可以自己试验一下。

给出一种写法

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
#define rep(i ,a, n) for(int i = a; i <= n; ++i)
#define per(i, n, a) for(int i = n; i >= a; --i)
typedef long long ll;
const int maxn = 4e4 + 5;
struct Node
{
    int num, id;
    bool operator < (const Node& other)const
    {
        return num < other.num || (num == other.num && id < other.id);
    }
}a[maxn];
int c[maxn], n;
int ans = 0;
int lowbit(int x)
{
    return x & -x;
}
void add(int pos, int w)
{
    while(pos <= n)
    {
        c[pos] += w;
        pos += lowbit(pos);
    }
}
int sum(int pos)
{
    int ret = 0;
    while(pos > 0)
    {
        ret += c[pos];
        pos -= lowbit(pos);
    }
    return ret;
}
int main()
{
    scanf("%d", &n);
    rep(i, 1, n) {scanf("%d", &a[i].num); a[i].id = i;}
    sort(a + 1, a + n + 1);
    per(i, n, 1)
    {
        ans += sum(a[i].id);
        add(a[i].id, 1);
    }
    printf("%d
", ans);
    return 0;
}

上述是一种比较常见的思路，就是按数值大小的顺序插入到对应的位置中。其实也可以按位置的前后插入到对应的大小顺序中。这两种效果相同。

-------------------------------------------18.5.19更新------------------------------------------

这天又做了一道逆序对的题，然后想出了一个更简洁的算法，不用结构体，不用sort。

首先也是要开一个类似于vis[]的数组，vis[x]记录x出现的次数。然后我们从头开始把vis[a[i]]++，这样对于每一次查询a[i]的逆序对，我们只用看位于a[i]后面的已经标记的数有多少个，a[i] + 1的后缀和，因为a[i]后面已经标记的数代表了比a[i]更早出现却比a[i]大的数，就是逆序对的定义嘛。

于是我想用树状数组，但树状数组是求动态前缀和的。于是我就改成了a[i]从后往前插入，这样就把后缀和改成了前缀和。

#include<cstdio>
#include<algorithm>
#include<iostream>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5; 
int n, a[maxn], c[maxn];
int lowbit(int x)
{
    return x & -x;
}
void add(int x, int d)
{
    int pos = x;
    while(pos < maxn)
    {
        c[pos] += d;
        pos += lowbit(pos);
    }
}
int sum(int x)
{
    int pos = x, ret = 0;
    while(pos > 0)
    {
        ret += c[pos];
        pos -= lowbit(pos);
    }
    return ret;
}
ll ans = 0;
int main()
{
    scanf("%d", &n); 
    for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    for(int i = n; i >= 1; --i)
    {
        ans += sum(a[i] - 1);
        add(a[i], 1);
    }
    printf("%lld
", ans);
    return 0; 
}