HDU 1394 (逆序数) Minimum Inversion Number

原来求逆序数还可以用线段树，涨姿势了。

首先求出原始序列的逆序数，然后递推每一个序列的逆序数。

 

 1 #include <cstdio>

 2 #include <cstring>

 3 #include <algorithm>

 4 using namespace std;

 5 

 6 const int maxn = 20000 + 10;

 7 

 8 int n, p, qL, qR;

 9 int sum[maxn], a[5000 + 10];

10 

11 void update(int o, int L, int R)

12 {

13     if(L == R) { sum[o]++; return; }

14     int M = (L + R) / 2;

15     if(p <= M) update(o*2, L, M);

16     else update(o*2+1, M+1, R);

17     sum[o] = sum[o*2] + sum[o*2+1];

18 }

19 

20 int query(int o, int L, int R)

21 {

22     if(qL <= L && qR >= R) return sum[o];

23     int ans = 0;

24     int M = (L + R) / 2;

25     if(qL <= M) ans += query(o*2, L, M);

26     if(qR > M) ans += query(o*2+1, M+1, R);

27     return ans;

28 }

29 

30 int main()

31 {

32     //freopen("in.txt", "r", stdin);

33 

34     while(scanf("%d", &n) == 1)

35     {

36         memset(sum, 0, sizeof(sum));

37 

38         for(int i = 0; i < n; i++) scanf("%d", &a[i]);

39         int inv = 0;

40         for(int i = 0; i < n; i++)

41         {

42             p = a[i];

43             qL = a[i]; qR = n - 1;

44             inv += query(1, 0, n - 1);

45             update(1, 0, n - 1);

46         }

47         int ans = inv;

48         for(int i = 0; i < n; i++)

49         {

50             inv = inv + n - a[i]*2 - 1;

51             ans = min(ans, inv);

52         }

53         printf("%d\n", ans);

54     }

55 

56     return 0;

57 }

线段树

 

既然要求逆序数了，干脆树状数组，归并排序也都试一试。

由于树状数组lowbit的特点，所以数组下标是从1开始的。但是树状数组要比线段树好写很多。

 1 #include <cstdio>

 2 #include <cstring>

 3 #include <algorithm>

 4 using namespace std;

 5 

 6 const int maxn = 5000 + 10;

 7 int n;

 8 int a[maxn], s[maxn];

 9 

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

11 

12 int sum(int x)

13 {

14     int ans = 0;

15     while(x > 0) { ans += s[x]; x -= lowbit(x); }

16     return ans;

17 }

18 

19 void add(int x, int d)

20 {

21     while(x <= n) { s[x] += d; x += lowbit(x); }

22 }

23 

24 int main()

25 {

26     //freopen("in.txt", "r", stdin);

27 

28     while(scanf("%d", &n) == 1)

29     {

30         memset(s, 0, sizeof(s));

31         for(int i = 0; i < n; i++) { scanf("%d", &a[i]); a[i]++; }

32         int inv = 0;

33         for(int i = 0; i < n; i++)

34         {

35             inv += sum(n) - sum(a[i]);

36             add(a[i], 1);

37         }

38         int ans = inv;

39         for(int i = 0; i < n; i++)

40         {

41             inv = inv + n + 1 - a[i]*2;

42             ans = min(ans, inv);

43         }

44         printf("%d\n", ans);

45     }

46 

47     return 0;

48 }

树状数组

 

下面是归并排序，_(:зゝ∠)_

代码不长，但是感觉还是挺容易写错的。

 1 #include <cstdio>

 2 #include <cstring>

 3 #include <algorithm>

 4 using namespace std;

 5 

 6 const int maxn = 5000 + 10;

 7 int n, inv;

 8 int a[maxn], b[maxn], T[maxn];

 9 

10 void MergeSort(int x, int y)

11 {

12     if(y - x > 1)

13     {

14         int m = (x + y) / 2;

15         int p = x, q = m, i = x;

16         MergeSort(x, m); MergeSort(m, y);

17         while(p < m || q < y)

18         {

19             if(q >= y || (p < m && a[p] <= a[q])) T[i++] = a[p++];

20             else { T[i++] = a[q++]; inv += m - p; }

21         }

22         for(i = x; i < y; i++) a[i] = T[i];

23     }

24 }

25 

26 int main()

27 {

28     //freopen("in.txt", "r", stdin);

29 

30     while(scanf("%d", &n) == 1)

31     {

32         for(int i = 0; i < n; i++) { scanf("%d", &a[i]); b[i] = a[i]; }

33         inv = 0;

34         MergeSort(0, n);

35         int ans = inv;

36         for(int i = 0; i < n; i++)

37         {

38             inv = inv + n - 1 - b[i]*2;

39             ans = min(ans, inv);

40         }

41         printf("%d\n", ans);

42     }

43 

44     return 0;

45 }

归并排序