【poj1804】【poj2299】【模板】求逆序对

刚写了一发归并排序的逆序对（不会写二分的蒟蒻）
那就顺便复习一下树状数组求逆序对吧

来道裸题

题目:http://poj.org/problem?id=1804
题意:给定一个序列a[],每次只允许交换相邻两个数,最少要交换多少次才能把它变成非递降序列.

归并排序是将数列a[l,h]分成两半a[l,mid]和a[mid+1,h]分别进行归并排序，然后再将这两半合并起来。
在合并的过程中（设l<=i<=mid，mid+1<=j<=h），当a[i]<=a[j]时，并不产生逆序数；当a[i]>a[j]时，在前半部分中比a[i]大的数都比a[j]大，将a[j]放在a[i]前面的话，逆序数要加上mid+1-i。因此，可以在归并
排序中的合并过程中计算逆序数.

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
using namespace std;
int a[100001];
int ans;
void mergesort(int l,int r)
{
    int i,j,k,mid=(l+r)/2;
    if(l>=r) return;
    mergesort(l,mid);
    mergesort(mid+1,r);
    int *b=new int[r+1];
    for(i=l;i<=r;i++) b[i]=a[i];
    i=l,j=mid+1,k=l;
    while(i<=mid&&j<=r)
    {
        if(b[i]<=b[j]) a[k++]=b[i++];
        else
        {
            a[k++]=b[j++];
            ans+=mid+1-i;       
        }
    }
    while(i<=mid) a[k++]=b[i++];
    while(j<=r) a[k++]=b[j++];
    delete []b;
}
int main()
{
    int t,tt=0;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++) scanf("%d",&a[i]);
        mergesort(1,n);
    //  for(int i=1;i<=n;i++) cout<<a[i]<<" ";
        printf("Scenario #%d:\n%d\n\n",++tt,ans);
        ans=0;
    }
    return 0;
}

再来一道
poj2299
用树状数组求的话先离散化，然后再更新答案
开始不太好理解，可以手动强行模拟一波

假设输入的数组是9 1 0 5 4， 离散后的结果aa[ ] = {5,2,1,4,3};
在离散结果中间结果的基础上，那么其计算逆序数的过程是这么一个过程。
1，输入5， 调用upDate(5, 1),把第5位设置为1
1 2 3 4 5
0 0 0 0 1
计算1-5上比5小的数字存在么？ 这里用到了树状数组的getSum（5） = 1操作，
现在用输入的下标1 - getSum(5) = 0 就可以得到对于5的逆序数为0。
2. 输入2， 调用upDate(2, 1),把第2位设置为1
1 2 3 4 5
0 1 0 0 1
计算1-2上比2小的数字存在么？ 这里用到了树状数组的getSum（2） = 1操作，
现在用输入的下标2 - getSum(2) = 1 就可以得到对于2的逆序数为1。
3. 输入1， 调用upDate(1, 1),把第1位设置为1
1 2 3 4 5
1 1 0 0 1
计算1-1上比1小的数字存在么？ 这里用到了树状数组的getSum（1） = 1操作，
现在用输入的下标 3 - getSum(1) = 2 就可以得到对于1的逆序数为2。
4. 输入4， 调用upDate(4, 1),把第5位设置为1
1 2 3 4 5
1 1 0 1 1
计算1-4上比4小的数字存在么？ 这里用到了树状数组的getSum（4） = 3操作，
现在用输入的下标4 - getSum(4) = 1 就可以得到对于4的逆序数为1。
5. 输入3， 调用upDate(3, 1),把第3位设置为1
1 2 3 4 5
1 1 1 1 1
计算1-3上比3小的数字存在么？ 这里用到了树状数组的getSum（3） = 3操作，
现在用输入的下标5 - getSum(3) = 2 就可以得到对于3的逆序数为2。
6. 0+1+2+1+2 = 6 这就是最后的逆序数
分析一下时间复杂度，首先用到快速排序，时间复杂度为O(NlogN),
后面是循环插入每一个数字，每次插入一个数字，分别调用一次upData()和getSum()外循环N, upData()和getSum()时间O(logN) => 时间复杂度还是O(NlogN).
最后总的还是O(NlogN).

不得不说，手动模拟是个好东西O(∩_∩)O

http://poj.org/problem?id=2299

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=500001;
int num[maxn],a[maxn],n;
struct node
{
    int val,pos;
}b[maxn];

int s[maxn];
bool lisanhua(const node &a,const node &b)
{
    return a.val<b.val;
}

int lowbit(int x)
{
    return x&(-x);
}
void add(int x)
{
    for(int i=x;i<=n;i+=lowbit(i))
        s[i]++;
}
int sum(int x)
{
    int ans=0;
    for(int i=x;i>0;i-=lowbit(i))
        ans+=s[i];
    return ans; 
}
int main()
{
    long long ans=0;
    while((scanf("%d",&n))&&n)
    {
        memset(s,0,sizeof(s));
        memset(b,0,sizeof(b));
        for(int i=1;i<=n;i++) 
        {
            scanf("%d",&b[i].val);
            b[i].pos=i;
        }
        sort(b+1,b+n+1,lisanhua);
        for(int i=1;i<=n;i++) num[b[i].pos]=i;
        for(int i=1;i<=n;i++)
        {
            add(num[i]);
            ans+=i-sum(num[i]);
        }
        printf("%lld\n",ans);
        ans=0;
    }
    return 0;
}