Go: package main

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

const R = 100000000

var sc = bufio.NewScanner(os.Stdin)

var n int
var A [101][101]int

func nextInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}
func prim() int {
	var u, Minimum, sum int
	var d, p, color [101]int

	for i := 0; i < n; i++ {
		d[i] = R
		p[i] = -1
		color[i] = 0
	}
	d[0] = 0

	for {
		Minimum = R
		u = -1
		for i := 0; i < n; i++ {
			if Minimum > d[i] && color[i] != 2 {
				u = i
				Minimum = d[i]
			}
		}
		if u == -1 {
			break
		}
		color[u] = 2
		for j := 0; j < n; j++ {
			if color[j] != 2 && A[u][j] != R {
				if d[j] > A[u][j] {
					d[j] = A[u][j]
					p[j] = u
					color[j] = 1
				}
			}
		}
	}

	for i := 0; i < n; i++ {
		if p[i] != -1 {
			sum += A[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++ {
			e := nextInt()
			if e == -1 {
				A[i][j] = R
			} else {
				A[i][j] = e
			}
		}
	}
	fmt.Println(prim())
}

C++: /*
 * a.cc: 
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>

using namespace std;

/* constant */

const int MAX_N = 100;

/* typedef */

struct Edge {
  int i, j, c;
  Edge() {}
  Edge(int _i, int _j, int _c): i(_i), j(_j), c(_c) {}
  bool operator<(const Edge &e) const { return c < e.c; }
};

typedef vector<Edge> ve;

struct UFT {
  int links[MAX_N], ranks[MAX_N], sizes[MAX_N];

  void clear(int n) {
    for (int i = 0; i < n; i++) links[i] = i, ranks[i] = sizes[i] = 1;
  }
  UFT() {}
  UFT(int n) { clear(n); }

  int root(int i) {
    int i0 = i;
    while (links[i0] != i0) i0 = links[i0];
    return (links[i] = i0);
  }

  int rank(int i) { return ranks[root(i)]; }
  int size(int i) { return sizes[root(i)]; }
  bool same(int i, int j) { return root(i) == root(j); }

  int merge(int i0, int i1) {
    int r0 = root(i0), r1 = root(i1), mr;
    if (r0 == r1) return r0;
    if (ranks[r0] == ranks[r1]) {
      links[r1] = r0;
      sizes[r0] += sizes[r1];
      ranks[r0]++;
      mr = r0;
    }
    else if (ranks[r0] > ranks[r1]) {
      links[r1] = r0;
      sizes[r0] += sizes[r1];
      mr = r0;
    }
    else {
      links[r0] = r1;
      sizes[r1] += sizes[r0];
      mr = r1;
    }
    return mr;
  }
};

/* global variables */

/* subroutines */

/* main */

int main() {
  int n;
  cin >> n;

  ve es;

  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) {
      int ai;
      cin >> ai;
      if (ai >= 0) es.push_back(Edge(i, j, ai));
    }
  sort(es.begin(), es.end());

  UFT uft(n);
  int en = es.size(), sum = 0;

  for (int i = 0; i < en; i++) {
    Edge &ei = es[i];
    if (! uft.same(ei.i, ei.j)) {
      uft.merge(ei.i, ei.j);
      sum += ei.c;
    }
  }

  printf("%d\n", sum);
  return 0;
}

C++: // プリム法 最小全域木 Minimum Spanning Tree
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
using namespace std;
static const int MAX = 100;
static const int INF = (1<<21);
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;

int n, M[MAX][MAX]; //M:隣接行列

int prim() {
    int u, minv;
    int distance[MAX], parent[MAX], color[MAX];

    for(int i = 0; i < n; i++) {
        distance[i] = INF;
        parent[i] = -1;
        color[i] = WHITE;
    }

    distance[0] = 0;

    while (true) {
        minv = INF;
        u = -1;
        for(int i = 0; i < n; i++) {
            if (minv > distance[i] && color[i] != BLACK) {
                u = i;
                minv = distance[i];
            }
        }

        if (u == -1)
            break;

        color[u] = BLACK;
        for(int v = 0; v < n; v++) {
            if (color[v] != BLACK && M[u][v] != INF) {
                if (distance[v] > M[u][v]) {
                    distance[v] = M[u][v];
                    parent[v] = u;
                    color[v] = GRAY;
                }
            }
        }
    }

    int sum = 0;
    for(int i = 0; i < n; i++) {
        if (parent[i] != -1)
            sum  += M[i][parent[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 == -1) ? INF : e;
        }
    }

    cout << prim() << endl;
    
    return 0;
}

C++: #include <climits>
#include <iostream>
#include <vector>

using namespace std;

// calculate Minimum Spanning Tree with Prim's algorithm
void mst(vector<vector<int>>& g, vector<int>& weights) {
    int n_vertex = weights.size();
    vector<bool> mst(n_vertex, false);

    weights[0] = 0;
    while (true) {
        int idx;
        int min_weight = INT_MAX;
        for (int i = 0; i < n_vertex; ++i) {
            if (!mst[i] && weights[i] < min_weight) {
                idx = i;
                min_weight = weights[i];
            }
        }

        if (min_weight == INT_MAX)
            break;

        mst[idx] = true;

        for (int i = 0; i < n_vertex; ++i) {
            if (!mst[i] && g[idx][i] != -1)
                weights[i] = min(weights[i], g[idx][i]);
        }
    }
}

int main() {
    int n;
    cin >> n;

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

    vector<int> weights(n, INT_MAX);
    mst(g, weights);

    int sum_of_weights = 0;
    for (int i = 0; i < n; ++i)
        sum_of_weights += weights[i];
    cout << sum_of_weights << '\n';
}

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

const int N = 100;
int n;
int A[N][N];
bool visit[N] = {0};
priority_queue< pair<int, int> > Q;

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

	Q.push(pair<int, int>(0,0));

	int cost = 0;

	while (Q.size())
	{
		pair<int, int> q = Q.top();
		Q.pop();
		int k = q.second;
		if (visit[k]) continue;
		cost += q.first;
		visit[k]=true;
		for(int j=0;j<n;j++)
		{
			int c = A[k][j];
			if (c <= 0) continue;
			if (visit[j]) continue;
			Q.push(pair<int, int>(-c,j));
		}
	}

	cout << -cost << endl;
		
	return 0;
}

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

const int N = 100;
int n;
int A[N][N];
bool visit[N] = {0};
priority_queue< pair<int, int> > Q;

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

	Q.push(pair<int, int>(0,0));
	visit[0] = true;

	int cost = 0;

	while (Q.size())
	{
		pair<int, int> q = Q.top();
		Q.pop();
		int k = q.second;
		if (visit[k]) continue;
		cost += q.first;
		visit[k]=true;
		for(int j=0;j<n;j++)
		{
			int c = A[k][j];
			if (c <= 0) continue;
			if (visit[j]) continue;
			Q.push(pair<int, int>(-c,j));
		}
	}

	cout << -cost << endl;
		
	return 0;
}