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

# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_2_A&lang=jp
# Spanning Tree - Minimum Spanning Tree

class PriorityQueue
  def initialize()
    @data = []
  end

  def push(x)
    i = @data.bsearch_index { |y| y > x }
    if i
      @data.insert(i, x)
    else
      @data.push(x)
    end
  end

  def length()
    @data.length
  end

  def pop()
    @data.shift
  end
end

class St
  attr :p, :cost

  def initialize(p, cost)
    @p = p
    @cost = cost
  end

  def >(other)
    @cost > other.cost
  end
end

class MST
  def initialize(nv)
    @adj = Array.new(nv) { Array.new }
    @nv = nv
  end

  def connect(a, b, w)
    @adj[a].push({ to: b, cost: w })
    @adj[b].push({ to: a, cost: w })
  end

  def calc
    que = PriorityQueue.new
    que.push(St.new(0, 0))
    visited = Array.new(@nv, false)
    sum = 0
    while que.length > 0
      cur = que.pop
      next if visited[cur.p]
      visited[cur.p] = true
      sum += cur.cost
      @adj[cur.p].each do |e|
        que.push(St.new(e[:to], e[:cost])) if !visited[e[:to]]
      end
    end
    sum
  end
end

nv, ne = gets.split.map(&:to_i)
mst = MST.new(nv)
ne.times do
  a, b, w = gets.split.map(&:to_i)
  mst.connect(a, b, w)
end

puts mst.calc