1.


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/**
* ACM Training 2009
* ACM Problem #11631 - Dark roads
* Link: http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=78&page=show_problem&problem=2678
*
* @author Dennis Wilfert
* @version 1.0, 08/09/2009
*
* Status : Accepted
* Runtime: 1.316
*/
public class Main {

public static void main(String[] args) throws IOException {

BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
StringBuilder output = new StringBuilder();

StringTokenizer token;
int junctions, roads, length, i, j, head;
int[][] coordinates;
boolean[] nodes;

while (true) {
token = new StringTokenizer(read.readLine());

// Kreuzungen
junctions = Integer.parseInt(token.nextToken());
// Straßen
roads = Integer.parseInt(token.nextToken());

if (junctions == 0 && roads == 0) {
break;
}

// Länge des Straßennetzes
length = 0;

coordinates = new int[roads][5];
nodes = new boolean[junctions];

// Werte in 2-Dimensionales Array einlesen
for (i = 0; i < roads; i++) {
token = new StringTokenizer(read.readLine());
coordinates[i][0] = Integer.parseInt(token.nextToken());
coordinates[i][1] = Integer.parseInt(token.nextToken());
coordinates[i][2] = Integer.parseInt(token.nextToken());
// Gesammtlänge des Straßennetzes berechnen
length += coordinates[i][2];
}

// 2-Dimensionales Array nach dem Abstand der Punkte Sortieren
sort(coordinates, 0, roads - 1);

// Jeweils die vorherigen und die nächste Position zu jedem Wert eintragen
for (i = 0; i < roads; i++) {
coordinates[i][3] = i - 1;
coordinates[i][4] = i + 1;
}

head = 0;
nodes[0] = true;

// Alle Knoten durchlaufen
for (j = junctions - 1; j > 0; j--) {
i = head;
while (i < roads) {
// Steht weder der Anfangs- noch der Endknoten der Straße auf true wird mit dem nächsten Wert weitergemacht
if (!nodes[coordinates[i][0]] && !nodes[coordinates[i][1]]) {
i = coordinates[i][4];
} // Steht mindestens einer der Beiden Knoten der aktuellen Straße auf true
else {
// Ist der Vorgängerwert -1, bekommt die nachfolgende Straße auch -1 als Vorgängerwert
if (coordinates[i][3] == -1) {
coordinates[coordinates[i][4]][3] = coordinates[i][3];
} // Ansonsten bekommt die vorherige Straße den nachfolgerwert als nächste Straße
// und doie nachfolgende Straße die Vorgängerstraße als vorherige Straße
else {
coordinates[coordinates[i][3]][4] = coordinates[i][4];
coordinates[coordinates[i][4]][3] = coordinates[i][3];
}
// Ist nur einer der beiden Knotenpunke der Straße auf true wird der andere Knotenpunkt auch auf true gesetzt und die Länge
// der Straße von der Gesamtlänge des Straßennetzes abgezogen, d.h. die Straße kann ohne Beleuchtung auskommen.
if ((nodes[coordinates[i][0]] && !nodes[coordinates[i][1]]) || (nodes[coordinates[i][1]] && !nodes[coordinates[i][0]])) {
nodes[nodes[coordinates[i][0]] ? coordinates[i][1] : coordinates[i][0]] = true;
length -= coordinates[i][2];
// Ist der Vorgängerwert -1 wird der Nachfolgerwert als Startpunkt für die while-Schleife gesetzt, ansonsten wird mit
// dem alten Startwert begonnen
if (coordinates[i][3] == -1) {
head = coordinates[i][4];
}
// Schleife unterbrechen
break;
}
i = coordinates[i][4];
}
}
}

output.append(length);
output.append("\n");
}
System.out.print(output);
}

/*
* Sortieren des 2-DImensionalen Arrays
*/
public static void sort(int[][] a, int start, int end) {
int[] tmp;
int i = start;
int j = end;
int x = a[(start + end) / 2][2];

do {
// Vom Startpunkt aus einen Wert suchen der >= x ist
while (a[i][2] < x) {
i++;
}
// Vom Endpunkt aus einen Wert suchen der <= x ist
while (a[j][2] > x) {
j--;
}

// a[i] und a[j] tauschen
if (i <= j) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
i++;
j--;
}
} while (i <= j);

if (start < j) {
sort(a, start, j);
}

if (i < end) {
sort(a, i, end);
}
}
}