Go: package main

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

//util
var sc = bufio.NewScanner(os.Stdin)

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func printList(list []int) {
	n := len(list)
	buf := bufio.NewWriter(os.Stdout)
	for _, v := range list[0 : n-1] {
		buf.Write([]byte(fmt.Sprintf("%d ", v)))
	}
	buf.Write([]byte(fmt.Sprintf("%d\n", list[n-1])))
	buf.Flush()
}

func max(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func min(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

//solve
const (
	MAX   = 100
	INFTY = (1 << 21)
	WHITE = 0
	GRAY  = 1
	BLACK = 2
)

//V: グラフの頂点全体の集合
//T: MSTに属する頂点の集合
var (
	n     int
	M     [MAX][MAX]int //重みを記録する隣接行列
	color [MAX]int
	p     [MAX]int //MSTにおける頂点の親を記録
	d     [MAX]int //Tに属する頂点と、V−Tに属する頂点を繋ぐ辺の中で、重みが最小のものを記録
)

func prim() int {
	var u, minv int
	//初期化
	for i := 0; i < n; i++ {
		d[i] = INFTY
		p[i] = -1
		color[i] = WHITE
	}

	d[0] = 0

	for {
		//頂点uを決めていく
		//つまり、Tに属する頂点と、V−Tに属する頂点を繋ぐ辺の中で、重みが最小のものを決める
		minv = INFTY
		u = -1
		for i := 0; i < n; i++ {
			//未訪問かつ、辺の重みが最小となるuを選ぶ
			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] != INFTY {
				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() {
	sc.Split(bufio.ScanWords)
	n = nextInt()

	for i := 0; i < n; i++ {

		for j := 0; j < n; j++ {
			tmp := nextInt()
			if tmp == -1 {
				tmp = INFTY
			}
			M[i][j] = tmp
		}

	}

	fmt.Println(prim())

}

C++: #include<iostream>
#include<vector>
using namespace std;

enum color{WHITE, GRAY, BLACK};

int calc(vector<vector<int> >& G, vector<color>& state){
    int i_min = 0;
    int j_min = 0;
    for (int i = 0; i < G.size(); i++) {
        if (state[i] == WHITE || state[i] == BLACK) {
            continue;
        }
        bool is_black = true;
        for (int j = 0; j < G[i].size(); j++) {
            if (state[j] == WHITE){
                is_black = false;
                if (G[i][j] < G[i_min][j_min]) {
                    i_min = i;
                    j_min = j;
                }
            }
        }
        if (is_black) state[i] = BLACK;
    }
    state[j_min] = GRAY;
    return G[i_min][j_min];
}

int Prim(vector<vector<int> >& G) {
    vector<color> state(G.size(), WHITE);
    state[0] = GRAY;
    int ret = 0;

    for (int i = 0; i < G.size() - 1; i++) {
        ret += calc(G, state);
    }
    return ret;
}

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] = 1e6;
        }
    }

    cout << Prim(G) << endl;

    return 0;
}

C++: #include<cstdio>
#include<iostream>
using namespace std;
int visited[101], d[101], adj[101][101];
int n;
const int INFTY = (1<<30);
void prim()
{
  for(int i=0; i<n; i++)
  {
    visited[i] = 0; d[i] = INFTY;
  }
  d[0] = 0;
  while(1)
  {
    int mincost = INFTY; int u= -1;
    for(int i=0; i<n; i++)
    {
      if(mincost > d[i] && visited[i] == 0)
      {
        mincost = d[i];
        u = i;
      }
    }
    if (mincost == INFTY) break;
    visited[u] = 1;
    for(int i=0; i<n; i++)
    {
      if(adj[u][i] != -1 && visited[i] == 0)
      {
        if(d[i] > adj[u][i])
          d[i] = adj[u][i];
      }
    }
  }
  int sum=0;
  for(int i=0; i<n; i++)
  {
    sum += d[i];
  }
  printf("%d\n", sum);
}
int main()
{
  //int n;
  scanf("%d", &n);
  for(int i=0; i<n; i++)
    for(int j=0; j<n; j++)
      scanf("%d", &adj[i][j]);

  prim();
  return 0;
}

C++: #include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <tuple>
#include <functional>
#include <numeric>
#include <cmath>
#include <iomanip>
#include <map>
#include <random>
#include <cstdlib>
#define INT_MAX 2147483647
#define INT_MIN -2147483646
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;

static const int N = 105;

struct vertex {
	int id;
	int p;
	int d;
	bool operator<(const vertex & another) const {
		return (d != another.d ? d>another.d : id>another.id);
	}
};

int main() {
	vvi mx(N, vi(N, -1));
	int n;
	cin >> n;
	Loop(i, n) {
		Loop(j, n) {
			int a;
			cin >> a;
			mx[i][j] = a;
		}
	}
	//
	vi color(N, 0); //0,1,2
	priority_queue<vertex> q;
	q.push({ 0,-1,0});
	int ret = 0;
	while(q.size() > 0) {//?
		vertex v = q.top();
		q.pop();
		if (color[v.id] == 2) continue;
		color[v.id] = 2;
		ret += v.d;
		Loop(j, n) {
			if (mx[v.id][j] != -1 && color[j] != 2){
					q.push({ j, v.id,mx[v.id][j] });
					color[j] = 1;
			}
		}
	}
	cout << ret << endl;
	return 0;
}

C++: #include <iostream>
#include <cstdio>
#include <climits>
#include <cmath>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#define MAX 100
#define INFTY 1<<30 // 2^30
using namespace std;
typedef long long llong;
static const int NIL = -1;
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;

int n, M[MAX][MAX];

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

  for(int i = 0; i < n; i++)
  {
    d[i] = INFTY;
    p[i] = NIL;
    color[i] = WHITE;
  }

  d[0] = 0;
  while(1)
  {
    minv = INFTY;
    u = NIL;
    for(int i = 0; i < n; i++)
    {
      if(minv > d[i] && color[i] != BLACK)
      {
        u = i;
        minv = d[i];
      }
    }
    if(u == NIL) break;
    color[u] = BLACK;
    for(int v = 0; v < n; v++)
    {
      if(color[v] != BLACK && M[u][v] != INFTY)
      {
        if(d[v] > M[u][v])
        {
          d[v] = M[u][v];
          p[v] = u;
          color[v] = GRAY;
        }
      }
    }
  }
  int sum = 0;
  for(int i = 0; i < n; i++)
  {
    //cerr << p[i] << endl;
    if(p[i] != NIL) sum += M[i][p[i]];
  }
  return sum;
}


int main()
{
  cin >> n;
  for(int i = 0; i < n; i++)
  {
    for(int j = 0; j < n; j++)
    {
      int e; cin >> e;
      M[i][j] = (e == NIL) ? INFTY : e;
      //cerr << M[i][j] << endl;
    }
  }
  cout << prim() << endl;
  return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
//#define ll long long
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define rep(i, n) REP(i, 0, n)
#define rep_rev(i, n) for (int (i) = (int)(n) - 1 ; (i) >= 0 ; --(i))
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
#define all(x) (x).begin(),(x).end()
ll t1,t2,t3;
const ll mod = 1000000007;
const int INF = 1e9;
const ll INFLONG = 1e18;

int main(){
  ll n;
  cin >> n;
  vector<vector<ll>> vec(n,vector<ll>(n));
  rep(i,n){
    rep(j,n){
      cin >> vec[i][j];
    }
  }
  vector<ll> arr(n,0);
  arr[0] = 1;
  priority_queue<pair<ll,ll>> pq;
  rep(i,n){
    if(vec[0][i] != -1){
      pq.push(make_pair(-vec[0][i],i));
    }
  }
  pair<ll,ll> pa;
  ll ans = 0;
  while(!pq.empty()){
    pa = pq.top();
    pq.pop();
    if(arr[pa.second] == 0){
      arr[pa.second] = 1;
      ans -= pa.first;
      rep(i,n){
        if(vec[pa.second][i] != -1){
          pq.push(make_pair(-vec[pa.second][i],i));
        }
      }
    }
  }
  cout << ans << endl;
}