n = int(eval(input()))



import itertools



arr = []



for i in range(n):

    arr.append(list(map(int,input().split())))





ptr = list(itertools.permutations(arr, n))





dis = 0



for i in range(len(ptr)):

    for j in range(n-1):

        dis +=((ptr[i][j][1]-ptr[i][j+1][1]) **2 + (ptr[i][j][0]-ptr[i][j+1][0])**2)**0.5

        

print((dis/len(ptr)))





    
import sys

sys.setrecursionlimit(10**6)

from math import floor,ceil,sqrt,factorial,log

from heapq import heappop, heappush, heappushpop

from collections import Counter,defaultdict,deque

from itertools import accumulate,permutations,combinations,product,combinations_with_replacement

from bisect import bisect_left,bisect_right

from copy import deepcopy

from operator import itemgetter

from fractions import gcd

mod = 10 ** 9 + 7

inf = float('inf')

ninf = -float('inf')

 

#整数input

def ii(): return int(sys.stdin.readline().rstrip()) #int(input())

def mii(): return list(map(int,sys.stdin.readline().rstrip().split()))

def limii(): return list(mii()) #list(map(int,input().split()))

def lin(n:int): return [ii() for _ in range(n)]

def llint(n: int): return [limii() for _ in range(n)]

#文字列input

def ss(): return sys.stdin.readline().rstrip() #input()

def mss(): return sys.stdin.readline().rstrip().split()

def limss(): return list(mss()) #list(input().split())

def lst(n:int): return [ss() for _ in range(n)]

def llstr(n: int): return [limss() for _ in range(n)]



#本当に貪欲法か？ DP法では？？

#本当に貪欲法か？ DP法では？？

#本当に貪欲法か？ DP法では？？



n=ii()

arr=llint(n)

ans=0

cnt=0



for i in permutations(list(range(n))):

    cnt+=1

    for j in range(n-1):

        ans+=((arr[i[j]][0]-arr[i[j+1]][0])**2 + (arr[i[j]][1]-arr[i[j+1]][1])**2)**0.5



print((ans/cnt))
n = int(eval(input()))
import itertools

arr = []
for i in range(n):
    arr.append(list(map(int, input().split())))
ptr = list(itertools.permutations(arr, n))
dis = 0
for i in range(len(ptr)):
    for j in range(n - 1):
        dis += (
            (ptr[i][j][1] - ptr[i][j + 1][1]) ** 2
            + (ptr[i][j][0] - ptr[i][j + 1][0]) ** 2
        ) ** 0.5
print((dis / len(ptr)))

import sys

sys.setrecursionlimit(10**6)
from math import floor, ceil, sqrt, factorial, log
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import (
    accumulate,
    permutations,
    combinations,
    product,
    combinations_with_replacement,
)
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd

mod = 10**9 + 7
inf = float("inf")
ninf = -float("inf")
# 整数input
def ii():
    return int(sys.stdin.readline().rstrip())  # int(input())


def mii():
    return list(map(int, sys.stdin.readline().rstrip().split()))


def limii():
    return list(mii())  # list(map(int,input().split()))


def lin(n: int):
    return [ii() for _ in range(n)]


def llint(n: int):
    return [limii() for _ in range(n)]


# 文字列input
def ss():
    return sys.stdin.readline().rstrip()  # input()


def mss():
    return sys.stdin.readline().rstrip().split()


def limss():
    return list(mss())  # list(input().split())


def lst(n: int):
    return [ss() for _ in range(n)]


def llstr(n: int):
    return [limss() for _ in range(n)]


# 本当に貪欲法か？ DP法では？？
# 本当に貪欲法か？ DP法では？？
# 本当に貪欲法か？ DP法では？？
n = ii()
arr = llint(n)
ans = 0
cnt = 0
for i in permutations(list(range(n))):
    cnt += 1
    for j in range(n - 1):
        ans += (
            (arr[i[j]][0] - arr[i[j + 1]][0]) ** 2
            + (arr[i[j]][1] - arr[i[j + 1]][1]) ** 2
        ) ** 0.5
print((ans / cnt))

-n = int(eval(input())) -import itertools +import sys -arr = [] -for i in range(n): -    arr.append(list(map(int, input().split()))) -ptr = list(itertools.permutations(arr, n)) -dis = 0 -for i in range(len(ptr)): +sys.setrecursionlimit(10**6) +from math import floor, ceil, sqrt, factorial, log +from heapq import heappop, heappush, heappushpop +from collections import Counter, defaultdict, deque +from itertools import ( +    accumulate, +    permutations, +    combinations, +    product, +    combinations_with_replacement, +) +from bisect import bisect_left, bisect_right +from copy import deepcopy +from operator import itemgetter +from fractions import gcd + +mod = 10**9 + 7 +inf = float("inf") +ninf = -float("inf") +# 整数input +def ii(): +    return int(sys.stdin.readline().rstrip())  # int(input()) + + +def mii(): +    return list(map(int, sys.stdin.readline().rstrip().split())) + + +def limii(): +    return list(mii())  # list(map(int,input().split())) + + +def lin(n: int): +    return [ii() for _ in range(n)] + + +def llint(n: int): +    return [limii() for _ in range(n)] + + +# 文字列input +def ss(): +    return sys.stdin.readline().rstrip()  # input() + + +def mss(): +    return sys.stdin.readline().rstrip().split() + + +def limss(): +    return list(mss())  # list(input().split()) + + +def lst(n: int): +    return [ss() for _ in range(n)] + + +def llstr(n: int): +    return [limss() for _ in range(n)] + + +# 本当に貪欲法か？ DP法では？？ +# 本当に貪欲法か？ DP法では？？ +# 本当に貪欲法か？ DP法では？？ +n = ii() +arr = llint(n) +ans = 0 +cnt = 0 +for i in permutations(list(range(n))): +    cnt += 1 -        dis += ( -            (ptr[i][j][1] - ptr[i][j + 1][1]) ** 2 -            + (ptr[i][j][0] - ptr[i][j + 1][0]) ** 2 +        ans += ( +            (arr[i[j]][0] - arr[i[j + 1]][0]) ** 2 +            + (arr[i[j]][1] - arr[i[j + 1]][1]) ** 2 -print((dis / len(ptr))) +print((ans / cnt))