hdu 1394 Minimum Inversion Number(线段树求最小逆序数)

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=1394

题目大意:   给出N个数，这些数可以把后面的删掉然后放到最前面形成新的序列

                 可得到的N种情况，求出这N种情况哪种的逆序数最小

解题思路:   先求出第一个序列的逆序数，然后用很巧妙的办法求下一个序列的逆序数，直到全部求出

                 序列 4 5 2 1 3 6 ，此序列的逆序数为7，它等到的下一个序列为 5 2 1 3 6 4

                 看这个新序列的产生过程，首部删除4，尾部添加4

                 删除4，必然会使得这个序列的逆序数减少(4-1)个，因为4前面必定有4-1个数小于4

                 添加4，必然会使得这个序列的逆序数增加(6-4)个，因为4后面必定有6-4个数大于4

                 由此推出公式，假设移动的数为m，序列的逆序数=上一序列逆序数-(m-1)+(N-m)

                 由于给出的序列不是顺序的，所以先要离散化出来

[cpp]  view plain  copy

1. // 线段树  
2. #include <stdio.h>  
3. #include <string.h>  
4. #include <stdlib.h>  
5. #include <algorithm>  
6. using namespace std;  
7. #define MAX 5100  
8. #define INF 0x3f3f3f3f  
9. #define MID(a,b) (a+b)>>1  
10. #define R(a) (a<<1|1)  
11. #define L(a) a<<1  
12. typedef struct {  
13.     int num,left,right;  
14. }Node;  
15. typedef struct {  
16.     int num,y;  
17. }Nodes;  
18. Nodes ans[MAX];  
19. Node Tree[MAX<<2];  
20. int n;  
21.   
22. bool cmp(Nodes a,Nodes b)  
23. {  
24.     return a.num>b.num?0:1;  
25. }  
26.   
27. bool cmp2(Nodes a,Nodes b)  
28. {  
29.     return a.y>b.y?0:1;  
30. }  
31.   
32. void Build(int t,int l,int r)         //以1为根节点建立线段树    
33. {    
34.     int mid;    
35.     Tree[t].left=l,Tree[t].right=r;    
36.     if(Tree[t].left==Tree[t].right)    
37.     {    
38.         Tree[t].num=0;    
39.         return ;    
40.     }    
41.     mid=MID(Tree[t].left,Tree[t].right);    
42.     Build(L(t),l,mid);    
43.     Build(R(t),mid+1,r);    
44. }    
45.     
46. void Insert(int t,int l,int r,int x)     //向以1为根节点的区间[l,r]插入数字1    
47. {    
48.     int mid;    
49.     if(Tree[t].left==l&&Tree[t].right==r)    
50.     {    
51.         Tree[t].num+=x;    
52.         return ;    
53.     }    
54.     mid=MID(Tree[t].left,Tree[t].right);    
55.     if(l>mid)    
56.     {    
57.         Insert(R(t),l,r,x);    
58.     }    
59.     else if(r<=mid)    
60.     {    
61.         Insert(L(t),l,r,x);    
62.     }    
63.     else    
64.     {    
65.         Insert(L(t),l,mid,x);    
66.         Insert(R(t),mid+1,r,x);    
67.     }    
68.     Tree[t].num=Tree[L(t)].num+Tree[R(t)].num;    
69. }    
70.     
71. int Query(int t,int l,int r)           //查询以1为根节点，区间[l,r]的和    
72. {    
73.     int mid;    
74.     if(Tree[t].left==l&&Tree[t].right==r)    
75.         return Tree[t].num;    
76.     mid=MID(Tree[t].left,Tree[t].right);    
77.     if(l>mid)    
78.     {    
79.         return Query(R(t),l,r);    
80.     }    
81.     else if(r<=mid)    
82.     {    
83.         return Query(L(t),l,r);    
84.     }    
85.     else    
86.     {    
87.         return Query(L(t),l,mid)+Query(R(t),mid+1,r);    
88.     }    
89. }    
90.   
91. int main()  
92. {  
93.     int a,n,i,t,min;  
94.     long long int k;  
95.     while(scanf("%d",&n)!=EOF)  
96.     {  
97.         memset(Tree,0,sizeof(Tree)); //初始化  
98.         Build(1,1,n);                //建立线段树  
99.         for(i=1;i<=n;i++)  
100.         {  
101.             scanf("%d",&ans[i].num);  
102.             ans[i].y=i;  
103.         }  
104.         sort(ans+1,ans+1+n,cmp);     //离散化  
105.         for(i=1;i<=n;i++)            //离散化  
106.             ans[i].num=i;  
107.         sort(ans+1,ans+1+n,cmp2);  
108.         for(i=1,k=0;i<=n;i++)  
109.         {  
110.             a=ans[i].num;  
111.             Insert(1,a,a,1);  
112.             k=k+(i-Query(1,1,a));    //求出第一个序列的逆序数  
113.         }  
114.         min=INF;  
115.         for(i=1;i<=n;i++)            //O(n)求出所有序列的逆序数，并且取最小的  
116.         {  
117.             k=k-(ans[i].num-1)+(n-ans[i].num);  
118.             if(min>k)  
119.                min=k;  
120.          }  
121.         printf("%d\n",min);  
122.     }  
123.     return 0;  
124. }