poj2299_树状数组

题意：求逆序对。

分析：以前用分治的思想写的，这次用树状数组。

以array[]=9 1 0 5 4 为例,

1.对于每个array[i]，求出小于等于array[i]的个数：

9：1

1：1

0：1

5：3

4：3个

这里如果遍历求的话，就超时了。因此需要构建树状数组，树状数组需要离散化。有：
array[] 9 1 0 5 4

num    1 2 3 4 5

这里不压缩要1--n内有时也行，如果数据小的话。

比如这个例子就行，离散到大于等于1就行。

但是如果数据大的话，就得压缩压下。

2.用树状数组求小于等于array[i]的个数应该以array[]由小到大排序遍历

i          1 2 3 4 5

array   0 1 4 5 9

num    3 2 5 4 1

array[]排序后也对应了num的一个顺序

依次对num进行更新，就可以tree[i]求出的就是小于等于array[i]的个数

3.用已经排序的对应的i-tree[i],即i-小于等于array[i]的个数的总和就是逆序数个数。

4.总结：关键是树状数组的构建，这里树状数组是用来求小于等于array[i]的个数的。

代码：

树状数组500ms

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <memory.h>
using namespace std;
//500ms
const int maxnum=500000;
struct node
{
    int digit;
    int num;
}array[maxnum];
int tree[maxnum];
int n;

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

void update(int index,int add)
{
    while(index<=n)  //  1.是<=n
    {
        tree[index]+=add;
        index+=((-index)&index);
    }
}

int getsum(int index)
{
    int sum=0;
    while(index>0)
    {
        sum+=tree[index];
        index-=((-index)&index);
    }
    return sum;
}

int main()
{
    int i;
    __int64 sum;
    while(scanf("%d",&n) && n!=0)
    {
        for(i=1;i<=n;i++)
        {
            scanf("%d",&array[i].digit);
            array[i].num=i;
        }
        sort(array+1,array+n+1,cmp);

        memset(tree,0,sizeof(tree)); //初始化树状数组
        sum=0;
        for(i=1;i<=n;i++)
        {
            update(array[i].num,1);
            sum+=(i-getsum(array[i].num));
        }
        printf("%I64d\n",sum);
    }
    return 0;
}

/*
5
9 1 0 5 4
*/

分治1282ms

#include <iostream>

using namespace std;
const int maxnum=1000000000;
int a[500005];
int larray[250005];
int rarray[250005];
long long cnt;   //这里是long long 否则wa

void Merge(int p,int q,int r)
{
    int i;
    int llen=q-p+1;
    int rlen=r-q;
    for(i=0;i<llen;i++)
        larray[i]=a[p+i];
    for(i=0;i<rlen;i++)
        rarray[i]=a[q+1+i];
    larray[llen]=maxnum;
    rarray[rlen]=maxnum;

    int j,k;
    i=0;j=0;
    for(k=p;k<=r;k++)
    {
        if(larray[i]<=rarray[j])
        {
            a[k]=larray[i];
            i++;
        }
        else
        {
            a[k]=rarray[j];
            j++;
            cnt+=llen-i;
        }
    }
}

void Merge_Sort(int p,int r)
{
    if(p<r)
    {
        int q=(p+r)/2;
        Merge_Sort(p,q);
        Merge_Sort(q+1,r);
        Merge(p,q,r);
    }
}

int main()
{
    int num,i;
    while(cin>>num)
    {
        if(num==0) break;
        for(i=0;i<num;i++)
            cin>>a[i];
        cnt=0;
        Merge_Sort(0,num-1);
        cout<<cnt<<endl;
    }
    return 0;
}

 

tjuoj 1455