#include <stdio.h>

#include <string.h>

#include <math.h>

#include <algorithm>

#include <iostream>

#include <time.h>

#include <vector>

#include <queue>

typedef long long LL;

using namespace std;

const int N = ;

const double eps = 1e-;

const int INF = 0x3f3f3f3f;

const int mod = ;

const double PI = *atan(1.0);

struct point

{

    double x, y;

}p[N];

double Dist(point p1, point p2)

{

    return sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));

}

int n;

double dp[N][N];///表示以j为起点，1为拐点，i为终点，经历所有i到j之间的点;

/*

double DP()

{

    dp[1][1] = 0;

    dp[2][1] = Dist(p[1], p[2]);

    for(int i=3; i<=n; i++)

    {

        for(int j=1; j<i-1; j++)

            dp[i][j] = dp[i-1][j] + Dist(p[i-1],p[i]);

        double Min = INF;

        for(int k=1; k<i-1; k++)

            Min = min(Min, dp[i-1][k] + Dist(p[k], p[i]));

        dp[i][i-1] = Min;

    }

    dp[n][n] = dp[n][n-1] + Dist(p[n-1], p[n]);

    return dp[n][n];

}*/

double DFS(int s, int e)

{

    if(dp[s][e] != )

        return dp[s][e];

    if(s < e-)

        dp[s][e] = DFS(s, e-) + Dist(p[e-], p[e]);

    else

    {

        double Min = INF;

        for(int i=; i<e-; i++)

            Min = min(Min, DFS(i, s) + Dist(p[i], p[e]));

        dp[s][e] = Min;

    }

    return dp[s][e];

}

int main()

{

    while(scanf("%d", &n) != EOF)

    {

        memset(dp, , sizeof(dp));

        for(int i=; i<=n; i++)

            scanf("%lf %lf", &p[i].x, &p[i].y);

        ///double ans = DP();

        dp[][] = ;

        dp[][] = dp[][] = Dist(p[], p[]);

        DFS(n-, n);

        dp[n][n] = dp[n-][n] + Dist(p[n-], p[n]);

        printf("%.2f\n", dp[n][n]);

    }

    return ;

}