树状数组求逆序对原理

归并排序和树状数组都可以用nlogn的算法做到求出逆序对.但这里着重讲树状数组的原理与求法.
树状数组最常用的方面就是用来求逆序对, 普通方法需要n^2的复杂度, 而树状数组只需要用nlogn的复杂度, 所以是很好的优化, 关键在于内部函数lowbit的应用.
这是树状数组的结构图 : lowbit函数就是进行哪些实现之间的转化的, 因为这些数之间在二进制中存在着某种联系, 而lowbit函数便可把这些联系体现出来.!!!

image.png

总之记住树状数组实现的是nlogn的算法, 和他具体实现的是什么功能就行了.
当数据的范围较小时,比如maxn=100000,那么我们可以开一个数组c[maxn],来记录前面数据的出现情况,初始化为0;当数据a出现时,就令c[a]=1。这样的话,欲求某个数a的逆序数,只需要算出在当前状态下c[a+1,maxn]中有多少个1,因为这些位置的数在a之前出现且比a大。但是若每添加一个数据a时,就得从a+1到 maxn搜一遍,复杂度太高了。树状数组却能很好的解决这个问题,可以把数一个个插入到树状数组中, 每插入一个数, 统计比他小的数的个数,对应的逆序为 i - getsum( c[i] ),其中 i 为当前已经插入的数的个数, getsum( c[i] )为比 c[i] 小的数的个数,i- getsum( c[i] ) 即比c[i] 大的个数, 即逆序的个数。最后需要把所有逆序数求和,就是在插入的过程中边插入边求和.

举个例子:有5个数,分别为5 3 4 2 1,当读入数据a=5时,c为:0,0,0,0,1;d为:0,0,0,0,1;当读入数据a=3时,c为:0,0,1,0,1;d为:0,0 , 1,1,1;当读入数据a=4时,c为:0,0,1,1,1;d为:0,0,1,2,1;
此思想的关键在于,读入数据的最大值为maxn,由于maxn较小,所以可以用数组来记录状态。当maxn较大时,直接开数组显然是不行了,这是的解决办法就是离散化。所谓离散化,就是将连续问题的解用一组离散要素来表征而近似求解的方法,这个定义太抽象了,还是举个例子吧。
   假如现在有一些数:1234 98756 123456 99999 56782,由于1234是第一小的数,所以num[1]=1;依此,有num[5]=2,num[2]=3,num[4]=4,num[3]=5;这样转化后并不影响原来数据的相对大小关系,何乐而不为呢!!!
还有一点值得注意,当有数据0出现时,由于0&0=0,无法更新,此时我们可以采取加一个数的方法将所有的数据都变成大于0的.

具体看代码 : 树状数组+去重离散化

#include<cstdio>
#include<algorithm>
#include<cstring>
#define CLR(x) memset(x,0,sizeof(x))
#define ll long long int
#define PI acos(-1.0)
#define db double
#define mod 1000000007
using namespace std;
const int maxn=1e5+5;
const db eps=1e-6;
const int inf=1e9;
const ll INF=1e15;
int c[maxn];         //树状数组
int lisan[maxn];   //用来离散的存离散后的结果数组
int s[maxn];        //用来存原始状态
int n,k;
//树状数组
int lowbit(int x)  //返回值最大1e5.
{
    return x&(-x);
}

void update(int i,int ans)
{
    while(i <= n){
        c[i] += ans;
        i += lowbit(i);
    }
}

int sum(int i)
{
    int s = 0;
    while(i > 0){
        s += c[i];
        i -= lowbit(i);
    }
    return s;
}
//结束
int main()
{
    while(~scanf("%d%d",&n,&k)){
        CLR(c);
        for(int i=0;i<n;i++){
            scanf("%d",&s[i]);
            lisan[i] = s[i];
        }
        sort(lisan,lisan+n);
        int len=unique(lisan,lisan+n)-lisan;
        ll res = 0;
        for(int i=0;i<n;i++){
            ll l=lower_bound(lisan,lisan+len,s[i])-lisan+1;
            update(l,1);
            res += i+1 - sum(l);
        }
        if(res < k) printf("0\n");
        else
            printf("%lld\n",res-k);
    }
}

说一说离散那部分.

/* 首先看题就知道肯定是需要进行离散化的, 还有一个问题就是可能有重数, 对于sort这种不稳定排序, 不考虑
*重数, 是对结果又影响的, 所以需要进行去重离散化, 一般的离散化也可以做到, 就是知道判到不重了, 就离散
* 化, 但是稍微有点麻烦, 所以这里就用到了, unique 和 lower_bound 函数, unique是使该数组中相同的部分去
* 掉, 而lower_bound是返回第一个大于或等于x的位置, 返回的都是地址.
*/
for(int i=0;i<n;i++){
            scanf("%d",&s[i]);
            lisan[i] = s[i];
}
sort(lisan,lisan+n);       //首先排序
int len=unique(lisan,lisan+n)-lisan;   //求出离散数组的长度并去重.
ll res = 0;
for(int i=0;i<n;i++){
int l=lower_bound(lisan,lisan+len,s[i])-lisan+1;    //实际上是返回的s[i] 在lisan数组中下标位置(从1开始) 然后
      //给原先那个数组所有相同的数都统一赋成一个值. 这样就可以到达去重的目的. l 既是离散化后的结果
update(l,1);
res += i+1 - sum(l);
}

所以实际上不管离不离散化都可以用这种方法.

推荐阅读更多精彩内容