POJ 2299 Ultra-QuickSort(树状数组求逆序对)

原题描述：
Time Limit: 7000MS Memory Limit: 65536K
Total Submissions: 62187 Accepted: 23121
Description

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
9 1 0 5 4 ,

Ultra-QuickSort produces the output
0 1 4 5 9 .

Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.
Input

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 – the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.
Output

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.
Sample Input
5
9
1
0
5
4
3
1
2
3
0
Sample Output
6
0
题目大意：
给定你多个序列，问其中的逆序对个数（数据极大！！！）

---

首先各位同学看到逆序对第一眼想到的应该就是归并排序了吧。
但如果这样编完，会发现自己会T很多。
这里就给大家介绍一种快速求逆序对个数的方法：离散化+树状数组！

---

1.离散化：
对于一个无序序列，应该很自然就会想到将其排成有序序列离散化，而本题的做法也是这样的。
举例来说，
原本序列：1 7 2 4 3 6
对应位置：1 2 3 4 5 6
离散化以后（以位值为离散化标准）
当前序列：1 2 3 4 5 6
对应位置：1 3 5 4 6 2
代码实现因该也不难：

struct node{int pos,date;}a[500001];
 for(i=1;i<=n;i++)
 {
   a[i].pos=i;
   a[i].date=read();
 }

那么此时我们就将求值的逆序对转化为了求位置的逆序对了。
然后我们再引入一个b数组，其下标表示真实位置，其值表示在刚刚离散化的序列中所处位置。
具体来说，
for(i=1;i<=n;i++)b[a[i].pos]=i;
举例来说，还是刚刚那个例子中的序列，第一遍按位值离散化，再赋给b后，为：
a[1].pos=1;————>b[1]=1;
a[2].pos=3;————>b[3]=2;
a[3].pos=5;————>b[5]=3;
a[4].pos=4;————>b[4]=4;
a[5].pos=6;————>b[6]=5;
a[6].pos=2;————>b[2]=6;
然后将b排序：b[1..6]={1 6 2 4 3 5}；
其实b[i]=j表示的就是第i个位置上的为第j大的数。
做到这里，离散化就基本做完了，由于我们的每一步离散化都基于值的大小，所以此时我们可以用b推出某个数前方有多少个小于其的数。（再看下文前读者不妨先独立思考一下）。

---

2.树状数组：
在我们离散化得到b数组后，我们就要开始利用树状数组求逆序对的个数了。
准确的说，我们利用b所求的为“顺序对的个数”。
而逆序对的个数=总序对个数-顺序对个数。
由于b的下标表示的是当前位置值的大小排名，
所以我们从1—n依次向树状数组中插入b，一定保证了值的大小顺序。
我们记每个插入节点的贡献为1，
那么其实每插入一个b，他的顺序对个数就为它前面所有节点贡献之和。
为什么呢，其实也并不是很难理解。
依旧以上面的例子说明(顺便回顾一下前面的步骤)：
原本序列：1 7 2 4 3 6
对应位置：1 2 3 4 5 6
离散化以后（以位值为离散化标准）
当前序列：1 2 3 4 5 6
对应位置：1 3 5 4 6 2
a[1].pos=1;————>b[1]=1;
a[2].pos=3;————>b[3]=2;
a[3].pos=5;————>b[5]=3;
a[4].pos=4;————>b[4]=4;
a[5].pos=6;————>b[6]=5;
a[6].pos=2;————>b[2]=6;
—>b[1]=1,b[2]=6,b[3]=2,b[4]=4,b[5]=3,b[6]=5;
我们用一条线段表示当前插入情况(求线段区间和读者们自己用树状数组实现，这里只解释说明原理)：
我们用“—”表示还未插入。
初始状态：— — — — — —

插入b[1]后：
线段状态：1 — — — — —
对应位值：1
此时和为1,构成的顺对个数为1，逆序对个数为i-1=0;

插入b[2]后：
线段状态：1 — — — — 1
对应位值：1 — — — — 2
当前的和为1+1=2，即构成的顺序对个数为2个,逆序对个数为i-2=0；

插入b[3]=2后：
线段状态：1 1 — — — 1
对应b值： 1 3 — — — 2
我们重点分析这个步骤：
对于当前位置，和为2，构成了两个顺序对，而此时插入的为第三个数，本来前方和应该为3，故组成逆序对个数为3-2=1；回过头看，第三个位置上的2组成逆序对是1个。
后面的依次类推。。。。。

为什么会这样，其实稍微想一想就知道了，我们插入的b[i]表示第i个位置上的数，为第b[i]大的数。如果前方全部为顺序对，那么前方和应该为i，而如果少了，就说明本应该比它小的数跑到后面去了，就构成了逆序对。
上面这一部分较难理解，希望读者们多加体会。

---

最后给出完整的代码：

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

struct node{int pos,date;}a[500001];
int b[500001],t[2000001];
long long ans;
int n;

int gi() {
    int w;bool q=1;char c;
    while (((c=getchar())<'0'||'9'<c)&&c!='-');
    if (c=='-') q=0,c=getchar();
    w=c-'0';
    while ('0'<=(c=getchar())&&c<='9') w=w*10+c-'0';
    return q?w:-w;
}

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

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

void insert(int x,int val)
{
    while(x<=n)
    {
      t[x]+=val;
      x=x+lowbit(x);
    }return;
}

int getsum(int x)
{
  int sum=0;
  while(x>0)
    {
      sum+=t[x];
      x=x-lowbit(x);
    }
  return sum;
}

int main()
{
     freopen("A.txt","r",stdin);
     int i,j;
    while(1)
    {
      n=gi();
      if(n==0)break;
      for(i=1;i<=n;i++)
      {
      a[i].pos=i;
      a[i].date=gi();
      }
      sort(a+1,a+n+1,cmp);
      for(i=1;i<=n;i++)b[a[i].pos]=i;
      ans=0;
      memset(t,0,sizeof(t));
      for(i=1;i<=n;i++)
      {
        insert(b[i],1);
        ans+=i-getsum(b[i]);
      }
      printf("%lld\n",ans);
    }
    return 0;
}

Hahahaha!