#include <iostream>
#include <vector>
#include <algorithm>
#include<math.h>
#include<fstream>

using namespace std;

    ifstream archivo;
    ofstream out("parque.out");

vector <int> idComponente;
vector <vector <int> > componente;
unsigned long long int costoTotal=0;
vector<pair<int,int>>vec;



bool unionFind(int nodoA, int nodoB){
    int compA = idComponente[nodoA];
    int compB = idComponente[nodoB];

    if(compA == compB){
        return false;
    }
    int tamA = componente[compA].size();
    int tamB = componente[compB].size();

    if(tamA > tamB){
        swap(compA, compB);
        swap(tamA, tamB);
    }

    for(int i=0; i<tamA; i++){
        int nodo = componente[compA][i];
        componente[compB].push_back(nodo);
        idComponente[nodo] = compB;
    }

    return true;
}


struct arista
{
    int desde, hacia, costo;
    float hipo;
};

bool ordenar(arista a,arista b)
{
    return (a.hipo < b.hipo);
}

struct gg{
    int nodo,px,py;
};




vector <arista> kruskal(vector <arista> a, int cantNodos){

    idComponente.resize(cantNodos);
    componente.resize(cantNodos);
    for(int i=0; i<cantNodos; i++){
        idComponente[i] = i;
        componente[i] = vector <int> (1, i);
    }

    vector <arista> arbol;
    sort(a.begin(), a.end(),ordenar);

    for(int i=0;i<a.size() && arbol.size()<cantNodos-1; i++){
           if(unionFind(a[i].desde, a[i].hacia)){
            arbol.push_back(a[i]);
            costoTotal+=a[i].costo;
           }
    }
    out<<costoTotal<<endl;
    ////////////////////////////
    return arbol;
}


float hipotenusa(pair<int,int>a,pair<int,int>b){
    float max1,max2,min1,min2;
    max1=max(a.first,b.first);
    min1=min(a.first,b.first);
    max2=max(a.second,b.second);
    min2=min(a.second,b.second);
    float terminoA=(max1-min1)*(max1-min1);
    float terminoB=(max2-min2)*(max2-min2);
    float hip2=sqrt(terminoA+terminoB);
    return(hip2);
}


int chicote(float hip){
    int aux=hip;
    float decimal=hip-aux;
   int cable2=(2-decimal)+hip;
    return cable2;
}



int main()
{
    archivo.open("parque.in",ios::in);


    int cantNodos,cantAristas;
    //
    archivo>>cantNodos;
    cantNodos++;
    ///////////////////////////////////////////////////////////
    cantAristas=(cantNodos*(cantNodos-1))/2;

    vector <arista> a(cantAristas);




    vec.resize(cantNodos);

    vec[0]={0,0};
    for(int i=1;i<cantNodos;i++){
        int nodo,x,y;
        ///////////////////////////////////////////
        archivo>>nodo>>x>>y;
        vec[nodo].first=x;
        vec[nodo].second=y;
    }



int contador=0;
   for(int i=0;i<vec.size()-1;i++){
       for(int j=i+1;j<vec.size();j++){
            float hip=hipotenusa(vec[i],vec[j]);
            int cable=chicote(hip);
            a[contador].hipo=hip;
            a[contador].desde=i;
            a[contador].hacia=j;
            a[contador].costo=cable;
            contador++;
            }
        }
///



    vector <arista> resultado = kruskal(a, cantNodos);
    vector<vector<int> >conexiones(cantNodos);

    for(int i=0; i<resultado.size(); i++){
            conexiones[ resultado[i].desde ].push_back(resultado[i].hacia);
            conexiones[resultado[i].hacia].push_back( resultado[i].desde );
    }
        for(int i=1;i<conexiones.size();i++){
        out<<i<<" ";
        ///////////////////////
            for(int j=0;j<conexiones[i].size();j++){
                out<<conexiones[i][j]<<" ";
            ///////////////////////
        }
        out<<endl;
    ///////////////////
    }


    return 0;
}