翻转排序 (sort)

翻转排序(sort)

题目描述

Alex得到了存放着一个1-n排列的容器。这个容器支持的唯一操作,是翻转排列的某一段。思考很久之后,他决定用以下方式让这个排列有序:

 

1 找到每一个极大的下降子序列(子序列要求连续)

2 对于每个长度大于1的极大下降子序列,对它进行翻转

3 如果排列依然不是有序的,转1

 

我们举一个例子:初始排列是(5 3 1 4 2)

一开始极大的下降子序列是(5 3 1)(4 2)

把这些序列翻转后得到1 3 5 2 4

接下来的极大下降子序列是(1)(3)(5 2)(4)

翻转后是13 2 5 4

接下来的极大下降子序列是(1)(3 2)(5 4)

翻转后是12 3 4 5,满足要求

 

定义翻转一个子序列的费用为1(注意一轮翻转的费用可能大于1),那么上面的费用一共是2+1+2=5。

 

现在,给你一个排列,你要求出对这个排列排序的费用。

另外题目保证:第一次划分时,所有极大下降子序列的长度都是偶数

输入

第一行一个整数N

第二行表示N个数的排列

输出

所需费用。如果不能排序,输出-1

 

样例输入

4

3 1 4 2

样例输出

3

数据范围

对于10%的数据,N<=10

对于40%的数据,N<=3000

对于100%的数据,N<=100000

可以证明一定能排序,否则一定能进行交换。

由于,第一次划分时,所有极大下降子序列的长度都是偶数,没有单个点,故之后的解尽可能在递增序列接口,长度不超过2

(6 5) (2 1) (4 3)

 5 (6–1 ) 2–3 4 

如果有单个点

(7 6 1) 4 (5 3 2)

 1 6 (7 4 2) 3 5

并且第一轮翻转之后不会有长度>=3的极长下降子序列

于是问题变成了求逆序对的个数,归并排序或者树状数组解决

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<functional>
#include<algorithm>
using namespace std;
#define MAXN (100000+10)
#define INF (0xfffffff)
int n,a[MAXN];
long long ans=0;
int le[MAXN],re[MAXN];
int len(int l,int r)
{
    return r-l+1;
}
void mergesort(int l,int r)
{
    if (l>=r) return;
    int m=(l+r)>>1;
    mergesort(l,m);
    mergesort(m+1,r);   
    memcpy(le+1,a+l,sizeof(int)*(m-l+1));
    memcpy(re+1,a+m+1,sizeof(int)*(r-m));
    le[m-l+2]=re[r-m+1]=INF;
    int i=1,j=1;
    for (int k=l;k<=r;k++)
        if (le[i]<re[j])
        {
            a[k]=le[i];
            i++;
        } 
        else
        {
            a[k]=re[j];
            j++;
            ans+=m-l+1-(i-1);
        }   
}
int main()
{
    freopen("sort.in","r",stdin);
    freopen("sort.out","w",stdout);
    scanf("%d",&n);
    for (int i=1;i<=n;i++) 
    {
        scanf("%d",&a[i]);
    }
    int h=1;
    for (int i=1;i<n;i++)
    {
        if (a[i]<a[i+1])
        {
            if (h!=i)
            {
                ans++;
                for (int j=1;j<=(i-h+1)/2;j++) swap(a[(i+h)/2-j+( (i-h)%2  ) ],a[(i+h)/2+j]);
//              for (int k=1;k<=n;k++) cout<<a[k]<<' ';
//              cout<<endl;
            }
            h=i+1;
        }
    }   
    if (h!=n)
    {
        ans++;
        int i=n;
        for (int j=1;j<=(i-h+1)/2;j++) swap(a[(i+h)/2-j+( (i-h)%2  ) ],a[(i+h)/2+j]);
//      for (int k=1;k<=n;k++) cout<<a[k]<<' ';
//      cout<<endl;
    }   

    mergesort(1,n);

    cout<<ans<<endl;    
//  while (1);
    return 0;
}