#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

vector<int> find_factions(int N);

namespace {

constexpr int kMaxQueries = 30000;

double score_multiplier(int num_queries) {
  if (num_queries <= 32) {
    return 1.0;
  }
  if (num_queries <= 48) {
    return 0.96 + (48 - num_queries) * 0.04 / 16;
  }
  if (num_queries <= 77) {
    return 0.74 + (77 - num_queries) * 0.22 / 29;
  }
  if (num_queries <= 2000) {
    return 0.27 + std::log2(2000.0 / num_queries) * 0.100021329;
  }
  return log(1.0 * kMaxQueries / num_queries) * 0.069108667;
}

int N;
int num_queries = 0;
vector<int> factions;
int num_parts;
vector<vector<int>> parts;

void build_parts() {
  num_parts = 0;
  for (int i = 0; i < N; ++i)
    num_parts = max(num_parts, factions[i] + 1);
  parts = vector<vector<int>>(num_parts);
  for (int i = 0; i < N; ++i) {
    parts[factions[i]].push_back(i);
  }
}

vector<bool> query(const vector<int> &Q) {
  vector<bool> ans(N);
  vector<int> cnt(N);
  for (int i = 0; i < num_parts; ++i) {
    for (int x : parts[i]) {
      cnt[Q[x]]++;
    }
    for (int x : parts[i]) {
      if (cnt[Q[x]] == 1)
        ans[x] = 1;
    }
    for (int x : parts[i]) {
      cnt[Q[x]]--;
    }
  }
  return ans;
}

bool equal_factions(const vector<int> &Q) {
  vector<bool> used(num_parts);
  for (int i = 0; i < num_parts; ++i) {
    for (int x : parts[i]) {
      if (Q[x] != Q[parts[i][0]])
        return false;
    }
    if (used[Q[parts[i][0]]])
      return false;
    used[Q[parts[i][0]]] = 1;
  }
  return true;
}

void fail(string msg) {
  cerr << msg << endl;
  exit(0);
}

vector<int> coordinate_compress(const vector<int> &data) {
  map<int, int> cm;
  int ct = 0;
  vector<int> ans = data;
  for (int &x : ans) {
    if (!cm.count(x))
      cm[x] = ct++;
    x = cm[x];
  }
  return ans;
}
} // namespace

vector<bool> organize_banquet(const vector<int> &Q) {
  num_queries++;
  if (num_queries > kMaxQueries) {
    fail("Too many queries.");
  }
  if ((int)Q.size() != N) {
    fail("Invalid query.");
  }
  return query(coordinate_compress(Q));
}

int main() {
  cin >> N;
  factions = vector<int>(N);
  for (int i = 0; i < N; ++i)
    cin >> factions[i];
  factions = coordinate_compress(factions);
  build_parts();
  vector<int> factions2 = coordinate_compress(find_factions(N));
  if ((int)factions2.size() != N) {
    fail("Wrong factions.");
  }
  for (int f : factions2) {
    if (f < 0 || f >= num_parts)
      fail("Wrong factions.");
  }
  if (equal_factions(factions2)) {
    cout << score_multiplier(num_queries) << endl;
    cerr << "OK " << num_queries << " queries." << endl;
  } else {
    fail("Wrong factions.");
  }
}