Problem:
Score : 1300 points

Problem Statement

You are playing a game and your goal is to maximize your expected gain.
At the beginning of the game, a pawn is put, uniformly at random, at a position p\in\{1,2,\dots, N\}. The N positions are arranged on a circle (so that 1 is between N and 2).

The game consists of turns. At each turn you can either end the game, and get A_p dollars (where p is the current position of the pawn), or pay B_p dollar to keep playing.
If you decide to keep playing, the pawn is randomly moved to one of the two adjacent positions p-1, p+1 (with the identifications 0 = N and N+1=1).

What is the expected gain of an optimal strategy?

Note: The "expected gain of an optimal strategy" shall be defined as the supremum of the expected gain among all strategies such that the game ends in a finite number of turns.

Constraints

2 \le N \le 200,000

0 \le A_p \le 10^{12} for any p = 1,\ldots, N

0 \le B_p \le 100 for any p = 1, \ldots, N

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Output

Print a single real number, the expected gain of an optimal strategy.
Your answer will be considered correct if its relative or absolute error does not exceed 10^{-10}.

Sample Input 1

5
4 2 6 3 5
1 1 1 1 1

Sample Output 1

4.700000000000

Sample Input 2

4
100 0 100 0
0 100 0 100

Sample Output 2

50.000000000000

Sample Input 3

14
4839 5400 6231 5800 6001 5200 6350 7133 7986 8012 7537 7013 6477 5912
34 54 61 32 52 61 21 43 65 12 45 21 1 4

Sample Output 3

7047.142857142857

Sample Input 4

10
470606482521 533212137322 116718867454 746976621474 457112271419 815899162072 641324977314 88281100571 9231169966 455007126951
26 83 30 59 100 88 84 91 54 61

Sample Output 4

815899161079.400024414062

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

/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author
 */

#include <iostream>
#include <fstream>

#include <bits/stdc++.h>

#define pb push_back
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(),(v).end()
#define mp make_pair

using namespace std;

typedef long long int64;
typedef vector<int> vi;
typedef pair<int, int> ii;

class TaskE {
 public:
  int n;
  vector<int64> a;
  vector<int64> b;
  vector<int64> b0;
  vector<int64> b1;
  vector<int64> b2;

  int64 score(int left, int right) {
    int n = right - left - 1;
    assert(n >= 0);
    int64 res = a[right] * 2;
    res += n * (a[left] + a[right]);
    int o = n + left + 1;
    res -= (-(b2[right] - b2[left + 1]) + (b1[right] - b1[left + 1]) * (o + left) - (b0[right] - b0[left + 1]) * left * o) * 2;
    return res;
  }

  void solveOne(istream &in, ostream &out) {
    in >> n;
    a = vector<int64>(2 * n);
    b = vector<int64>(2 * n);
    vector<pair<int64, int>> items(n);
    for (int i = 0; i < n; ++i) {
      in >> a[i];
      a[i + n] = a[i];
      items[i].first = a[i];
      items[i].second = i;
    }
    for (int i = 0; i < n; ++i) {
      in >> b[i];
      b[i + n] = b[i];
    }
    b0.resize(b.size() + 1);
    b1.resize(b.size() + 1);
    b2.resize(b.size() + 1);
    for (int i = 0; i < b.size(); ++i) {
      b0[i + 1] = b0[i] + b[i];
      b1[i + 1] = b1[i] + b[i] * i;
      b2[i + 1] = b2[i] + b[i] * i * i;
    }
    sort(all(items), [](const auto& p, const auto& q) {
      return p.first > q.first;
    });
    set<int> taken;
    int64 res = 0;
    for (const auto& p : items) {
      int at = p.second;
      if (taken.empty()) {
        taken.insert(at);
        res += score(at, at + n);
      } else {
        auto it = taken.lower_bound(at);
        int next;
        int prev;
        int we = at;
        if (it == taken.end()) {
          next = *taken.begin() + n;
        } else {
          next = *it;
        }
        if (it == taken.begin()) {
          prev = *taken.rbegin() - n;
          prev += n;
          we += n;
          next += n;
        } else {
          --it;
          prev = *it;
        }
        int64 delta = -score(prev, next) + score(prev, we) + score(we, next);
        if (delta > 0) {
          res += delta;
          taken.insert(at);
        }
      }
    }
    out << res / (double) (2 * n) << "\n";
  }

  void solve(std::istream &in, std::ostream &out) {
    out.precision(30);
    int nt = 1;
    for (int it = 0; it < nt; ++it) {
      solveOne(in, out);
    }
  }
};


int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  TaskE solver;
  std::istream& in(std::cin);
  std::ostream& out(std::cout);
  solver.solve(in, out);
  return 0;
}