//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }

class UnionFind{
public:
    vector<ll> parent; //parent[i]はiの親
    vector<ll> siz; //素集合のサイズを表す配列(1で初期化)
    map<ll,vector<ll>> group; //集合ごとに管理する(key:集合の代表元、value:集合の要素の配列)
    ll n; //要素数

    //コンストラクタ
    UnionFind(ll n_):n(n_),parent(n_),siz(n_,1){
        //全ての要素の根が自身であるとして初期化
        for(ll i=0;i<n;i++){parent[i]=i;}
    }

    //データxの属する木の根を取得(経路圧縮も行う)
    ll root(ll x){
        if(parent[x]==x) return x;
        return parent[x]=root(parent[x]);//代入式の値は代入した変数の値なので、経路圧縮できる
    }

    //xとyの木を併合
    void unite(ll x,ll y){
        ll rx=root(x);//xの根
        ll ry=root(y);//yの根
        if(rx==ry) return;//同じ木にある時
        //小さい集合を大きい集合へと併合(ry→rxへ併合)
        if(siz[rx]<siz[ry]) swap(rx,ry);
        siz[rx]+=siz[ry];
        parent[ry]=rx;//xとyが同じ木にない時はyの根ryをxの根rxにつける
    }

    //xとyが属する木が同じかを判定
    bool same(ll x,ll y){
        ll rx=root(x);
        ll ry=root(y);
        return rx==ry;
    }

    //xの素集合のサイズを取得
    ll size(ll x){
        return siz[root(x)];
    }

    //素集合をそれぞれグループ化
    void grouping(){
        //経路圧縮を先に行う
        rep(i,n)root(i);
        //mapで管理する(デフォルト構築を利用)
        rep(i,n)group[parent[i]].push_back(i);
    }

    //素集合系を削除して初期化
    void clear(){
        rep(i,n){parent[i]=i;}
        siz=vector<ll>(n,1);
        group.clear();
    }
};
int main() {
    ll N; cin>>N;
    vector<ll> A(N), B(N);
    rep(i, N){
        cin>>A[i];
        B[i] = A[i];
    }

    reverse(B.begin(), B.end());


    ll res = 0;
    UnionFind uf(2e5+1);
    rep(i, N){
        if(!uf.same(A[i], B[i])){
            res++;
            uf.unite(A[i], B[i]);
        }
    }
    cout << res << endl;
}
#include <bits/stdc++.h>
using namespace std;

struct UnionFind {
  vector<int> par, size;

  UnionFind(int n) : par(n), size(n) {
    for(int i = 0; i < n; i++) {
      par[i] = i;
      size[i] = 1;
    }
  }

  int root(int x) {
    return par[x] == x ? x : par[x] = root(par[x]);
  }

  bool unite(int x, int y) {
    int rx = root(x);
    int ry = root(y);
    if(rx == ry) return false;

    if(size[rx] > size[ry]) {
      par[ry] = rx;
      size[rx] += size[ry];
    } else {
      par[rx] = ry;
      size[ry] += size[rx];
    }
    return true;
  }

  bool same(int x, int y) {
    return root(x) == root(y);
  }

  int tree_size(int x) {
    return size[root(x)];
  }
};

void milkshake() {
  int n, m = 0;
  cin >> n;
  vector<int> a(n);
  for(auto &x : a) {
    cin >> x;
    m = max(m, x);
    x--;
  }

  UnionFind tree(m);
  for(int i = 0; i < n/2; i++) {
    tree.unite(a[i], a[n - 1 - i]);
  }

  int ans = 0;
  for(int i = 0; i < m; i++) {
    if(tree.par[i] == i)
      ans += tree.tree_size(i) - 1;
  }
  cout << ans << '\n';
}

signed main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int tt=1;
  while(tt--) milkshake();
  return 0;
}

