树状数组求逆序数

样例输入：

3

1 2 3

4

4 3 2 1

样例输出：

0

6

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
int a[10005];
int n;

int lowbit(int t)
{
    return t&(-t);
}

void Update(int i,int d)   //更新含有x的数组个数
{
    while(i<=n)
    {
        a[i]+=d;
        i+=lowbit(i);
    }

}

int Getsum(int i)   //向下统计小于x的个数
{
    int sum=0;
    while(i>0)
    {
        sum+=a[i];
        i-=lowbit(i);
    }
    return sum;
}

int main ()
{
    int i,k;
    while(cin>>n)
    {
        memset(a,0,sizeof(a));
        int ans=0;
        for(i=1;i<=n;i++)
        {
            cin>>k;         //  一个个插入到树状数组
            Update(k,1);
            ans+=i-Getsum(k);    //  i-Getsum(k)  表示为比k大的数，即逆序数
        }
        cout<<ans<<endl;
    }
    return 0;
}

离散操作+树状数组

样例输入：

5

9 1 0 5 4

离散操作流程：

1.结构体存储：

 k:    9 1 0 5 4

orde:  1 2 3 4 5

2.排序后：

 k:   0 1 4 5 9

orde: 3 2 5 4 1

3.储存到a数组：

a[3]=1;

a[2]=2;

a[5]=3;

a[4]=4;

a[1]=5;

4.最终结果：

 i:   1 2 3 4 5 

a[i]: 5 2 1 4 3

原输入： 9 1 0 5 4

离散后： 5 2 1 4 3

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
int a[10005];   // 存离散化后的数组
int c[10005];   // 存树状数组
int n;

struct node
{
  int k,orde; 
}p[10005];

bool cmp(node a,node b)
{
    return (a.k<b.k);
}

int lowbit(int t)
{
    return t&(-t);
}

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

}

int Getsum(int i)
{
    int sum=0;
    while(i>0)
    {
        sum+=c[i];
        i-=lowbit(i);
    }
    return sum;
}

int main ()
{
    int i,j;
    while(cin>>n)
    {
        for(i=1;i<=n;i++)
        {
            cin>>p[i].k;
            p[i].orde=i;
        }
        // 离散化
        sort(p+1,p+n+1,cmp);
        for(i=1;i<=n;i++)
            a[p[i].orde]=i;

        memset(c,0,sizeof(c));
        int ans=0;
        for(j=1;j<=n;j++)
        {
            Update(a[j],1);
            ans+=j-Getsum(a[j]);
        }
        cout<<ans<<endl;
    }
    return 0;
}