output_description: 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}.
  
  * * *
input_description: 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
attempt: from bisect import bisect_right
  
  
  def det(p1, p2, p3):
      area = (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0])
      return area > 0
  
  
  def convex_hull(pts):
      pts = sorted(pts)
      n = len(pts)
      extsize = 0
      extpts = []
      for i in range(n):
          while extsize > 1:
              if det(extpts[-2], extpts[-1], pts[i]):
                  break
              extsize -= 1
              extpts.pop()
          extpts.append(pts[i])
          extsize += 1
      t = extsize
      for i in range(n - 1, -1, -1):
          while extsize > t:
              if det(extpts[-2], extpts[-1], pts[i]):
                  break
              extsize -= 1
              extpts.pop()
          extpts.append(pts[i])
          extsize += 1
      return extpts[:-1]
  
  
  n = int(input())
  aa = [int(x) for x in input().split()]
  bb = [int(x) for x in input().split()]
  
  ma = max(aa)
  ind = -1
  for i in range(n):
      if ma == aa[i]:
          ind = i
          break
  
  a = aa[i:] + aa[: i + 1]
  b = bb[i:] + bb[: i + 1]
  
  c = [0] * (n + 1)
  for i in range(2, n + 1):
      c[i] = 2 * (c[i - 1] + b[i - 1]) - c[i - 2]
  
  pts = []
  for i in range(n + 1):
      pts.append((i, a[i] - c[i]))
  
  f = [-(10**15)] * (n + 1)
  ext = []
  
  for i, val in convex_hull(pts):
      if val * n < (a[0] - c[0]) * (n - i) + (a[n] - c[n]) * i:
          continue
      f[i] = val
      ext.append(i)
  
  ext = sorted(ext)
  
  for i in range(n + 1):
      if f[i] == -(10**15):
          t = bisect_right(ext, i)
          l = ext[t - 1]
          r = ext[t]
          f[i] = f[l] + (i - l) * (f[r] - f[l]) / (r - l)
  
  
  ans = 0
  for i in range(1, n + 1):
      ans += f[i] + c[i]
  
  print(f"{ans/n:.12f}")
  
problem_description: 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.
samples: [{"input": "5\n    4 2 6 3 5\n    1 1 1 1 1", "output": "4.700000000000\n    \n\n* * *"}, {"input": "4\n    100 0 100 0\n    0 100 0 100", "output": "50.000000000000\n    \n\n* * *"}, {"input": "14\n    4839 5400 6231 5800 6001 5200 6350 7133 7986 8012 7537 7013 6477 5912\n    34 54 61 32 52 61 21 43 65 12 45 21 1 4", "output": "7047.142857142857\n    \n\n* * *"}, {"input": "10\n    470606482521 533212137322 116718867454 746976621474 457112271419 815899162072 641324977314 88281100571 9231169966 455007126951\n    26 83 30 59 100 88 84 91 54 61", "output": "815899161079.400024414062"}]