#include "bits/stdc++.h"

using namespace std;

#define ld long double

long double kek(const pair<int, int>& x, const pair<int, int>& y) {
    return sqrtl((long double) (x.first - y.first) * 1ll * (x.first - y.first) +
                 (x.second - y.second) * 1ll * (x.second - y.second));
}

bool equal(long double x, long double y) {
    return abs(x - y) < 1e-9;
}

vector<ld> solve(vector<pair<int, int>> a, vector<ld> dp) {
    const int n = (int) a.size();
    if (n == 1) {
        return dp;
    }
    map<pair<int, int>, int> id;
    for (int i = 0; i < n; i++) {
        id[a[i]] = i;
    }
    std::sort(a.begin(), a.end());
    const int m = n / 2;
    vector<pair<int, int>> L, R;
    vector<ld> dpl, dpr;
    for (int i = 0; i < n; i++) {
        (i < m ? L : R).push_back({a[i].second, a[i].first});
        (i < m ? dpl : dpr).push_back(dp[id[a[i]]]);
    }
    vector<ld> res(n);
    {
        auto resl = solve(L, dpl);
        vector<ld> dpr2(dpr.size(), 1e18);
        for (int i = m; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dpr2[i - m] = min(dpr2[i - m], resl[j] + kek(a[i], a[j]));
            }
        }
        auto resr = solve(R, dpr2);
        for (int i = m; i < n; i++) {
            res[i] = resr[i - m];
        }
    }
    {
        auto resr = solve(R, dpr);
        vector<ld> dpr2(dpl.size(), 1e18);
        for (int i = m; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dpr2[j] = min(dpr2[j], resr[i - m] + kek(a[i], a[j]));
            }
        }
        auto resl = solve(L, dpr2);
        for (int i = 0; i < m; i++) {
            res[i] = resl[i];
        }
    }
    vector<ld> result = res;
    for (int i = 0; i < n; i++) {
        result[id[a[i]]] = res[i];
    }
    return result;
}

vector<int> restore(vector<pair<int, int>> a, vector<ld> dp, int mx) {
    const int n = (int) a.size();
    if (n == 1) {
        return vector<int>{0};
    }
    map<pair<int, int>, int> id;
    for (int i = 0; i < n; i++) {
        id[a[i]] = i;
    }
    auto p = a[mx];
    std::sort(a.begin(), a.end());
    for (int i = 0; i < n; i++) {
        if (a[i] == p) {
            mx = i;
        }
    }
    const int m = n / 2;
    vector<pair<int, int>> L, R;
    vector<ld> dpl, dpr;
    for (int i = 0; i < n; i++) {
        (i < m ? L : R).push_back({a[i].second, a[i].first});
        (i < m ? dpl : dpr).push_back(dp[id[a[i]]]);
    }
    if (mx >= m) {
        auto resl = solve(L, dpl);
        vector<ld> dpr2(dpr.size(), 1e18);
        for (int i = m; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dpr2[i - m] = min(dpr2[i - m], resl[j] + kek(a[i], a[j]));
            }
        }
        auto resr = restore(R, dpr2, mx - m);
        for (auto& x : resr) {
            x += m;
        }
        for (int j = 0; j < m; j++) {
            if (equal(resl[j] + kek(a[resr.back()], a[j]), dpr2[resr.back() - m])) {
                auto resl = restore(L, dpl, j);
                for (auto x : resl) {
                    resr.push_back(x);
                }
                for (auto& x : resr) {
                    x = id[a[x]];
                }
                return resr;
            }
        }
        assert(false);
    } else {
        auto resr = solve(R, dpr);
        vector<ld> dpr2(dpl.size(), 1e18);
        for (int i = m; i < n; i++) {
            for (int j = 0; j < m; j++) {
                dpr2[j] = min(dpr2[j], resr[i - m] + kek(a[i], a[j]));
            }
        }
        auto resl = restore(L, dpr2, mx);
        for (int j = m; j < n; j++) {
            if (equal(resr[j - m] + kek(a[resl.back()], a[j]), dpr2[resl.back()])) {
                auto resr = restore(R, dpr, j - m);
                for (auto x : resr) {
                    resl.push_back(x + m);
                }
                for (auto& x : resl) {
                    x = id[a[x]];
                }
                return resl;
            }
        }
        assert(false);
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    vector<pair<int, int>> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i].first >> a[i].second;
    }
    vector<ld> dp(n, 0);
    auto ans = solve(a, dp);
    int pos = min_element(ans.begin(), ans.end()) - ans.begin();
    cout << fixed << setprecision(15) << ans[pos] << '\n';
    auto result = restore(a, dp, pos);
    reverse(result.begin(), result.end());
    for (auto x : result) {
        cout << x + 1 << " ";
    }
    cout << '\n';
}