Problem:
Minimum Spanning Tree

Find the sum of weights of edges of the Minimum Spanning Tree for a given weighted undirected graph G = (V, E).

Input

|V| |E|
s0 t0 w0
s1 t1 w1
:
s|E|-1 t|E|-1 w|E|-1

, where |V| is the number of vertices and |E| is the number of edges in the graph. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively.

si and ti represent source and target verticess of i-th edge (undirected) and wi represents the weight of the i-th edge.

Output

Print the sum of the weights of the Minimum Spanning Tree.

Constraints

1 ≤ |V| ≤ 10,000

0 ≤ |E| ≤ 100,000

0 ≤ wi ≤ 10,000

The graph is connected

There are no parallel edges

There are no self-loops

Sample Input 1

4 6
0 1 2
1 2 1
2 3 1
3 0 1
0 2 3
1 3 5

Sample Output 1

3

Sample Input 2

6 9
0 1 1
0 2 3
1 2 1
1 3 7
2 4 1
1 4 3
3 4 1
3 5 1
4 5 6

Sample Output 2

5

Solution in JAVA (judge verdict: Accepted)


import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		new Main().run();
	}

	private void run() {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int m = scanner.nextInt();
		Edge[] edges= new Edge[m];
		for (int i = 0; i < m; i++) {
			int a = scanner.nextInt();
			int b = scanner.nextInt();
			int c = scanner.nextInt();
			edges[i] = new Edge(a, b, c);
		}
		System.out.println(kruskal(n, edges));
	}

	private int kruskal(int n, Edge[] edges) {
		int totalCost = 0;
		Arrays.sort(edges);
		UnionFind unionFind = new UnionFind(n);
		for (Edge edge:edges) {
			if (!unionFind.isSame(edge.sorce, edge.target)) {
				totalCost += edge.cost;
				unionFind.merge(edge.sorce, edge.target);
			}
		}
		return totalCost;
	}

	class Edge implements Comparable<Edge> {
		int sorce, target, cost;

		@Override
		public String toString() {
			return "Edge [sorce=" + sorce + ", target=" + target + ", cost="
					+ cost + "]";
		}

		public Edge(int sorce, int target, int cost) {
			super();
			this.sorce = sorce;
			this.target = target;
			this.cost = cost;
		}

		@Override
		public int compareTo(Edge o) {
			return this.cost - o.cost;
		}

	}

	class UnionFind {
		int[] rank, node;

		UnionFind(int size) {
			rank = new int[size];
			node = new int[size];
			for (int i = 0; i < size; i++) {
				node[i] = i;
			}
		}

		@Override
		public String toString() {
			return "UnionFind [rank=" + Arrays.toString(rank) + ", node="
					+ Arrays.toString(node) + "]";
		}

		int find(int x) {
			if (x == node[x])
				return x;
			return node[x] = find(node[x]);
		}

		boolean isSame(int x, int y) {
			return find(x) == find(y);
		}

		void merge(int x, int y) {
			x = find(x);
			y = find(y);
			if (x == y)
				return;
			if (rank[x] > rank[y])
				node[y] = x;
			else {
				node[x] = y;
				if (rank[x] == rank[y])
					rank[y]++;
			}
		}

	}
}