Problem:
Reverse Sort

1 ∼ NまでのN個の数字の順列A1, A2, ……, ANが与えられる。
この順列に対して区間[i, j](1 ≤ i ≤ j ≤ N)の数字の順序を逆順にする操作reverse(i, j)を行うことが出来る。
例えば、[1, 2, 3, 4, 5]に対してreverse(2, 4)を適用すると[1, 4, 3, 2, 5]となる。
最小で何回の操作を行えば順列を昇順にソートされた状態にすることが出来るか計算せよ。

Input

入力は以下の形式で与えられる。

N
A1 A2 …… AN

Constraints

Nは整数である

2 ≤ N ≤ 10

Output

問題の解を1行に出力せよ。

Sample Input 1

5
1 4 3 5 2

Output for the Sample Input 1

2

reverse(4,5):1 4 3 2 5

reverse(2,4):1 2 3 4 5

のようにすればよい。

Sample Input 2

5
3 1 5 2 4

Output for the Sample Input 2

4

例えば

reverse(1,2):1 3 5 2 4

reverse(3,5):1 3 4 2 5

reverse(2,4):1 2 4 3 5

reverse(3,4):1 2 3 4 5

のようにすればよい。

Sample Input 3

3
1 2 3

Output for the Sample Input 3

0

Sample Input 4

10
3 1 5 2 7 4 9 6 10 8

Output for the Sample Input 4

9

Solution in C++11 (judge verdict: Memory Limit Exceeded)

#include<iostream>
#include<vector>
#include<map>
#include<queue>
#include<algorithm>
#include<cstdlib>
 
using namespace std;
 
struct S{
  vector<int> v;
  int c,d,e;
  S(const vector<int> &pv,int pc):v(pv),c(pc){
    eval();
  }
  void eval(){
    d=0;
    for(int i=0;i<v.size()-1;i++){
      d+=abs(v[i]-v[i+1])>1;
    }
    e=c+(d+1)/2;
  }   
  void reverse(int a,int b){
    c++;
    std::reverse(begin(v)+a,begin(v)+b+1);
    eval();
  }
  bool operator<(const S &s)const{
    return e>s.e;
  }
};
 
int main(){
  int N;
  cin>>N;
  vector<int> v(N);
  for(auto &e:v){
    cin>>e;
  }
  S is(v,0);
  priority_queue<S> que;
  que.push(is);
  map<vector<int>,int> m;
  for(;;){
    S c=que.top();
    if(is_sorted(begin(c.v),end(c.v)))break;
    que.pop();
    if(m.count(c.v)&&m[c.v]<=c.c)continue;
    m[c.v]=c.c;
    for(int i=0;i<N;i++){
      for(int j=i+1;j<N;j++){
	S n=c;
	n.reverse(i,j);
	que.push(n);
      }
    }
  }
  cout<<que.top().c<<endl;
}