Go: package main

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

func main() {
	r := bufio.NewReader(os.Stdin)

	var n int
	fmt.Fscan(r, &n)
	cs := make([]map[int]int, n) // []v_i -> c_i
	for h := 0; h < n; h++ {
		var u, k int
		fmt.Fscan(r, &u, &k)
		m := make(map[int]int)
		for i := 0; i < k; i++ {
			var v, c int
			fmt.Fscan(r, &v, &c)
			m[v] = c
		}

		cs[u] = m
	}

	q := make(map[int]int)
	q[0] = 0
	visited := make(map[int]struct{})
	out := make([]int, n)

	for len(q) > 0 {
		u := top(q)
		for uu, c := range cs[u] {
			// Consider the connection between u and uu.
			if _, ok := visited[uu]; ok {
				continue
			}
			if d, ok := q[uu]; !ok || d > q[u]+c {
				q[uu] = q[u] + c
			}
		}

		out[u] = q[u]
		delete(q, u)
		visited[u] = struct{}{}
	}

	for u, d := range out {
		fmt.Println(u, d)
	}
}

func top(q map[int]int) int {
	minu := -1
	min := -1
	for u, d := range q {
		if min < 0 || d < min {
			minu = u
			min = d
		}
	}

	return minu
}

C++: #include<stdio.h>
#include<cstdlib>
// 0origin
// referred to http://www.deqnotes.net/acmicpc/dijkstra/
// 単純な方法の方

#define MAX_DATA 100
#define INF 1000001
#define NIL -2

int n;
typedef struct {
    int num;
    // ここから伸びるエッジの情報
    int edges_to[MAX_DATA]; // 各接続先の番号
    int edges_cost[MAX_DATA]; // 各エッジのコスト
    int edges_size; // エッジの本数
    
    // ダイクストラ法のためのデータ
    bool done; // 確定ノードか否か
    int cost; // このノードへの現時点で判明しているコスト
}Node;

Node node[MAX_DATA];

int min(int x, int y){
    return x < y ? x : y;
}

void Init(){
    for (int i = 0; i < n; i++) {
        node[i].done = false;
        node[i].cost = INF;
    }
}

void Dijkstra(){
    Init();
    node[0].cost = 0;
    /*
    while (1) {
        Node doneNode;
        doneNode.cost = NIL;
        for (int i = 0; i < n; i++) {
            printf("node[%d].done:%s cost:%d doneNode.cost:%d\n", i, node[i].done == true ? "true" : "false", node[i].cost, doneNode.cost);
            if (node[i].done == true || node[i].cost == INF) {
                continue;
            }
            if (doneNode.cost == NIL || node[i].cost < doneNode.cost) {
                doneNode = node[i];
            }
        }
        if(doneNode.cost == NIL){
            break;
        }
        
        .done = true;
        
        for (int i = 0; i < doneNode.edges_size; i++) {
            int to = doneNode.edges_to[i];
            int cost = doneNode.cost + doneNode.edges_cost[i];
            if (node[to].cost < 0 || cost < node[to].cost) {
                node[to].cost = cost;
            }
        }
    }*/
    
    Node doneNode[MAX_DATA];
    node[0].done = true;
    doneNode[0] = node[0];
    int NOFdoneNode = 1;
    while (NOFdoneNode < n) {
        int mincost = INF;
        for(int i = 0; i < NOFdoneNode; i++){ // doneNodeを動かす
            for(int j = 0; j < doneNode[i].edges_size; j++){ // doneNodeから伸びているnodeをうごかす
                //printf("%d to %d\n", doneNode[i].num, doneNode[i].edges_to[j]);
                if (node[doneNode[i].edges_to[j]].done) { // 確定ノードと確定ノードがつながっていたらスルー
                    //printf(" through\n");
                    continue;
                }
                //printf(" %d >?< %d\n", node[doneNode[i].edges_to[j]].cost, doneNode[i].cost + doneNode[i].edges_cost[j]);
                if(node[doneNode[i].edges_to[j]].cost >= doneNode[i].cost + doneNode[i].edges_cost[j]){ // 確定nodeたちからの最短距離を記録
                    node[doneNode[i].edges_to[j]].cost = doneNode[i].cost + doneNode[i].edges_cost[j];
                    if(mincost > node[doneNode[i].edges_to[j]].cost){ // mincostが更新されたらdoneNodeの最後尾を更新
                        mincost = node[doneNode[i].edges_to[j]].cost;
                        doneNode[NOFdoneNode] = node[doneNode[i].edges_to[j]];
                    }
                }
            }
        }
        node[doneNode[NOFdoneNode].num].done = true;
        //printf("%d is done\n", doneNode[NOFdoneNode].num);
        
        /*for(int i = 0; i < NOFdoneNode+1; i++){
            printf("%d,", doneNode[i].num);
        }
        printf("\n\n");*/
        NOFdoneNode++;
    }
}

int main(){
    int m;
    
    scanf("%d", &n);
    
    for(int i = 0; i < n; i++){
        scanf("%d%d", &m ,&m);
        node[i].edges_size = m;
        node[i].num = i;
        for (int j = 0; j < m; j++) {
            scanf("%d %d", &node[i].edges_to[j], &node[i].edges_cost[j]);
        }
        node[i].edges_to[m] = NIL;
        node[i].edges_cost[m] = NIL;
    }
    
#ifdef D
    for (int i = 0; i < n; i++) {
        printf("%d:", i);
        for (int j = 0; ; j++) {
            if(node[i].edges_to[j] == NIL){
                break;
            }
            printf("%d(%d) ", node[i].edges_to[j], node[i].edges_cost[j]);
        }
        printf("\n");
    }
#endif
    
    Dijkstra();
    
    for (int i = 0; i < n; i++) {
        printf("%d %d\n", i, node[i].cost);
    }
    
    return 0;
}

C++: #include <iostream>
#include <limits>

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)

constexpr int MAXN = 100;
constexpr int MAXINT = std::numeric_limits<int>::max();


int G[MAXN][MAXN];
int D[MAXN];
int C[MAXN];
int P[MAXN];
int n;

int main() {
    std::cin >> n;
    FOR(i, 0, n)
    FOR(j, 0, n)
    {
        G[i][j] = MAXINT;
    }

    FOR(i, 0, n){
        int id, e;
        std::cin >> id >> e;
        FOR(i, 0, e) {
            int v, c;
            std::cin >> v >> c;
            G[id][v] = c;
        }
    }

    FOR(i, 0, n) D[i] = MAXINT;

    int r = -1;
    D[0] = 0;
    while (true) {
        int mincost = MAXINT;
        int t;
        for (int i = 0; i < n; i++) {
            if ((C[i] == 0)  && (D[i] < mincost)) {
                mincost = D[i];
                t = i;
            }
        }

        if (mincost == MAXINT) {
            break;
        }

        C[t] = 1;
        P[t] = r;

        for (int i = 0; i < n; i++) {
            if ((C[i] == 0) && (G[t][i] != MAXINT) && ((D[t] + G[t][i]) < D[i])) {
                D[i] = D[t] + G[t][i];
            }
        }
        r = t;
    }
    FOR(i, 0, n) {
        std::cout << i << " " << D[i] << std::endl;
    }
}

C++: #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
static const int NMAX = 100;
#define INF (1 << 30)
int ADJ[NMAX][NMAX];

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

  for (int i = 0; i < n; i++) {
    int id, nn;
    cin >> id  >> nn;
    for (int j = 0; j < nn; j++) {
      int to, weight;
      cin >> to >> weight;
      ADJ[id][to] = weight;
    }
  }

  bool visited[n];
  int dist[n];

  // add node 0
  for (int i = 0; i < n; i++) {
    dist[i] = ADJ[0][i];
    visited[i] = false;
  }
  visited[0] = true;
  dist[0] = 0;

  while (true) {
    int minnode = -1;
    int mincost = INF;
    // find nearest node
    for (int i = 0; i < n; i++) {
      if (visited[i] == false && dist[i] < mincost) {
        minnode = i;
        mincost = dist[i];
      }
    }
    if (minnode == -1)
      break;

    // add node
    visited[minnode] = true;

    // update dist
    for (int i = 0; i < n; i++) {
      if (visited[i] == false)
        dist[i] = min(dist[i], dist[minnode] + ADJ[minnode][i]);
    }
  }

  for (int i = 0; i < n; i++)
    cout << i << " " << dist[i] << endl;
}

C++: a