Go: package main

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

var scanner = bufio.NewScanner(os.Stdin)

func nextString() string {
	scanner.Scan()
	return scanner.Text()
}

func nextInt() int {
	n, err := strconv.Atoi(nextString())
	if err != nil {
		fmt.Printf("strconv.Atoi failed: %v\n", err)
	}
	return n
}

var infty = 1000000000

type DirectedGraphNodeID int

type DirectedGraphNode struct {
	key         DirectedGraphNodeID
	adjacents   []*DirectedGraphNode
	costs       []int
	distance    int
	predecessor *DirectedGraphNode
}

func newDirectedGraph(nNodes int) *DirectedGraph {
	graph := DirectedGraph{}
	graph.nodes = make([]*DirectedGraphNode, nNodes)
	for i := 0; i < nNodes; i++ {
		node := DirectedGraphNode{}
		node.key = DirectedGraphNodeID(i)
		node.distance = infty
		graph.nodes[i] = &node
	}
	return &graph
}

type DirectedGraph struct {
	nodes []*DirectedGraphNode
}

func (g *DirectedGraph) setAdjacency(i, j DirectedGraphNodeID, cost int) {
	g.nodes[i].adjacents = append(g.nodes[i].adjacents, g.nodes[j])
	g.nodes[i].costs = append(g.nodes[i].costs, cost)
}

func (g *DirectedGraph) print() {
	for i := 0; i < len(g.nodes); i++ {
		node := g.nodes[i]
		key := node.key
		strings := []string{strconv.Itoa(int(key)), strconv.Itoa(node.distance)}
		for j := 0; j < len(node.adjacents); j++ {
			nodeJ := fmt.Sprintf("(%v, %v)", node.adjacents[j].key, node.costs[j])
			strings = append(strings, nodeJ)
		}
		fmt.Printf("%v\n", strings)
	}
}

func (g *DirectedGraph) relaxEdge(l, r *DirectedGraphNode, w int) {
	if r.distance > l.distance+w {
		// fmt.Printf("%v -> %v, %v\n", l.key, r.key, l.distance+w)
		r.distance = l.distance + w
		r.predecessor = l
	}
}

func main() {
	scanner.Split(bufio.ScanWords)

	nNodes := nextInt()
	graph := newDirectedGraph(nNodes)

	for i := 0; i < nNodes; i++ {
		iNode := DirectedGraphNodeID(nextInt())
		nAdjacent := nextInt()
		for j := 0; j < nAdjacent; j++ {
			jNode := DirectedGraphNodeID(nextInt())
			cost := nextInt()
			graph.setAdjacency(iNode, jNode, cost)
		}
	}

	graph.nodes[0].distance = 0
	for iNode := 0; iNode < nNodes; iNode++ {
		for iLeft := 0; iLeft < len(graph.nodes); iLeft++ {
			nodeLeft := graph.nodes[iLeft]
			for iRight := 0; iRight < len(nodeLeft.adjacents); iRight++ {
				nodeRight := nodeLeft.adjacents[iRight]
				cost := nodeLeft.costs[iRight]
				graph.relaxEdge(nodeLeft, nodeRight, cost)
			}
		}
	}

	// graph.print()

	for iNode := 0; iNode < len(graph.nodes); iNode++ {
		node := graph.nodes[iNode]
		fmt.Println(node.key, node.distance)
	}
}

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