POJ_2299_Ultra-QuickSort

牢骚：~做了那么久树状数组卡死在离散化，无语到透顶。

离散化的定义：把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。

这题是赤裸裸的求逆序对，为何要用离散化？

首先，这恶心的题目给出a[i]的范围居然是10亿，这还求啥逆序对，开个辅助数组c，直接MLE了，还好出题人人性化了点，给了个数组长度n，1<=n<50,000，还有希望...

然后，我们根据a[i]的值从小到大排列，留着它的id...然后遍历

#include <cstdio>

#include <cmath>

#include<vector>

#include <algorithm>

using namespace std;

#define N 500005

#define LL long long

int n,c[N];

struct point

{

    int val,id;

}p[N];

int sum(int x)

{

    int ret=0;

    while(x)

    {

        ret+=c[x];

        x-=x&-x;

    }

    return ret;

}

void add(int x)

{

    while(x<=n)

    {

        c[x]++;

        x+=x&-x;

    }

}

bool cmp(point a,point b)

{

    if(a.val != b.val)  //注意有相等的元素 ，必须这样写

        return a.val<b.val;

    return a.id <b.id;

}

int main()

{

    int i,j,k;

    while(~scanf("%d",&n),n)

    {

        for(i=1;i<=n;++i)

        {

            scanf("%d",&p[i].val);

            p[i].id=i;

            c[i]=0;

        }

        sort(p+1,p+1+n,cmp);

        LL ans=0; //一般n在10W以上，求逆序对的题目就可以直接用long long了

        for(i=1;i<=n;++i)

        {

            /*

            为啥可以这样离散化？

            想想啊，假设i<j,p[i].id<p[j].id,然后由排序，我们知道p[i].num一定会小于等于p[j].num，

            于是p[i]、p[j]就顺利的成为了一对非严格递增的顺序对

            */

            add(p[i].id); 

            ans+=i-sum(p[i].id);

        }

        printf("%I64d\n",ans);

    }

    return 0;

}