Go: package main

import (
	"fmt"
	"sort"
)

type Edge struct {
	I int
	J int
	A int
}

func main() {
	var n int
	fmt.Scan(&n)

	g := make([][]int, n)
	edges := make([]Edge, 0, n*(n-1)/2)
	parents := make([]int, n)
	for i := 0; i < n; i++ {
		g[i] = make([]int, n)
		for j := 0; j < n; j++ {
			fmt.Scan(&g[i][j])
			if g[i][j] >= 0 {
				edges = append(edges, Edge{i, j, g[i][j]})
			}
		}
		parents[i] = i
	}
	sort.SliceStable(edges, func(i, j int) bool { return edges[i].A >= edges[j].A })

	sum := 0
	num := 0
	for len(edges) > 0 && num < n-1 {
		edge := edges[len(edges)-1]
		edges = edges[:len(edges)-1]

		if same(edge.I, edge.J, &parents) {
			continue
		}
		union(edge.I, edge.J, &parents)
		sum += edge.A
		num += 1
	}
	fmt.Println(sum)
}



func root(id int, parents *[]int) int {
	if id == (*parents)[id] {
		return id
	}
	return root((*parents)[id], parents)
}

func union(i, j int, parents *[]int) {
	(*parents)[root(j, parents)] = (*parents)[root(i, parents)]
}

func same(i, j int, parents *[]int) bool {
	return root(i, parents) == root(j, parents)
}

Python: n = int(input())
INFTY = 10**5
WHITE = 0
GRAY = 1
BLACK = 2

A = [[ int(row) if row != "-1" else INFTY for row in input().split()] for i in range(n)]

def prim(A, st):
    colors = [WHITE] * n
    colors[st] = BLACK
    T = [st]
    total_weights = 0
    
    while len(T) < n:
    
        current_min = INFTY
        next_add = st
        for node_inT in T:
            for v in range(n):
                if colors[v] == WHITE and A[node_inT][v] < current_min:
                    current_min = A[node_inT][v]
                    next_add = v

        total_weights += current_min
        T.append(next_add)
        colors[next_add] = BLACK
    
    return total_weights

MST = [0] * n
for i in range(n):
    MST[i] = prim(A, i)

print(min(MST))

Python: from __future__ import division, print_function
from sys import stdin, maxint
 
 
def main():
    num = int(stdin.readline())
 
    y = []
    for _ in xrange(num):
        it = iter(int(s) for s in stdin.readline().split()[1:])
        y.append([(next(it), next(it)) for _ in xrange(next(it))])
    weight = [maxint] * num
    weight[0] = 0
    t = set(xrange(1, num))
    index = 0
 
    while t:
        for v, cost in y[index]:
            if v not in t:
                continue
            weight[v] = min(weight[v], cost + weight[index])

        index = min(t, key=lambda i: weight[i])
        t.remove(index)

    for i, d in enumerate(weight):
        print(i, d)
 
 
main()

Python: # coding: utf-8

n = int(input())
ew = [None] * n
for i in range(n):
    ew[i] = list(map(int, input().split()))

elist = []
for i in range(n):
    for j in range(i+1, n):
        if ew[i][j] > -1:
            elist.append((ew[i][j], i, j))


class UnionFind(object):
    def __init__(self, n):
        self.parent = [i for i in range(n)]

    def find_root(self, i):
        if self.parent[i] != i:
            p = self.parent[i]
            self.parent[i] = self.find_root(p)
        return self.parent[i]

    def same_group(self, i, j):
        return self.find_root(i) == self.find_root(j)

    def union(self, i, j):
        i = self.find_root(i)
        j = self.find_root(j)
        if i != j:
            self.parent[j] = i


uf = UnionFind(n)
esum = 0
for edge in sorted(elist):
    if not uf.same_group(edge[1], edge[2]):
        uf.union(edge[1], edge[2])
        esum += edge[0]

print(esum)

Python: # -*- coding: utf-8 -*-
"""
Created on Sat Apr  6 18:01:32 2019

@author: Yamazaki Kenichi
"""

n = int(input())
A = [list(map(int,input().split())) for i in range(n)]
INFTY = 10**6
T = [-1 for i in range(n)]
d = [INFTY for i in range(n)]
p = [0 for i in range(n)]
d[0], p[0] = 0, -1
for j in range(n):
    mincost = 10**6
    for i in range(n):
        if T[i] != 1 and d[i] < mincost:
            mincost = d[i]
            u = i
    T[u] = 1
    for v in range(n):
        if T[v] != 1 and A[u][v] != -1:
            if A[u][v] < d[v]:
                d[v] = A[u][v]
                p[v] = u
                T[v] = 0
print(sum(d))

Python: n = int(input())
edgeArray = [list(map(int, input().split())) for i in range(n)]
edgeList = []
rootList = [-1 for i in range(n)]
sumLength = 0

def getRoot(x):
    r = rootList[x]
    if r < 0:
        rootList[x] = x
    elif r != x:
        rootList[x] = getRoot(r)
    return rootList[x]
        
for i in range(n):
    for j in range(i):
        if edgeArray[i][j] != -1:
            edgeList.append([edgeArray[i][j], i, j])
edgeList.sort(key=lambda x: x[0])
for e in edgeList:
    x = getRoot(e[1])
    y = getRoot(e[2])
    if x != y:
        sumLength += e[0]
        rootList[x] = rootList[y] = min(x, y)
print(sumLength)

Python: import sys
from collections import deque

sys.setrecursionlimit(1000000)
n = int(input())
graph = [[] for _ in range(n)]

global visited 
visited = [0 for _ in range(n)]
global Q, S, T

S = [0] #訪れた順
T = []
visited[0] = 1 #開始位置はすでに訪れたことにする

def input_graph(n):
  for i in range(n):
    vs = list(map(int, input().split()))
    graph[i] = vs
    """for j in range(n):
      if vs[j] != -1:
        tree[i].append([j, vs[j]])"""

def prim():
  global S
  cost = 0
  while len(S) < n:
    max_e = 3000
    ad_v = 0
    ad_list = []
    for s in S:
      for j in range(n):
        if graph[s][j] != -1 and j not in S:
          ad_list.append(graph[s][j])
          #print("s: ",s, " j: ",j, graph[s][j])
          if max_e > graph[s][j]:
            max_e = graph[s][j]
            ad_v = j
    S.append(ad_v)
    cost += max_e
  print(cost)
  

if __name__ == "__main__":
  input_graph(n)
  prim()

Python: import heapq
n = int(input())
ans = 0
cost = []
for i in range(n):
    L = list(map(int,input().split()))
    cost.append(L)
used = [False]*n
used[0] = True #島0から探索を始める。
edge = []
for i in range(n):
    T = []
    edge.append(T)
for i in range(n):
    for j in range(n):
        if cost[i][j] != -1:
            edge[i].append([cost[i][j],j])
P = edge[0]
P.sort()
while len(P) != 0:
    cur = heapq.heappop(P)
    d = cur[0]
    next = cur[1]
    if used[next] == True:
        continue
    used[next] = True
    ans += d
    for e in edge[next]:
        heapq.heappush(P,[e[0],e[1]])
print(ans)

Python: import heapq


class MinimumSpanningTree:
    """ Prim's algorithm: find minimum spanning tree
        Complexity: O(E log(V))
        used in GRL2A(AOJ)
    """

    def __init__(self, V, E, start=0, INF=10**9):
        """ V: the number of vertexes
            E: adjacency list (undirected graph)
            start: start vertex
            INF: Infinity cost
        """
        self.prim(V, E, start, INF)

    def prim(self, V, E, start=0, INF=10**9):
        used = [False] * V
        self.mincost = 0
        que = []
        heapq.heappush(que, (0, 0))
        while len(que) > 0:
            cost, v = heapq.heappop(que)
            if used[v]:
                continue
            used[v] = True
            self.mincost += cost
            for to, c in E[v]:
                heapq.heappush(que, (c, to))

    def minCost(self):
        return self.mincost

V = int(input())
edge = [[] for _ in range(V)]
for i in range(V):
    for j, d in enumerate(map(int, input().split())):
        if d != -1:
            edge[i].append((j, d))
mst = MinimumSpanningTree(V, edge)
print(mst.minCost())