using System;
using System.Linq;
using System.Collections.Generic;

using SyrupBeans.Competitive.Combinatorics;

using E = System.Linq.Enumerable;

public class Program
{
    public static void Main()
    {
        var n = int.Parse(Console.ReadLine());
        var towns = new Tuple<int, int>[n];
        for (int i = 0; i < towns.Length; ++i)
        {
            var xy = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            towns[i] = Tuple.Create(xy[0], xy[1]);
        }

        var distances = new double[towns.Length][];
        for (int i = 0; i < distances.Length; ++i)
        {
            distances[i] = new double[towns.Length];
            for (int j = 0; j < distances[i].Length; ++j)
            {
                var dx = Math.Abs(towns[i].Item1 - towns[j].Item1);
                var dy = Math.Abs(towns[i].Item2 - towns[j].Item2);
                distances[i][j] = Math.Sqrt(dx * dx + dy * dy);
            }
        }

        var m = 1;
        for (int i = 1; i < n; ++i)
        {
            m *= i + 1;
        }

        var sum = 0d;
        var order = E.Range(0, towns.Length).ToArray();
        do
        {
            for (int i = 1; i < distances.Length; ++i)
            {
                sum += distances[order[i - 1]][order[i]];
            }
        } while (Permutation.NextPermutation(order));

        Console.WriteLine((sum / m).ToString("F10"));
    }
}

namespace SyrupBeans.Competitive.Combinatorics
{
    using System;
    using System.Collections.Generic;
    using System.Linq;

    public class Permutation
    {
        public static IEnumerable<T[]> Permutate<T>(IEnumerable<T> elements, int length)
        where T : IComparable<T>
        {
            var set = new SortedSet<T>(elements);
            if (length < 0 || set.Count < length)
            {
                throw new ArgumentOutOfRangeException(nameof (length));
            }

            if (length == 0)
            {
                yield return Array.Empty<T>();
                yield break;
            }

            var xs = new List<T>(length);
            var nextSibling = new Stack<int>(length);
            int i = 0;
            while (i < set.Count)
            {
                var x = set.ElementAt(i);
                xs.Add(x);
                set.Remove(x);
                nextSibling.Push(i + 1);
                i = 0;
                if (xs.Count < length)
                {
                    continue;
                }
                yield return xs.ToArray();
                do
                {
                    i = nextSibling.Pop();
                    set.Add(xs.Last());
                    xs.RemoveAt(xs.Count - 1);
                } while (i >= set.Count && nextSibling.Any());
            }
        }

        public static bool NextPermutation<T>(T[] xs) where T : IComparable<T> => NeighborPermutation(xs, 1);

        public static bool PrevPermutation<T>(T[] xs) where T : IComparable<T> => NeighborPermutation(xs, -1);

        private static bool NeighborPermutation<T>(T[] xs, int sign)
        where T : IComparable<T>
        {
            int l = xs.Length - 1;
            while (l > 0 && xs[l].CompareTo(xs[l - 1]) * sign < 0)
            {
                --l;
            }
            if (l < 0)
            {
                return false;
            }
            Array.Reverse(xs, l, xs.Length - l);
            if (l < 1)
            {
                return false;
            }
            
            int r = l;
            while (xs[r].CompareTo(xs[l - 1]) * sign < 0)
            {
                ++r;
            }
            T t = xs[l - 1];
            xs[l - 1] = xs[r];
            xs[r] = t;
            return true;
        }
    }
}


Measured memory_bytes: 13396