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 Rust (judge verdict: Accepted)

use std::cmp::Ordering;
use std::io::Read;
use std::collections::{BTreeMap, BinaryHeap};

#[derive(PartialEq, Eq, Debug, Copy, Clone, Default, Hash)]
pub struct Reverse<T>(pub T);

impl<T: PartialOrd> PartialOrd for Reverse<T> {
    #[inline]
    fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering> {
        other.0.partial_cmp(&self.0)
    }

    #[inline]
    fn lt(&self, other: &Self) -> bool {
        other.0 < self.0
    }
    #[inline]
    fn le(&self, other: &Self) -> bool {
        other.0 <= self.0
    }
    #[inline]
    fn gt(&self, other: &Self) -> bool {
        other.0 > self.0
    }
    #[inline]
    fn ge(&self, other: &Self) -> bool {
        other.0 >= self.0
    }
}

impl<T: Ord> Ord for Reverse<T> {
    #[inline]
    fn cmp(&self, other: &Reverse<T>) -> Ordering {
        other.0.cmp(&self.0)
    }
}

fn solve(nv: usize, _ne: usize, e: &[(usize, usize, i32)]) -> i32 {
    let mut g = vec![BTreeMap::new(); nv];
    for &(s, t, w) in e.iter() {
        g[s].insert(t, w);
        g[t].insert(s, w);
    }
    let v = 0;
    let mut vis = vec![false; nv];
    vis[v] = true;
    let mut h = g[v].iter().map(|(&t, &w)| Reverse((w, v, t))).collect::<BinaryHeap<_>>();
    let mut e = Vec::new();
    while let Some(Reverse((w, s, t))) = h.pop() {
        if vis[s] && !vis[t] {
            e.push((s, t, w));
            vis[t] = true;
            for (&u, &w) in g[t].iter() {
                if !vis[u] {
                    h.push(Reverse((w, t, u)));
                }
            }
        }
    }
    e.iter().map(|&(_, _, w)| w).sum::<i32>()
}

fn main() {
    let mut buf = String::new();
    std::io::stdin().read_to_string(&mut buf).unwrap();
    let mut iter = buf.split_whitespace();
    let nv: usize = iter.next().unwrap().parse().unwrap();
    let ne: usize = iter.next().unwrap().parse().unwrap();
    let e = (0..ne)
        .map(|_| {
            let s: usize = iter.next().unwrap().parse().unwrap();
            let t: usize = iter.next().unwrap().parse().unwrap();
            let w: i32 = iter.next().unwrap().parse().unwrap();
            (s, t, w)
        })
        .collect::<Vec<_>>();
    let w = solve(nv, ne, &e);
    println!("{}", w);
}