翻转排序(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;
}