Problem:
Problem Statement

You are given a connected undirected graph which has even numbers of nodes.
A connected graph is a graph in which all nodes are connected directly or indirectly by edges.

Your task is to find a spanning tree whose median value of edges' costs is minimum.
A spanning tree of a graph means that a tree which contains all nodes of the graph.

Input

The input consists of multiple datasets.

The format of each dataset is as follows.

n m
s_1 t_1 c_1
...
s_m t_m c_m

The first line contains an even number n (2 \leq n \leq 1,000) and an integer m (n-1 \leq m \leq 10,000).
n is the nubmer of nodes and m is the number of edges in the graph.

Then m lines follow, each of which contains s_i (1 \leq s_i \leq n), t_i (1 \leq s_i \leq n, t_i \neq s_i) and c_i (1 \leq c_i \leq 1,000).
This means there is an edge between the nodes s_i and t_i and its cost is c_i.
There is no more than one edge which connects s_i and t_i.

The input terminates when n=0 and m=0.
Your program must not output anything for this case.

Output

Print the median value in a line for each dataset.

Sample Input

2 1
1 2 5
4 6
1 2 1
1 3 2
1 4 3
2 3 4
2 4 5
3 4 6
8 17
1 4 767
3 1 609
8 3 426
6 5 972
8 1 607
6 4 51
5 1 683
3 6 451
3 4 630
8 7 912
3 7 43
4 7 421
3 5 582
8 4 538
5 7 832
1 6 345
8 2 608
0 0

Output for the Sample Input

5
2
421

Solution in JAVA (judge verdict: Accepted)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main {
	MyScanner sc = new MyScanner();
	Scanner sc2 = new Scanner(System.in);
	final int MOD = 1000000007;
	int[] dx = { 1, 0, 0, -1 };
	int[] dy = { 0, 1, -1, 0 };
	int  M = 10000000;

	void run() {
		for (;;) {
			int n = sc.nextInt();
			int m = sc.nextInt();
			if ((n | m) == 0) {
				return;
			}
			int[][] cost = new int[n + 1][n + 1];
			int[] min = new int[n + 1];
			boolean[] use = new boolean[n + 1];

			for (int i = 0; i <= n; i++) {
				Arrays.fill(cost[i], M);
				cost[i][i] = 0;
			}
			Arrays.fill(min, M);
			for (int i = 0; i < m; i++) {
				int s = sc.nextInt();
				int t = sc.nextInt();
				int c = sc.nextInt();
				cost[s][t] = c;
				cost[t][s] = c;
			}
			min[1] = 0;
			ArrayList<Integer> list = new ArrayList<Integer>();
			for (;;) {
				int v = -1;
				for (int j = 1; j <= n; j++) {
					if (!use[j] && (v == -1 || min[v] > min[j])) {
						v = j;
					}
				}
				if (v == -1) {
					break;
				}
				if (min[v] != 0) {
					list.add(min[v]);
				}
				use[v] = true;
				for (int j = 1; j <= n; j++) {
					if (!use[j] && min[j] > cost[v][j]) {
						min[j] = cost[v][j];
					}
				}
			}
			Collections.sort(list);
			System.out.println(list.get((n-1)/2));
		}
	}

	public static void main(String[] args) {
		new Main().run();
	}

	void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}

	void debug2(int[][] array) {
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				System.out.print(array[i][j]);
			}
			System.out.println();
		}
	}

	class MyScanner {
		int nextInt() {
			try {
				int c = System.in.read();
				while (c != '-' && (c < '0' || '9' < c))
					c = System.in.read();
				if (c == '-')
					return -nextInt();
				int res = 0;
				do {
					res *= 10;
					res += c - '0';
					c = System.in.read();
				} while ('0' <= c && c <= '9');
				return res;
			} catch (Exception e) {
				return -1;
			}
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		String next() {
			try {
				StringBuilder res = new StringBuilder("");
				int c = System.in.read();
				while (Character.isWhitespace(c))
					c = System.in.read();
				do {
					res.append((char) c);
				} while (!Character.isWhitespace(c = System.in.read()));
				return res.toString();
			} catch (Exception e) {
				return null;
			}
		}
	}
}