HDU 5775 Bubble Sort（归并排序+逆序数）

题目链接：HDU 5775

Bubble Sort

                                                                                              Time Limit: 2000/1000 MS    Memory Limit: 65536/65536 K

Problem Description

P is a permutation of the integers from 1 to N(index starting from 1).
Here is the code of Bubble Sort in C++.

for(int i=1;i<=N;++i)
    for(int j=N,t;j>i;—j)
        if(P[j-1] > P[j])
            t=P[j],P[j]=P[j-1],P[j-1]=t;

After the sort, the array is in increasing order. ?? wants to know the absolute values of difference of rightmost place and leftmost place for every number it reached.

 

Input

The first line of the input gives the number of test cases T; T test cases follow.
Each consists of one line with one integer N, followed by another line with a permutation of the integers from 1 to N, inclusive.

limits
T <= 20
1 <= N <= 100000
N is larger than 10000 in only one case. 

 

Output

For each test case output “Case #x: y1 y2 … yN” (without quotes), where x is the test case number (starting from 1), and yi is the difference of rightmost place and leftmost place of number i.

 

Sample Input

  
  

   
   2
3
3 1 2
3
1 2 3
  
  

 

Sample Output

  
  

   
   Case #1: 1 1 2
Case #2: 0 0 0


   
   

    
    

     
     Hint
    
    
In first case, (3, 1, 2) -> (3, 1, 2) -> (1, 3, 2) -> (1, 2, 3)
the leftmost place and rightmost place of 1 is 1 and 2, 2 is 2 and 3, 3 is 1 and 3
In second case, the array has already in increasing order. So the answer of every number is 0.
   
   
  
  

 心路历程：拿到这道题后先找规律，发现：每个数的最右端取决于它向右移动的次数，而每个数向右移动的次数取决于它后面有多少个比它小的数，而最左端则是min（初始位置，应有位置）。所以我们的目标就是找后面比它小的数，由于数列是连续的，所以我们可以求前面比它大的数，进而推出结果，于是我们可以将归并排序求逆序数改为求每个数前面比它大的数。

ac代码如下：

#include <iostream>
#include <stdio.h>

using namespace std;
//用结构体分别保存这个数原来的值（也是最后的位置）初始的角标，和它的逆序数
struct nu
{
    int val,index,sum;
}p[100010];
//归并排序
void merge_sort(nu arr[],nu brr[],int beg,int ed)
{
    if(beg>=ed)
    {
        return;
    }
    int mid=(beg+ed)/2;
    merge_sort(arr,brr,beg,mid);
    merge_sort(arr,brr,mid+1,ed);
    int i=beg,l1=beg,l2=mid+1;
    while(l1<=mid&&l2<=ed)
    {
        if(arr[l1].val>arr[l2].val)
        {
           arr[l2].sum+=mid+1-l1;//保存每个数的逆序数
        }
        brr[i++]=arr[l1].val<arr[l2].val?arr[l1++]:arr[l2++];
    }
    while(l1<=mid)
    {
        brr[i++]=arr[l1++];
    }
    while(l2<=ed)
    {
        brr[i++]=arr[l2++];
    }
    for(i=beg; i<=ed; i++)
    {
        arr[i]=brr[i];
    }
}
int main()
{
    int ca,n,k=1;
    scanf("%d",&ca);
    while(ca--)
    {
        nu brr[100010];//过度数组，用来辅助归并排序
        int pro[100010];//用来保存答案
        scanf("%d",&n);
        int i;
        for(i=1; i<=n; i++)
        {
            scanf("%d",&p[i].val);
            p[i].index=i;
            p[i].sum=0;
        }
        merge_sort(p,brr,1,n);
        for(i=1;i<=n;i++)//初始位置和应有位置的关系
        {
            if(p[i].index>=p[i].val)
            {
                pro[p[i].val]=p[i].sum;
            }
            else
            {
                pro[p[i].val]=p[i].sum-p[i].index+p[i].val;
            }
        }
        printf("Case #%d: ",k);
        for(i=1;i<n;i++)
        {
            printf("%d ",pro[i]);
        }
        printf("%d\n",pro[n]);
        k++;
    }
    return 0;
}

期末不挂！