Go: package main

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

const (
	MAX = 100
	INF = 1 << 21
	WHITE = 0
	GRAY = 1
	BLACK = 2
)

var (
	n int
	M [MAX][MAX]int
)

func prim() int {
	var u, minv int
	var d [MAX]int
	var p [MAX]int
	var color [MAX]int

	for i := 0; i < n; i++ {
		d[i] = INF
		p[i] = -1
		color[i] = WHITE
	}
	d[0] = 0
	for {
		minv = INF
		u = -1
		for i := 0; i < n; i++ {
			if minv > d[i] && color[i] != BLACK {
				u = i
				minv = d[i]
			}
		}
		if u == -1 {
			break
		}
		color[u] = BLACK
		for v := 0; v < n; v++ {
			if color[v] != BLACK && M[u][v] != INF {
				if d[v] > M[u][v] {
					d[v] = M[u][v]
					p[v] = u
					color[v] = GRAY
				}
			}
		}
	}
	sum := 0
	for i := 0; i < n; i++ {
		if p[i] != -1 {
			sum += M[i][p[i]]
		}
	}
	return sum
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Scan()
	n, _ = strconv.Atoi(scanner.Text())
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			scanner.Scan()
			e, _ := strconv.Atoi(scanner.Text())
			if e == -1 {
				M[i][j] = INF
			} else {
				M[i][j] = e
			}
		}
	}
	fmt.Println(prim())
}

C++: #include<iostream>
#include<algorithm>
#define wh 0
#define gr 1
#define bl 2
#define inf 2001
#define null (-1)
#define Max 100 
using namespace std;
int color[Max],m[Max][Max];
int d[Max],p[Max],n;
void prim(){
int i,j,u;
	for(i=0;i<n;i++){
	color[i]=wh;
		d[i]=inf;
	}
	d[0]=0;
	p[0]=-1;
	while(true){
	int mincost=inf;
		for(i=0;i<n;i++){
			if(color[i]!=bl && d[i]<mincost){
			mincost=d[i];
				u=i;
			}
		}
		if(mincost==inf)
		break;
		color[u]=bl;
		for(int v=0;v<n;v++){
			if(color[v]!=bl && m[u][v]!=null){
				if(m[u][v]<d[v]){
				d[v]=m[u][v];
					p[v]=u;
					color[v]=gr;
				}
			}
		}
	}
}

main(){
	int i,j;
	cin>>n;
	for(i=0;i<n;i++){
		for(j=0;j<n;j++){
	cin>>m[i][j];
			m[j][i]=m[i][j];
		}
	}
	prim();
	int ans=0;
	for(i=0;i<n;i++)
	ans+=d[i];
	cout<<ans<<endl;
	return 0;
}

C++: #include<iostream>
using namespace std;
static const int MAX = 100;
static const int INFTY = (1<<21);
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;

struct Node{
  int color, dist, parent;
};

int n, M[MAX][MAX];
Node node[MAX];

void Printnodes(){
  string col[3] = {"WHITE", "GRAY ", "BLACK"};
  for(int i = 0; i < n; i++){
    cout << "nodeID : " << i ;
    cout << " color : " << col[node[i].color];
    cout << " parent : " << node[i].parent;
    cout << " dist : " << node[i].dist << endl;
  }
  cout << endl;
}

int main(){
  cin >> n;

  for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++){
      cin >> M[i][j];
    }
    node[i].color = WHITE;
    node[i].dist = INFTY;
    node[i].parent = -1;
  }

  int p = 0;
  node[p].dist = 0;

  while(true){
    //Printnodes();

    for(int i = 0; i < n; i++){
      if(M[p][i] >= 0 && node[i].color != BLACK){
        if(node[i].dist > M[p][i]){
          node[i].dist = M[p][i];
          node[i].parent = p;
          node[i].color = GRAY;
        }
      }
    }

    int min_d = INFTY;
    p = -1;
    for(int i = 0; i < n; i++){
      if(node[i].dist < min_d && node[i].color != BLACK){
        min_d = node[i].dist;
        p = i;
      }
    }

    if(p == -1)
      break;

    node[p].color = BLACK;
    //cout << "node " << p << " turns to BLACK!" << endl;
  }

  int sum = 0;
  for(int i = 0; i < n; i++){
    if(node[i].parent != -1)
      sum += M[i][node[i].parent];
  }
  cout << sum << endl;
  return 0;
}

C++: #include <iostream>
#include <vector>
#include <queue>
#define to first
#define cost second
const int inf=1e9+7;
using namespace std;
int main(){

  int n,tmp,r=0,flag[100]={},v=0;
  cin>>n;
  vector <pair<int,int> > gl[n];
  priority_queue <pair<int,int> ,vector<pair<int,int> >, greater<pair<int,int> > >q;
  //for(int i=1;i<n;i++) mincost[i]=inf;                                                                                                                                                       

  for(int i=0;i<n;i++) for(int j=0;j<n&&cin>>tmp;j++) if(tmp!=-1) gl[i].push_back(make_pair(j,tmp));
  int now=0;
  for(int j=0;j<n-1;j++){
    for(int i=0;i<gl[now].size();i++) if(!flag[gl[now][i].to]) q.push(make_pair(gl[now][i].cost,gl[now][i].to));
    flag[now]=1;
    // cout<<now<<" "<<q.top().first<<endl;                                                                                                                                                    
    for(;flag[q.top().second]||q.empty();) q.pop();
    if(q.empty()) break;
    r+=q.top().first;
    now=q.top().second;
    q.pop();
  }
  cout<<r<<endl;
  return 0;

}

C++: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;

enum state { New, Working, Done };

int main()
{
	int n;
	cin >> n;
	vector<vector<int>> am(n, vector<int>(n));
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) cin >> am[i][j];
	}

	vector<int> d(n, INT_MAX), p(n, INT_MAX);
	vector<state> status(n);
	d[0] = 0;
	p[0] = -1;
	status[0] = Working;
	while (true) {
		int minv = INT_MAX;
		int node = -1;
		for (int i = 0; i < n; i++) {
			if (d[i] < minv && status[i] != Done) {
				minv = d[i];
				node = i;
			}
		}
		if (node == -1) break;
		status[node] = Done;
		for (int i = 0; i < n; i++) {
			if (am[node][i] != -1 && am[node][i] < d[i] && status[i] != Done) {
				d[i] = am[node][i];
				p[i] = node;
				status[i] = Working;
			}
		}
	}
	cout << accumulate(d.begin(), d.end(), 0) << endl;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n)   FOR(i,0,n)
#define pb emplace_back
typedef long long ll;
typedef pair<int,int> pint;

const int MAX_N=101;
struct edge{
    int src,dst,cost;
    edge(int src,int dst,int cost):
    src(src),dst(dst),cost(cost){}
    };
bool operator < (const edge &m,const edge &f){
    return m.cost!=f.cost?m.cost<f.cost:
    m.src!=f.src?m.src<f.src:m.dst<f.dst;
}
struct UnionFind{
    int par[MAX_N],rank[MAX_N]; 
    void init(int n){
        for (int i=0;i<n;i++){par[i]=i;rank[i]=0;}
    } 
    int find(int x){
        if (x==par[x]) return (x);
        return (par[x]=find(par[x]));
    }
    void unite(int x, int y){
        x=find(x);y=find(y);       
        if(x==y) return;
        if(rank[x]<rank[y]){par[x]=y;}
        else{par[y]=x;if(rank[x]==rank[y]) rank[x]++;}
    } 
    bool same(int x, int y){return (find(x) == find(y));} 
};
vector<edge> ve;
int n;
int kruskal(){
    sort(ve.begin(),ve.end());
    UnionFind uf;
    uf.init(n);
    int res=0;
    rep(i,ve.size()){
        edge m=ve[i];
        if(!uf.same(m.src,m.dst)){
            uf.unite(m.src,m.dst);
            res +=m.cost;
        }
    }
    return res;
}
int main(){
    cin>>n;
    int a;
    rep(i,n){
        rep(j,n){
            cin>>a;
            if(a!=-1) ve.pb(edge(i,j,a));
        }
    }
    cout<<kruskal()<<endl;
    return 0;
}

C++: #include<iostream>
#include<vector>
#include<queue>
using namespace std;
enum COLOR{WHITE, BLACK};

struct Edge{
    int w, i, j;
    Edge(int w_, int i_, int j_) : w(w_), i(i_), j(j_) {}
    bool operator< (const Edge& right) const{
        return w > right.w;
    }
};

int main(){
    int n;
    cin >> n;
    vector<vector<int> > G(n, vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> G[i][j];
            if (G[i][j] == -1) G[i][j] = 1e8;
        }
    }
    vector<COLOR> state(n, WHITE);
    priority_queue<Edge> prim;
    state[0] = BLACK;
    int sum = 0;
    int idx_new_gray = 0;
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (state[j] != WHITE) continue;
            prim.push(Edge(G[idx_new_gray][j], idx_new_gray, j));
        }
        while (state[prim.top().j] == BLACK) prim.pop();
        sum += G[prim.top().i][prim.top().j];
        state[prim.top().j] = BLACK;
        idx_new_gray = prim.top().j;
        prim.pop();
    }
    cout << sum << endl;
    return 0;
}