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 C (judge verdict: Time Limit Exceeded)

#include <stdio.h>
#include <stdlib.h>
#define EMAX 100000
#define VMAX 10000
typedef struct graph_tag{

 int w;
 int source;
 int target;

}GRAPH;

GRAPH E[EMAX];
int P[VMAX];

void swap(int *a, int *b){
int v;
   v = *a;
   *a = *b;
   *b = v;
}
QSort(int l, int r){
int m;


 if(l < r){
 m = partition(l, r);
 QSort(l, m-2);
 QSort(m, r);
 }

}

int partition(int l, int r){
int i = l, j = 0, v;



 for(j = l; j <= r; j++){
    if(E[r].w >= E[j].w){
      swap(&(E[i].w), &(E[j].w));
      swap(&(E[i].source), &(E[j].source));
      swap(&(E[i].target), &(E[j].target));
      i++;
    }

 }

 return i;

}

void unite(int s, int t){
int ps, pt;
 ps  = find(s);
 pt = find(t);


 P[ps] = pt;

}

int find(int s){
int p;
  p = s;
 while(P[p] != p){
  p = P[p];

 }
 return p;
}

int main(){
int v, e, count, sum = 0;

 scanf("%d", &v);
 scanf("%d", &e);

 for(count = 0; count < e; count++){
  scanf("%d", &(E[count].source));
  scanf("%d", &(E[count].target));
  scanf("%d", &(E[count].w));
 }

 for(count = 0; count < v; count++)
   P[count] = count;

 QSort(0, e-1);

 for(count = 0; count < e; count++){

    if(find(E[count].source) != find(E[count].target)){
       sum += E[count].w;
       unite(E[count].source, E[count].target);
    }
 }


 printf("%d\n", sum);


 return 0;
}