#include <stdio.h>

/******************************************************************/
struct arete
{int orig,extr;float co;};
/*****************************************************************/
void saisie(int n,struct arete t[])
 {for (int i=0;i<n;i++)
  scanf("%d%d%f",&t[i].orig,&t[i].extr,&t[i].co);
 } 
/*****************************************************************/
void affiche(int n,struct arete t[])
 {for (int i=0;i<n;i++)
  printf("(%d,%d) longueur %f\n",t[i].orig,t[i].extr,t[i].co);
 }
/*****************************************************************/
void calcul(int nbArPoss,struct arete tArPoss[],int np,
            struct arete tArChoi[])
{
 int g[np];//tableau representant les groupes de points
 int grorig,grextr;//representent les groupes de l'origine et de l'extremite 
                   //de l'arete en cours d'essai
 int nbArChoi=0;//nb aretes choisies a un moment donne
 int iPoss=0;//indice de l'arete possible qui est en cours d'essai

 //initialisation des groupes: au départ, chaque point constitue un groupe
 // à lui tout seul,qui porte le meme numero que lui( v. remarque a la fin).
    for (int i=0;i<np;i++) g[i]=i;

 //essai des aretes dans l'ordre de cout croissant
 while (nbArChoi < np-1)
   {
    printf("arete essayee (%d,%d)\n",tArPoss[iPoss].orig,tArPoss[iPoss].extr);

   //remplissage de grorig et grextr 
   //(rappel:l'indice de tableau commence a 0,et les noeuds
   //sont numerotes à partir de 1 dans les donnees)
   grorig=g[tArPoss[iPoss].orig-1];grextr=g[tArPoss[iPoss].extr-1];
 
   if (grorig !=grextr)//les deux extremites n'appartiennent pas au meme groupe

     {//l'arete est retenue: les groupes de ses extremites fusionnent;
      //le nouveau groupe a par convention le numero du plus petit des deux
      int garde,renumerote;
      if (grorig<grextr) {garde=grorig;renumerote=grextr;}
       else{garde=grextr;renumerote=grorig;}

      //affichage pour suivre le deroulement
      printf("garde %d   renumerote %d\n", garde, renumerote);
      for (int i=0;i<np;i++) if(g[i]==renumerote) g[i]=garde;
      printf("tableau apres modif\n");
      printf("indices : ");for (int i=0;i<np;i++) printf("%d ",i);
      printf("\n");
      printf("valeurs : ");;for (int i=0;i<np;i++) printf("%d ",g[i]);
      printf("\n");
     
      //on ajoute effectivement l'arete a la liste des aretes choisies
      tArChoi[nbArChoi]=tArPoss[iPoss];nbArChoi++;
     }//fin if
    iPoss++;
  }//fin while
}//calcul








/****************************************************************/
int main()

{int np;//nombre de points
 scanf("%d",&np);
 int nbArPoss;scanf("%d",&nbArPoss);//nombre d'aretes possibles 
 struct arete tArPoss[nbArPoss];// tableau des aretes possibles 
 struct arete tArChoi[np-1];// tableau des aretes choisies

 //saisie puis affichage des aretes possibles
 saisie(nbArPoss,tArPoss);
 printf("liste des %d aretes possibles \n", nbArPoss);
 affiche(nbArPoss,tArPoss);

 //calcul des aretes retenues
 calcul(nbArPoss,tArPoss,np,tArChoi);
//affichage des aretes retenues
 printf("liste des %d aretes  retenues \n", np-1);
 affiche(np-1, tArChoi);

}



/*remarque pour le remplissage du tableau de groupes:

      comme les indices commencent à zéro, il y a un décalage
      entre les numéros des noeuds dans l'énoncé (numérotation humaine
      courante ,à partir de 1) ,et les indices des éléments de tableau:
      qui leur correspondent: t[i] "represente" le noeud i+1,et doit 
      contenir le numéro du groupe auquel appartient le noeud i+1. 
      Il faut décider si au départ, on met i+1 dans t[i] ( numero identique
      à celui du noeud) ou si on met i ( numero identique à l'indice qui
      represente le noeud). J'ai choisi i, mais les deux solutions se valent:
      il faut simplement rester homogène ensuite pendant le calcul.*/