/* 
 * File:   main.cpp
 * Author: virtualdemon
 *
 * Created on February 6, 2010, 11:38 AM
 */
#include <fstream>
#define Nmax 200000
#define inf 0x3f3f3f3f

/*
 *
 */
using namespace std;
struct list
{
    int cost;
    int vertex;
    list *next;
} *L[Nmax];
int N;
int Heap[Nmax], Position[Nmax], cmin[Nmax], apm[Nmax];
inline void swap( int& x, int& y )
{
    int aux=x;
    x=y;
    y=aux;
}
inline void push( int x, int y, int c )
{
    list *q;
    q=new list;
    q->cost=c; q->vertex=y;
    q->next=L[x];
    L[x]=q;
}
void DownHeap( int k )
{
    int son;
    while( true )
    {
        son=2*k;
        if( son > N )
            return;
        if( son < N && cmin[Heap[son]] > cmin[Heap[son+1]] )
            son+=1;
        if( cmin[Heap[son]] >= cmin[Heap[k]] )
            return;
        swap( Position[Heap[k]], Position[Heap[son]] );
        swap( Heap[k], Heap[son] );
        k=son;
    }
}
void UpHeap( int k )
{
    int key=cmin[Heap[k]], f=k/2;
    while( k > 1 && key < cmin[Heap[f]] )
    {
        swap( Position[Heap[k]], Position[Heap[f]] );
        swap( Heap[k], Heap[f] );
        k=f;
        f=k/2;
    }
}
void cut_root()
{
    swap( Position[Heap[1]], Position[Heap[N]] );
    Position[Heap[1]]=-1;
    swap( Heap[1], Heap[N] );
    --N;
    DownHeap(1);
}
int main( void )
{
    list *p;
    int n, m, x, y, c, v, s=0;
    ifstream in("apm.in");
    in>>n>>m;
    for( x=0; x < n; ++x )
        Position[x]=cmin[x]=inf;
    for( ; m; --m )
    {
        in>>x>>y>>c;
        x-=1;
        y-=1;
        push( x, y, c );
        push( y, x, c );
    }
    cmin[0]=0;
    ++N;
    Position[0]=1;
    for( m=n; m; --m )
    {
        v=Heap[1];
        s+=cmin[v];
        cut_root();
        for( p=L[v]; p; p=p->next )
        {
            if( -1 == Position[p->vertex] )
                continue;
            if( cmin[p->vertex] > p->cost )
            {
                apm[p->vertex]=v;
                cmin[p->vertex]=p->cost;
                if( inf == Position[p->vertex] )
                {
                    Heap[++N]=p->vertex;
                    Position[p->vertex]=N;
                }
                UpHeap( Position[p->vertex] );
            }
        }        
    }
   
    ofstream out("apm.out");
    out<<s<<' '<<(n-1)<<'\n';
    for( x=1; x <n; ++x )
        out<<(x+1)<<' '<<(apm[x]+1)<<'\n';
    return 0;
}