#include <bits/stdc++.h>
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
	*this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define double long double

void monte(int n, int start) {
	int T = 1000000;
	vector<double> ev(n + 1);
	for(int test = 1; test <= T; ++test) {
		int cur = 1 + rand() % (n - 1);
		while(0 < cur && cur < n) {
			ev[cur]++;
			if(rand() % 2) {
				cur++;
			}
			else {
				cur--;
			}
		}
	}
	for(int i = 0; i <= n; ++i) cout << ev[i] / T << " ";
	cout << endl;
}

int main() {
	// monte(10, 3);
	int n;
	scanf("%d", &n);
	vector<pair<long long,int>> a(n);
	int where_big = 0;
	for(int i = 0; i < n; ++i) {
		scanf("%lld", &a[i].first);
		if(a[i].first > a[where_big].first) {
			where_big = i;
		}
	}
	for(int i = 0; i < n; ++i) {
		scanf("%d", &a[i].second);
	}
	vector<pair<long long, int>> tmp;
	for(int i = where_big; i < n; ++i) {
		tmp.push_back(a[i]);
	}
	for(int i = 0; i < where_big; ++i) {
		tmp.push_back(a[i]);
	}
	tmp.push_back(a[where_big]);
	a = tmp;
	debug() << imie(a);
	vector<bool> stop(n + 1);
	stop[0] = stop[n] = true;
	
	//  EV[i] = 1/N * (i * EV[N] + (N-i) * EV[0] + 2*i*(N-i)*cost[i] + linearly smaller)
	// 3 * 7 * (1 + 1/(N-1)) / N
	
	vector<double> pref0(n + 1), pref1(n + 1), pref2(n + 1);
	for(int i = 1; i <= n; ++i) {
		pref0[i] = pref0[i-1] + a[i].second;
		pref1[i] = pref1[i-1] + (double) i * a[i].second;
		pref2[i] = pref2[i-1] + (double) i * i * a[i].second;
	}
	
	auto get_sum_of_linear = [&](int L, int R) {
		double total = pref1[R-1] - pref1[L] - L * (pref0[R-1] - pref0[L]);
		// for(int i = 1; i < R - L; ++i) {
			// total += (double) (L+i) * a[L+i].second;
		// }
		return total;
	};
	auto get_sum_of_squares = [&](int L, int R) {
		double total = pref2[R-1] - pref2[L]; // - (L-1) * (
		total -= (double) L * L * (pref0[R-1] - pref0[L]);
		// total -= (double) L * 2 * (pref1[R-1] - pref1[L]);
		total -= L * 2 * get_sum_of_linear(L, R);
		// for(int i = 1; i < R - L; ++i) {
			// total -= (double) L * 2 * i * a[L+i].second;
		// }
		return total;
	};
	
	auto get_interval = [&](int L, int R) {
		assert(L < R);
		// if(L > R) {
			// return (double) 0;
		// }
		int N = R - L;
		assert(N > 0);
		double if_inside = 0;
		if(N >= 2) {
			// for(int i = 1; i < N; ++i) {
				// if_inside += (double) i * (N) * a[L+i].second;
			// }
			if_inside += get_sum_of_linear(L, R) * N;
			if_inside -= get_sum_of_squares(L, R);
			double c = (1 + 1. / (N - 1)) / N;
			if_inside *= c;
		}
		debug() << imie(L) imie(R) imie(if_inside);
		// if_inside *= (1 + 1. / (N - 1)) / N;
		double p_inside = (double) (N - 1) / n;
		return p_inside * (-if_inside + (a[L].first + a[R].first) / 2.0);

	};
	
	vector<int> stos{0};
	for(int C = 1; C <= n; ++C) {
		while((int) stos.size() >= 2) {
			int A = stos.end()[-2];
			int B = stos.end()[-1];
			double improvement = get_interval(A, C) - get_interval(A, B) - get_interval(B, C) - (double) a[B].first / n;
			if(improvement > 0) {
				stos.pop_back();
			}
			else {
				break;
			}
		}
		stos.push_back(C);
	}
	debug() << imie(stos);
	double an = 0;
	for(int i = 0; i < (int) stos.size() - 1; ++i) {
		int L = stos[i];
		int R = stos[i+1];
		an += (double) a[L].first / n + get_interval(L, R);
	}
	printf("%.10Lf\n", an);
}



Measured memory_bytes: 20564