树状数组求逆序对：POJ 2299、3067

　　前几天开始看树状数组了，然后开始找题来刷。

　　首先是 POJ 2299 Ultra-QuickSort： http://poj.org/problem?id=2299

　　这题是指给你一个无序序列，只能交换相邻的两数使它有序，要你求出交换的次数。实质上就是求逆序对，网上有很多人说它的原理是冒泡排序，可以用归并排序来求出，但我一时间想不出它是如何和归并排序搭上边的（当初排序没学好啊~），只好用刚学过的树状数组来解决了。在POJ 1990中学到了如何在实际中应用上树状数组，没错，就是用个特殊的数组来记录即可，然后区间查询和单点更新的复杂度都在O(logn)范围内。

　　对于这道题，即处理到第i个数时，可以通过计算 i-1-它前面比它小的数得出前面比它大的数，即该数前面的逆序数；而统计某数前面比它小的数就是树状数组的裸题了。分析到这里已经差不多了，但是一看，a[i] ≤ 999,999,999，就不能简单地用数组下标来记录a[i]的值了，这时我想起了之前看过的一个很高大上的名字："离散化"，没错，就是离散化，因为n < 500,000而已，用不着那么多数组的空间，把a[i]通过排序再放进数组即可，不过具体的题我还没做过，对于这道题，我的做法是设置一个辅助数组 r[i] 表示第i个数的下标，初始化时也就是r[i]= i，然后通过比较对应a[i]的a[j]的值对r[]排序。说白了就是对数组a[]的下标进行排序（利用了刘汝佳小白书上kruskal的做法），这时候数组r[]的逆序数就是数组a[]的逆序数。这是因为在排序时是一一对应的，每交换两个数使a[]消除一个逆序对时r[]便增加一个逆序对（r[]本来是1,2,3,4,5……的顺序数列），所以就转化为了求数组r[]的逆序对，此时下标只受n<500,000约束，开数组不成问题，详见代码：

 1 #include<cstdio>

 2 #include<cstring>

 3 #include<algorithm>

 4 using namespace std;

 5 typedef long long LL;

 6 const LL maxn= 500008;

 7 

 8 inline int lowbit(int x) {    return x&(-x);    }

 9 

10 struct treeArray{

11     int c[maxn], n;

12     treeArray(int n=0):n(n)    {    memset(c,0,sizeof(c));    }

13     void clear() {    memset(c,0,sizeof(c));    }

14     int sum(int x) const {

15         int ans= 0;

16         while(x){

17             ans+= c[x];

18             x-= lowbit(x);

19         }

20         return ans;

21     }

22     void add(int x, int d){

23         while(x<=n){

24             c[x]+= d;

25             x+= lowbit(x);

26         }

27     }

28 } num(maxn);

29 

30 int a[maxn], r[maxn];

31 bool cmp(int i, int j)    {    return a[i]<a[j];    }

32 

33 int main(){

34     int n,i;

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

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

37             scanf("%d",a+i);

38             r[i]= i;

39         }

40         sort(r+1,r+n+1,cmp);

41         LL inv= 0;

42         num.clear();

43         num.n= n;

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

45             inv+= i-1-num.sum(r[i]);

46             num.add(r[i],1);

47         }

48         printf("%lld\n",inv);

49     }

50     return 0;

51 }

　　树状数组的写法我参照了网上的人的写法，把它封装成一个结构体，用于实现区间查询和单点更新的数组c[]放在了结构体内，这样子可使代码更清晰，不至于要开个全局数组容易混淆，如同矩阵快速幂一样把矩阵的乘法重载在结构体中，可以避免在一些细节上浪费精力，代码量也没有增加多少。

 

　　然后是第二道 POJ 3067： http://poj.org/problem?id=3067

　　这题主要是说东西两边各有1~N和1~M个城市，然后有K条道路连接东西两边的城市，要求这K条边的所有交点。这里有个不大却很易栽的坑：K的范围没给出，所以可以猜想其为N*M的上限，然后它给出的道路也没说是有序的（千万别被样例骗了），所以我们首先要对它进行预处理才行。

　　如上题一样，可以利用求逆序对的做法来求。为什么呢？我们可以先按e（就是左边的坐标）排升序，e相同的话按w（右边的坐标）排升序（w一定要为升序，因为e相同时的边是不会有交叉点的，所以w升序在统计时可以使e相同而w不同的边不存在逆序对，符合没有交叉点的实际情况），大体的预处理就是这样，然后对排好序的w边进行求逆序数即可，具体求法如上题所述。和上题不同的是，这里的w值可以和前面的重复，但也不影响树状数组的运用，要处理好细节，记住先返回区间的值即sum(x)，再去更新即add(x)（数组c[x]在add(x)前为0，不影响sum(x)的统计）。

 1 #include<cstdio>

 2 #include<cstring>

 3 #include<algorithm>

 4 using namespace std;

 5 typedef long long LL;

 6 #define lowbit(x) ((x)&-(x))

 7 const int maxn= 1000006;

 8 

 9 struct treeArray{

10     int c[maxn], n;

11     treeArray(int n=0):n(n)    {    memset(c,0,sizeof(c));    }

12     void clear() {    memset(c,0,sizeof(c));    }

13     LL sum(int x) const {

14         LL ans= 0;

15         while(x){

16             ans+= c[x];

17             x-= lowbit(x);

18         }

19         return ans;

20     }

21     void add(int x, int d){

22         while(x<=n) {        //这里是 wa的根源？

23             c[x]+= d;

24             x+= lowbit(x);

25         }

26     }

27 } num(maxn);

28 

29 struct Edge{

30     int e,w;

31     bool operator <(const Edge E2) const {

32         if(e==E2.e)      return w<E2.w;

33         return e<E2.e;

34     }

35 } edge[maxn];

36 

37 void solve(){

38     static int p=0;

39     int n,m,k;

40     scanf("%d%d%d",&n,&m,&k);

41     for(int i=1; i<=k; ++i)

42         scanf("%d%d",&edge[i].e, &edge[i].w);

43     

44     sort(edge+1,edge+k+1);

45     LL inv= 0;

46     num.clear();

47     num.n= m;        //原来这里才是 wa的根源！！

48     for(int i=1; i<=k; ++i){

49         inv+= i-1-num.sum(edge[i].w);

50         num.add(edge[i].w,1);

51     }

52     printf("Test case %d: %lld\n",++p,inv);

53 }

54 

55 int main(){

56     int t;

57     scanf("%d",&t);

58     while(t--)    solve();

59     return 0;

60 }

　　奇怪的是，这题我wa了近10遍才过(T.T)，一开始怎么也找不着错的原因，各种long long、__int64、%lld、%I64d的输入输出姿势都试过了，还是wa，没办法，只好和标程一点一点地对拍，到最后才发现真正的错误是在num.n= m这里，就是没处理好树状数组c[]的n，这种细节问题还是第一次见，不过也需记住这个错误，因为树状数组的结构体模板以后应该会经常用到，还是得多刷题了，昨晚竟被老师和师兄说自己的进度太慢，听后除了惭愧外还有一丝恨铁不成钢（我对自己）的心理，大白书，Come on！