Problem:
Score : 800 points

Problem Statement

Niwango has N cards, numbered 1,2,\ldots,N.
He will now arrange these cards in a row.

Niwango wants to know if there is a way to arrange the cards while satisfying all the N conditions below.
To help him, determine whether such a way exists. If the answer is yes, also find the lexicographically smallest such arrangement.

To the immediate right of Card 1 (if any) is NOT Card a_1.

To the immediate right of Card 2 (if any) is NOT Card a_2.

\vdots

To the immediate right of Card N (if any) is NOT Card a_N.

Constraints

2 \leq N \leq 10^{5}

1 \leq a_i \leq N

a_i \neq i

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 \ldots a_N

Output

If no arrangements satisfy the conditions, print -1. If such arrangements exist, print the lexicographically smallest such arrangement, in the following format:

b_1 b_2 \ldots b_N

Here, b_i represents the i-th card from the left.

Sample Input 1

4
2 3 4 1

Sample Output 1

1 3 2 4

The arrangement (1,2,3,4) is lexicographically smaller than (1,3,2,4), but is invalid, since it violates the condition "to the immediate right of Card 1 is not Card 2."

Sample Input 2

2
2 1

Sample Output 2

-1

If no arrangements satisfy the conditions, print -1.

Sample Input 3

13
2 3 4 5 6 7 8 9 10 11 12 13 12

Sample Output 3

1 3 2 4 6 5 7 9 8 10 12 11 13

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
 
//#include <unistd.h>
//#include <iostream>
 
using namespace std;
 
#define DEBUG(x) cerr<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cerr<<#v<<":";for(int i=0;i<v.size();i++) cerr<<" "<<v[i]; cerr<<endl;
#define DEBUG_MAT(v) cerr<<#v<<endl;for(int i=0;i<v.size();i++){for(int j=0;j<v[i].size();j++) {cerr<<v[i][j]<<" ";}cerr<<endl;}
typedef long long ll;
#define int ll
 
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
template<class S, class T> pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first + t.first, s.second + t.second); }
template<class S, class T> pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first - t.first, s.second - t.second); }
template<class S, class T> ostream& operator<<(ostream& os, pair<S, T> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
#define X first
#define Y second
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(int i=(n);i>0;i--)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(),c.end()
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 (a>b) { a = b; return 1; } return 0; }
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = (ll)1e18 + 1;
const long double pi = 3.1415926535897932384626433832795028841971L;
#define Sp(p) cout<<setprecision(25)<< fixed<<p<<endl;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
#define fio() cin.tie(0); ios::sync_with_stdio(false);
const ll MOD = 1000000007;
//const ll MOD = 998244353;
// #define mp make_pair
//#define endl '\n'


void solve0(int n, vi a, vi hp) {
  int x;
  rep (i, n) {
    if (hp[i] == 0) {
      x = i;
      break;
    }
  }
  cout << x + 1 << " ";
  rep (i, n) {
    if (i == x) continue;
    cout << i + 1 << " ";
  }
  cout << endl;
}

signed main() {
  fio();

  int n;
  cin >> n;
  if (n == 2) {
    cout << -1 << endl;
    return 0;
  }
  vi a(n);
  vi hp(n, n - 1);
  bool zero = false;
  rep (i, n) {
    cin >> a[i];
    a[i]--;
    hp[a[i]]--;
    if (hp[a[i]] == 0) zero = true;
  }
  if (zero) {
    solve0(n, a, hp);
    return 0;
  }

  set<pii> hp_idx;
  rep (i, n) {
    hp_idx.insert(pii(hp[i], i));
  }
  int si = 1;
  vi ans;
  set<int> live;
  rep (i, n) live.insert(i);

  set<int> last;

  rep (i, n - 8) { 
    while (hp_idx.size() > 0) {
      pii temp = *hp_idx.begin();
      if (temp.first == si) {
        last.insert(temp.second);
        hp_idx.erase(hp_idx.begin());
      }
      else break;
    }

    int kon = -1;
    if (ans.size() > 0) {
      int x = ans.back();
      int yaba = a[x];
      for (auto itr = last.begin(); itr != last.end(); itr++) {
        if (*itr != yaba) {
          kon = *itr;
          break;
        }
      }
    }
    if (kon == -1) {
      if (ans.size() == 0) {
        kon = *live.begin();
      }
      else {
        int x = ans.back();
        int yaba = a[x];
        for (auto itr = live.begin(); itr != live.end(); itr++) {
          if (*itr != yaba) {
            kon = *itr;
            break;
          }
        }
      }
    }

    ans.push_back(kon);
    live.erase(kon);
    if (last.count(kon)) last.erase(kon);
    if (hp_idx.count(pii(hp[kon], kon))) {
      hp_idx.erase(pii(hp[kon], kon));
    }

    if (ans.size() >= 2) {
      int di = ans[ans.size() - 2];
      int right = a[di];
      if (hp_idx.count(pii(hp[right], right))) {
        hp_idx.erase(pii(hp[right], right));
        hp[right]++;
        hp_idx.insert(pii(hp[right], right));
      }
      si++;
    }
    //DEBUG_VEC(hp);
    //DEBUG_VEC(ans);
  }

  vi add;
  for (auto itr = live.begin(); itr != live.end(); itr++) {
    add.push_back(*itr);
  }

  //DEBUG_VEC(ans);
  do {
    //DEBUG_VEC(add);
    if (ans.size() > 0) {
      int x = ans.back();
      int yaba = a[x];
      if (yaba == add[0]) continue;
    }
    bool flag = true;
    rep (i, add.size() - 1) {
      int x = add[i];
      int yaba = a[x];
      if (yaba == add[i + 1]) {
        flag = false;
        break;
      }
    }
    if (flag) break;
  } while (next_permutation(all(add)));

  rep (i, add.size()) ans.push_back(add[i]);

  rep (i, n) {
    cout << ans[i] + 1 << " ";
  }
  cout << endl;
}