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