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
	for len(edges) > 0 {
		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
	}
	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)
}

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;
}

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

#define MAX (1<<21)

int n,M[101][101];
int vis[101],d[101],p[101];

int prim(){
    int u,minv,i,v,j;
    for( i = 0; i < n; i++ ){
        d[i] = MAX;
        p[i] = -1;
    }
    d[0] = 0;
    while(1){
        minv = MAX;
        u = -1;
        for( i = 0; i < n; i++ ){
            if( minv > d[i] && !vis[i] ){
                u = i;
                minv = d[i];
            }
        }
        if( u == -1 ) break;
        vis[u] = 1;
        for( v = 0; v < n; v++ ){
            if( !vis[v] && M[u][v] != MAX ){
                if( d[v] > M[u][v] ){
                    d[v] = M[u][v];
                    p[v] = u;
                }
            }
        }
    }
    int sum = 0;
    for( i = 0; i < n; i++ ){
        if( p[i] != -1 ) sum += M[i][p[i]];
    }
    return sum;
}


int main(){
    int i,j,k,m;
    cin >> n;
    for( i = 0; i < n; i++ ){
        for( j = 0; j < n; j++ ){
            cin >> k;
            M[i][j] = (k == -1) ? MAX : k;
        }
    }
    cout << prim() << endl;
}