Go: package main

import (
	"bufio"
	"fmt"
	"log"
	"math"
	"os"
	"strconv"
	"strings"
)

type color int

const (
	white color = iota // 未訪問
	mst                // MSTとして確定
)

// 頂点
type node struct {
	matrix   []int // 隣接行列
	minToMst int   // MSTへの重み最小値
	parent   int   // 最小値の相手
	color    color
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	n := eGetInt(scanner)

	nodes := make([]node, n)
	for i := 0; i < n; i++ {
		nodes[i].matrix = eAtoi((strings.Fields(eGetline(scanner))))
		nodes[i].parent = -1
		nodes[i].minToMst = math.MaxInt16
		nodes[i].color = white
	}

	// 初回はnode[0]がMSTに入るように,minToMstを設定
	nodes[0].minToMst = 0
	for { // 全部チェックするまで

		// どの頂点を新たにMSTに取り込むか
		min := math.MaxInt16
		u := -1
		for i := 0; i < n; i++ {
			if nodes[i].color == mst {
				continue
			}
			if nodes[i].minToMst < min {
				u = i
				min = nodes[i].minToMst
			}
		}

		if u == -1 {
			break
		}
		// MSTに追加する頂点決定
		nodes[u].color = mst

		// MSTに属していない頂点それぞれについて,MSTとの最小の重みを更新
		for i := 0; i < n; i++ {
			if nodes[i].color == mst {
				continue
			}
			if nodes[i].matrix[u] == -1 {
				// 接してない
				continue
			}
			if nodes[i].matrix[u] < nodes[i].minToMst {
				// node[u]との重みが最小
				nodes[i].minToMst = nodes[i].matrix[u]
				nodes[i].parent = u
			}
		}
	}

	sum := 0
	for _, v := range nodes {
		// node[0]はparentが入っていない
		if v.parent != -1 {
			sum += v.matrix[v.parent]
		}
	}
	fmt.Println(sum)
}

func eGetInt(scanner *bufio.Scanner) int {
	t := eAtoi(strings.Fields(eGetline(scanner)))
	return t[0]
}

func eGetline(p *bufio.Scanner) string {
	if !p.Scan() {
		if err := p.Err(); err != nil {
			log.Fatal(err.Error())
		}
		return ""
	}
	return p.Text()
}

func eAtoi(s []string) []int {
	ints := make([]int, len(s))
	var err error
	for i, e := range s {
		ints[i], err = strconv.Atoi(e)
		if err != nil {
			log.Fatal(err.Error())
		}
	}
	return ints
}

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;
  
int n, M[MAX][MAX];
  
int prim() {
   int a, min;
   int d[MAX], p[MAX], color[MAX];
   
   for ( int i = 0; i < n; i++) {
      d[i] = INFTY;
      p[i] = -1;
      color[i] = WHITE;
   }
  
   d[0] = 0;
  
   while ( 1 ) {
      min = INFTY;
      a = -1;
  
      for ( int i = 0; i < n; i++ ) {
         if ( min > d[i] && color[i] != BLACK ) {
            a = i;
            min = d[i];
         }
      }
  
      if ( a == -1 ) break;
      color[a] = BLACK;
      for ( int v = 0; v < n; v++ ) {
         if ( color[v] != BLACK && M[a][v] != INFTY ) {
            if ( d[v] > M[a][v] ) {
               d[v] = M[a][v];
               p[v] = u;
               color[v] = GRAY;
            }
         }
      }
   }
  
   int sum = 0;
   for ( int i = 0; i < n; i++ ) {
      if ( p[i] != -1 ) sum = 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 == -1) ? INFTY : e;
      }
   }
  
   cout << prim() << endl;
  
   return 0;
}

C++: #include <bits/stdc++.h>

using ll = long long;
using namespace std;
using pii = pair<int, int>;

int INF = 1000000000;
int n, x;
std::vector<std::vector<pii>> g;
priority_queue<pii, std::vector<pii>, std::greater<pii>> pq;
std::vector<int> dist;
std::vector<bool> used;

int main() {
    std::cin >> n;
    dist.assign(n, INF);
    used.assign(n, false);
    g.assign(n, std::vector<pii>(0));
    for (int i = 0; i < n; i++) {
        for (int k = 0; k < n; k++) {
            std::cin >> x;
            if (x == -1) {
                continue;
            }
            g[i].push_back(make_pair(x, k));
        }
    }
    pq.push(std::make_pair(0, 0));
    used[0] = true;
    dist[0] = 0;
    while (!pq.empty()) {
        auto e = pq.top();
        pq.pop();
        used[e.second] = true;
        for (int i = 0; i < g[e.second].size(); i++) {
            if (used[g[e.second][i].second] == false && dist[g[e.second][i].second] > g[e.second][i].first) {
                dist[g[e.second][i].second] = g[e.second][i].first;
                pq.push(g[e.second][i]);
            }
        }
    }
    ll ans = 0;
    for (int i = 0; i < dist.size(); i++) {
        ans += dist[i];
    }
    std::cout << ans << std::endl;
}

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


struct edge
{
   int cost;
   int src;
   int dst;
};

edge e[5000];
int A[100][100];
int M=0;
int P[100];

void init(int N)
{
  for (int i=0; i<=N; ++i) P[i] = i;
}

int root(int a)
{
  if (P[a] == a) return a;
  return (P[a] = root(P[a]));
}

bool is_same_set(int a, int b)
{
  return root(a) == root(b);
}

void unite(int a, int b)
{
  P[root(a)] = root(b);
}

void checkEdges(int n)
{
    for(int r=0;r<n;r++)
        for(int c=r+1;c<n;r++)
    {
        if(A[r][c]>-1)
        {
            e[M].cost=A[r][c];
            e[M].src=r;
            e[M].dst=c;
            M+=1;
        }
    }
}

bool cmp(edge e1,edge e2)
{
    return e1.cost<=e2.cost;
}
int main()
{
    int n,count=0;
    cin>>n;
    init(n);
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++){
                cin>>A[i][j];
        }
    }
    checkEdges(n);
    sort(e,e+M,cmp);
    for (int i=0; i<M; ++i)
    {
        if(is_same_set(e[i].src,e[i].dst))
        {
            continue;
        }
        unite(e[i].dst,e[i].src);
        count+=e[i].cost;
    }
    cout<<count<<endl;
    //system("pause");
    return 0;
}

C++: /* primのアルゴリズム */
#include<iostream>
#include<stdio.h>
using namespace std;


static const int N_MAX=100;
static const int INFTY=(1<<21);
static const int WHITE=0;
static const int GRAY=1;
static const int BLACK=2;

int color[N_MAX];
int M[N_MAX][N_MAX];
int d[N_MAX];
int p[N_MAX];
int n;


int prim()
{
    int i,minv,u,v;
    for(i=0;i<n;i++)
    {
        color[i]=WHITE;
        d[i]=INFTY;
        p[i]=-1;
    }
    d[0]=0;

    while(true)
    {
        minv=INFTY;
        //T(最小全域木)に追加するノードuの探索
        for(i=0;i<n;i++)
        {
            //未選択でT-Vの接続がもっとも小さいノードの選択
            if(color[i]!=BLACK && d[i]<minv)
            {
                minv=d[i];
                u=i;
            }
        }

        //もし最小接続コストがINFTYなら探索終了
        if(minv==INFTY) break;

        //Tに追加されたuは選択済みのフラグを立てる
        color[u]=BLACK;

        //元グラフVからu-vで最小のコストのエッジをd[v]に保存
        //親も保存
        //探査はした証拠にGRAYにする
        //ここでの代入操作は次のループで上のfor文内で使われる
        for(v=0;v<n;v++)
        {
            //未選択でuとのエッジが存在するvについて
            if(color[v]!=BLACK && M[u][v]!=INFTY)
            {
                //そのエッジコストがvが記録する
                //T - (V-T)間の最小コストより小さければ
                //エッジコスト更新
                //vの親の更新
                if(M[u][v]<d[v])
                {
                    d[v]=M[u][v];
                    p[v]=u;
                    color[v]=GRAY;
                }
            }
        }

    }

    int sum=0;
    for(i=0;i<n;i++)
    {
        //親が存在すれば、i-p[i]間コストを加算
        if(p[i]!=-1) sum+=M[i][p[i]];
    }
    return sum;
}


int main()
{
    scanf("%d",&n);

    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            int e;
            scanf("%d",&e);
            M[i][j]=(e==-1) ? INFTY : e ;
        }
    }

    printf("%d",prim());
    printf("\n");

    return 0;
}