#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const int N = 1 << 11;
const db INF = 1e47;

template<typename T>
void updMin(T& a, T b)
{
	a = min(a, b);
}

db dist(const PII& a, const PII& b)
{
	return hypot(b.F - a.F, b.S - a.S);
}

vector<vector<tuple<db, int, int>>> matr[N];
vector<PII> pts[N];
VI globalIndices[N];

void solve(int v, bool hor)
{
	int n = SZ(pts[v]);
	matr[v] = vector(n, vector<tuple<db, int, int>>(n, {INF, -1, -1}));
	if (n == 1)
	{
		matr[v][0][0] = {0, 0, 0};
		return;
	}
	VI sortedIndices(n);
	iota(ALL(sortedIndices), 0);
	sort(ALL(sortedIndices), [&](int i, int j)
	{
		return hor ? pts[v][i].S < pts[v][j].S : pts[v][i].F < pts[v][j].F;
	});
	globalIndices[v] = sortedIndices;
	int szL = n / 2, szR = n - szL;
	int leftV = 2 * v + 1, rightV = 2 * v + 2;
	pts[leftV].resize(szL);
	pts[rightV].resize(szR);
	FOR(i, 0, szL)
		pts[leftV][i] = pts[v][sortedIndices[i]];
	FOR(i, 0, szR)
		pts[rightV][i] = pts[v][sortedIndices[i + szL]];
	solve(leftV, hor ^ 1);
	solve(rightV, hor ^ 1);
	FOR(a, 0, szL)
	{
		int aa = sortedIndices[a];
		FOR(c, 0, szR)
		{
			int cc = sortedIndices[c + szL];
			db minAC = INF;
			int bestB = -1;
			FOR(b, 0, szL)
			{
				int bb = sortedIndices[b];
				db cur = get<0>(matr[leftV][a][b]) + dist(pts[v][bb], pts[v][cc]);
				if (cur < minAC)
				{
					minAC = cur;
					bestB = b;
				}
			}
			FOR(d, 0, szR)
			{
				int dd = sortedIndices[d + szL];
				db cur = minAC + get<0>(matr[rightV][c][d]);
				if (cur < get<0>(matr[v][aa][dd]))
				{
					matr[v][aa][dd] = {cur, bestB, c};
				}
			}
		}
	}
	FOR(i, 0, n)
		FOR(j, 0, n)
		{
			auto [d, b, c] = matr[v][i][j];
			updMin(matr[v][j][i], make_tuple(d, c, b));
		}
}

vector<PII> answer;

void restore(int v, int a, int d)
{
	int n = SZ(pts[v]);
	if (SZ(pts[v]) == 1)
	{
		answer.PB(pts[v][0]);
		return;
	}
	auto [dis, b, c] = matr[v][a][d];
	a = find(ALL(globalIndices[v]), a) - globalIndices[v].begin();
	d = find(ALL(globalIndices[v]), d) - globalIndices[v].begin();
	int szL = n / 2;
	assert((a < szL) ^ (d < szL));
	if (a < szL)
	{
		restore(2 * v + 1, a, b);
		restore(2 * v + 2, c, d - szL);
	}
	else
	{
		restore(2 * v + 2, a - szL, b);
		restore(2 * v + 1, c, d);
	}
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout << fixed << setprecision(10);
	int n;
	cin >> n;
	pts[0].resize(n);
	for (auto& [x, y] : pts[0])
		cin >> x >> y;
	solve(0, false);
	db ans = INF;
	int a = -1, d = -1;
	FOR(i, 0, n)
		FOR(j, 0, n)
			if (get<0>(matr[0][i][j]) < ans)
			{
				ans = get<0>(matr[0][i][j]);
				a = i;
				d = j;
			}
	map<PII, int> mp;
	FOR(i, 0, n)
		mp[pts[0][i]] = i;
	restore(0, a, d);
	assert(SZ(answer) == n);
	cout << ans << "\n";
	db check = 0;
	FOR(i, 0, n)
	{
		if (i > 0)
		{
			cout << " ";
			check += dist(answer[i - 1], answer[i]);
		}
		cout << mp[answer[i]] + 1;
	}
	cout << "\n";
	cerr << check << endl;
	return 0;
}