// Adapted from Readiz/h-contest-lesson at 2011c00330b5.
// Local C++17 runner: 1 <= N <= 100, coordinates in [0, 999].
#include <iostream>
#include <cstdlib>
static int coordinates[100][2];
int get_dist(int a, int b) {
    return std::abs(coordinates[a][0] - coordinates[b][0])
         + std::abs(coordinates[a][1] - coordinates[b][1]);
}
int get_path_dist(const int order[], int size) {
    int cost = 0;
    for (int i = 1; i < size; ++i) cost += get_dist(order[i-1], order[i]);
    return cost;
}
extern int get_dist(int a, int b);
extern int get_path_dist(const int order[], int size);

static void reverse_range(int order[], int left, int right) {
    while (left < right) {
        int temp = order[left];
        order[left] = order[right];
        order[right] = temp;
        ++left;
        --right;
    }
}

void build_path(int n, const int points[][2], int order[]) {
    int used[100];
    (void)points;

    for (int i = 0; i < n; ++i) {
        used[i] = 0;
    }

    order[0] = 0;
    used[0] = 1;

    for (int pos = 1; pos < n; ++pos) {
        int current = order[pos - 1];
        int best = -1;
        int best_dist = 0;

        for (int cand = 0; cand < n; ++cand) {
            if (used[cand]) continue;

            int dist = get_dist(current, cand);
            if (best == -1 || dist < best_dist) {
                best = cand;
                best_dist = dist;
            }
        }

        order[pos] = best;
        used[best] = 1;
    }

    for (int pass = 0; pass < 80; ++pass) {
        int improved = 0;

        for (int left = 1; left < n - 1; ++left) {
            for (int right = left + 1; right < n; ++right) {
                int a = order[left - 1];
                int b = order[left];
                int c = order[right];
                int before = get_dist(a, b);
                int after = get_dist(a, c);

                if (right + 1 < n) {
                    int d = order[right + 1];
                    before += get_dist(c, d);
                    after += get_dist(b, d);
                }

                if (after < before) {
                    reverse_range(order, left, right);
                    improved = 1;
                }
            }
        }

        if (!improved) break;
    }
}

int main() {
    int n;
    if (!(std::cin >> n) || n < 1 || n > 100) return 1;
    for (int i = 0; i < n; ++i) {
        if (!(std::cin >> coordinates[i][0] >> coordinates[i][1])) return 1;
        for (int v : coordinates[i]) if (v < 0 || v > 999) return 1;
    }
    int order[100];
    build_path(n, coordinates, order);
    std::cout << get_path_dist(order, n) << '\n';
    for (int i = 0; i < n; ++i) std::cout << (i ? " " : "") << order[i];
    std::cout << '\n';
}