Go: package main

import (
	"fmt"
	"bufio"
	"os"
	"strconv"
)

const (
	white int = iota
	gray
	black
)
const INFTY int = 2001

var G [][]int
var color []int
var d []int
var p []int
var N int

func prim() int {
	u := 0
	d[u] = 0
	for {
		minCost := INFTY
		for i:=0; i<N; i++ {
			if color[i] != black && d[i] < minCost {
				minCost = d[i]
				u = i
			}
		}

		if minCost == INFTY {
			break
		}

		color[u] = black

		for v:=0; v<N; v++ {
			if color[v] != black && G[u][v] != -1 {
				if G[u][v] < d[v] {
					d[v] = G[u][v]
					p[v] = u
					color[v] = gray
				}
			}
		}
	}
	// sum
	sum := 0
	for i:=0; i<N; i++ {
		if p[i] != -1 {
			sum += G[i][p[i]]
		}
	}
	return sum
}




func initVariable(N int) {
	G = make([][]int, N)
	for i:=0; i<N; i++ {
		G[i] = make([]int, N)
	}
	color = make([]int, N)
	d = make([]int, N)
	p = make([]int, N)
	for i:=0; i<N; i++ {
		d[i] = INFTY
		p[i] = -1
	}
}

func nextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	num, _ := strconv.Atoi(scanner.Text())
	return num
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	N = nextInt(scanner)
	initVariable(N)
	for i:=0; i<N; i++ {
		for j:=0; j<N; j++ {
			G[i][j] = nextInt(scanner)
		}
	}
	fmt.Printf("%d\n", prim())
}

C++: #include<iostream>
#include<vector>
#include<utility>
#include<algorithm>
using namespace std;
class UnionFind{
  vector<int> node;
 public:
  UnionFind(int n):node(n){
    for(int i = 0;i < n;i++){
      node[i] = i;
    }
  }
  int root(int x){
    if(x == node[x])return x;
    return root(node[x]);
  }
  void merge(int x,int y){
    node[root(x)] = root(y);
  }
};
struct edge{
  int x,y,w;
};
bool operator<(edge e1,edge e2){
  return e1.w < e2.w;
}
int main(){
  int n;
  cin >> n;
  vector<edge> edges;
  UnionFind u(n);
  for(int i = 0;i < n;i++){
    for(int j = 0;j < n;j++){
      int x;
      cin >> x;
      if(x >= 0){
        edges.push_back({i,j,x});
      }
    }
  }
  int weight = 0;
  sort(edges.begin(),edges.end());
  for(auto &e:edges){
    if(u.root(e.x) == u.root(e.y))continue;
    u.merge(e.x,e.y);
    weight += e.w;
  }
  cout << weight << endl;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define MAX 100
#define WHITE 0
#define BLACK 1
#define INFTY 2001

// グラフの頂点数
int n;
// 隣接行列
vector<vector<int> > M(MAX, vector<int>(MAX));
// 頂点の状態を表す配列
vector<int> color(MAX, WHITE);
// d[v]はvとTの頂点を結ぶ辺の重みの最小値
vector<int> d(MAX, INFTY);
// p[v]はd[v]の重みを持つ辺のvでない方の頂点
vector<int> p(MAX, -1);

int mst()
{
  // 初期化
  int ans = 0;
  d.at(0) = 0;

  while (1)
  {
    // d[u]が最小であるようなV-Tの頂点uを選ぶ
    int u;
    int m = INFTY;
    for (int i = 0; i < n; i++)
    {
      if (color.at(i) != BLACK && d.at(i) < m)
      {
        m = d.at(i);
        u = i;
      }
    }

    if (m == INFTY)
    {
      // MNTが完成したとき
      break;
    }

    // uをTに追加する
    color.at(u) = BLACK;
    // uをTに追加したときの辺の重みをansに足す
    if (p.at(u) != -1)
    {
      ans += M.at(p.at(u)).at(u);
    }

    // uと隣接しているV-Tの各頂点iのd[i]を更新する
    for (int i = 0; i < n; i++)
    {
      if (color.at(i) != BLACK && M.at(u).at(i) != -1 && M.at(u).at(i) < d.at(i))
      {
        d.at(i) = M.at(u).at(i);
        p.at(i) = u;
      }
    }
  }

  return ans;
}

int main()
{
  // 入力
  cin >> n;
  for (int i = 0; i < n; i++)
  {
    for (int j = 0; j < n; j++)
    {
      cin >> M.at(i).at(j);
    }
  }

  // 処理と出力
  cout << mst() << endl;
}

C++: #include <iostream>
#include <limits.h>
using namespace std;

int main(void)
{
	int n, now = 0, flag[101];
	long ans = 0, an[100][100], min[100];

	cin >> n;

	for(int i = 0; i < n; i++) {
		for(int j = 0; j < n; j++) {
			cin >> an[i][j];
		}
		min[i] = LONG_MAX;
		flag[i] = 0;
	}

	/* ???????則?????????即?????属????????? */
	do {
		flag[now] = 1;
		flag[100] = 0;
/*
		cout << "\n??? " << now << " ????則???????????????????" << endl;
		cout << "?????贈?????? : ";
		for(int i = 0; i < n; i++) {
			if(flag[i] == 1) {
				cout << i << " ";
			}
		}
		cout << endl;
		cout << "?????即???????属?????????則" << endl;
		for(int i = 0; i < n; i++) {
			if(flag[i] == 0) {
				cout << "??? " << i << " : " << min[i] << endl;
			}
		}
*/
		/* min?????卒??属 */
		for(int j = 0; j < n; j++) {
			if(an[now][j] != -1 && an[now][j] < min[j] && flag[j] == 0) {
/*				cout << "??? " << j <<" ???????属?????????卒??属??????????????? : "<< min[j] << " ??? " << an[now][j] << endl; */
				min[j] = an[now][j];
			}
		}
/*
		cout << "?????即???????属?????????則" << endl;
		for(int i = 0; i < n; i++) {
			if(flag[i] == 0) {
				cout << "??? " << i << " : " << min[i] << endl;
			}
		}
*/
		/* ?測??????蔵?卒蔵???min????属???? */
		long key = LONG_MAX, key_j;

		for(int j = 0; j < n; j++) {
			if(flag[j] == 0 && min[j] < key) {
				key = min[j];
				key_j = j;
			}
		}
/*
		cout << "?則???????????賊??????????????????? : ??? " << key_j << endl;
*/
		/* ?則?????????? */
		now = key_j;
		ans += key;

		/* ??????????????贈????????? */
		for(int i = 0; i < n; i++) {
			if(flag[i] == 1) {
				flag[100]++;
			}
		}
	
	}while(flag[100] != n - 1);

	cout << ans << endl;

	return 0;
}

C++: #include <iostream>
#include <list>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <algorithm>
#include <cmath>
#include <string>
using namespace std;
typedef long long lli;
typedef vector<lli> vll;
typedef vector<bool> vbl;
typedef vector<vector<lli> > mat;
typedef vector<vector<bool> > matb;
typedef vector<string> vst;
typedef pair<lli,lli> pll;
typedef pair<double,double> pdd;

vll par;
vll rnk;
void init(lli n){
    par = vll(n);
    rnk = vll(n);
    for(lli i = 0;i < n;i++) par[i] = i;
}
lli find(lli x){
    if(par[x] == x) return x;
    else return par[x] = find(par[x]);
}
void unite(lli x,lli y){
    x = find(x);y = find(y);
    if(x == y) return;
    if(rnk[x] < rnk[y]) par[x] = y;
    else {
        par[y] = x;
        if(rnk[x] == rnk[y]) rnk[x]++;
    }
}
bool same(lli x,lli y){
    return find(x) == find(y);
}

lli n;
vll c,r,l;
vll p;
mat g;
lli ans = 0;

int main(){
    cin >> n;
    g = mat(n,vll(n));
    for(lli i = 0;i < n;i++){
        for(lli j = 0;j < n;j++){
            cin >> g[i][j];
        }
    }
    for(lli i = 0;i < n;i++){
        for(lli j = i+1;j < n;j++){
            if(g[i][j] >= 0) c.push_back(g[i][j]),r.push_back(i),l.push_back(j);
        }
    }
    p = vll(c.size());
    for(lli i = 0;i < p.size();i++) p[i] = i;
    sort(p.begin(),p.end(),[](lli a,lli b){
        return c[a] < c[b];
    });
    init(n);
    for(lli i = 0;i < p.size();i++){
        if(!same(r[p[i]],l[p[i]])) unite(r[p[i]],l[p[i]]),ans += c[p[i]];
    }
    cout << ans << endl;
    return 0;
}

C++: #include<bits/stdc++.h>
//#include"UnionFind.hpp"
using namespace std;

using Weight=long long;
struct Edge{
    int from,to;
    Weight weight;
};
bool operator<(const Edge& lhs,const Edge& rhs){
    return lhs.weight<rhs.weight;
}

using Edges=vector<Edge>;
using Graph=vector<Edges>;


Edges MinimumSpanningTree(int n,Edges edges){
    Edges res;
    UnionFind u(n);
    for(int i=0;i<edges.size();i++){
        if(!u.same(edges[i].from,edges[i].to)){
            res.push_back(edges[i]);
            u.unite(edges[i].from,edges[i].to);
        }
    }
    return res;
}

Edges MinimumSpanningTree(const Graph& g){
    Edges edges;
    for(int i=0;i<g.size();i++){
        copy(g[i].begin(),g[i].end(),back_inserter(edges));
    }
    auto res=MinimumSpanningTree(g.size(),edges);
    return res;
}

int main(){
    int n;
    cin>>n;
    Graph g(n);
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            Weight c;
            cin>>c;
            if(i==j) continue;
            g[i].push_back({i,j,c});
        }
    }
    auto mst=MinimumSpanningTree(g);
    cout<<accumulate(mst.begin(),mst.end(),Weight(0),[](const Weight& lhs,const Edge& rhs){return lhs+rhs.weight;})<<endl;
    return 0;
}