Go: package main

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

const BIG_COST = 200000

const (
	ST_NOT_YET = iota
	ST_JOINED
)

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	nNodes := scanInt(sc)

	costs := make([][]int, nNodes)
	graph := make([][]int, nNodes)

	states := make([]int, nNodes)
	costSums := make([]int, nNodes)

	for i := 0; i < nNodes; i++ {
		costs[i] = make([]int, nNodes)
		costSums[i] = BIG_COST
	}

	for i := 0; i < nNodes; i++ {
		u := scanInt(sc)
		k := scanInt(sc)
		graph[u] = make([]int, k)
		for d := 0; d < k; d++ {
			v := scanInt(sc)
			graph[u][d] = v
			costs[u][v] = scanInt(sc)
		}
	}

	costSums[0] = 0
	for {
		minCost := BIG_COST
		var u int

		for i, cost := range costSums {
			if states[i] != ST_JOINED && cost < minCost {
				minCost = cost
				u = i
			}
		}

		if minCost == BIG_COST {
			break
		}

		states[u] = ST_JOINED

		for _, v := range graph[u] {
			cost := minCost + costs[u][v]
			if cost < costSums[v] {
				costSums[v] = cost
			}
		}
	}

	w := bufio.NewWriter(os.Stdout)
	for i, cost := range costSums {
		fmt.Fprintf(w, "%d %d\n", i, cost)
	}
	w.Flush()
}

func scanInt(sc *bufio.Scanner) int {
	sc.Scan()
	v, _ := strconv.Atoi(sc.Text())
	return v
}

C++: #include "bits/stdc++.h"
 
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;

#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
 
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define FORL(i,a,b) for(LL i=(a);i<(b);++i)
#define REPL(i,n)  FORL(i,0,n)
#define ALL(a) (a).begin(),(a).end()
 
const double EPS = 1e-10;
const double PI  = acos(-1.0);

 //debug func
template<typename T>
void vprint(vector<T> v) {
    for(auto x : v) {
        cerr << x << " ";
    }
    cerr << endl;
}
 
template<typename T>
void vvprint(vector<vector<T>> vv) {
    REP(i, vv.size()) {
        REP(j, vv[i].size()) {
            cerr << vv[i][j] << " ";
        }
        cerr << endl;
    }
}

template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k, const Iterator last)
{
   /* Credits: Thomas Draper */
   if ((first == last) || (first == k) || (last == k))
      return false;
   Iterator itr1 = first;
   Iterator itr2 = last;
   ++itr1;
   if (last == itr1)
      return false;
   itr1 = last;
   --itr1;
   itr1 = k;
   --itr2;
   while (first != itr1)
   {
      if (*--itr1 < *itr2)
      {
         Iterator j = k;
         while (!(*itr1 < *j)) ++j;
         iter_swap(itr1,j);
         ++itr1;
         ++j;
         itr2 = k;
         rotate(itr1,j,last);
         while (last != j)
         {
            ++j;
            ++itr2;
         }
         rotate(k,itr2,last);
         return true;
      }
   }
   rotate(first,k,last);
   return false;
}

inline double get_time_sec(void){
    return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count())/1000000000;
}

template<typename T>
T lcm(T a, T b) {
    return (a / __gcd(a, b)) * b;
}

template<typename T>
map<T, T> prime_list(T n) {
    map<T, T> ret;
    for(T i = 2; i*i <= n; i++) {
        if(n % i == 0) {
            ret[i] = 0;
            while(n % i == 0) {
                n /= i;
                ret[i]++;
            }
        }
    }
    if(n != 1) ret[n]++;
    return ret;
}

#define MOD 1000000007

LL mypow(LL a, LL n) {
    if(n == 0) return 1;
    if(n == 1) return a % MOD;
    if(n % 2 == 1) return (a * mypow(a, n-1)) % MOD;
    LL t = mypow(a, n/2);
    return (t * t) % MOD; 
}

LL mycomb(LL n, LL k) {
    if(n == 0 || n == k) return 1;
    LL x = 1, y = 1;
    REP(i, k) {
        x = x * (n-i) % MOD;
        y = y * (i+1) % MOD;
    }
    return x * mypow(y, MOD - 2) % MOD;
}

#define INF 1e8

struct edge {int u, v, cost;};

vector<edge> g;
VI par, rnk;

int root(int x) {
    if(par[x] == x) return x;
    else return par[x] = root(par[x]);
}

int same(int x, int y) {
    x = root(x);
    y = root(y);
    return x == y;
}

void unite(int x, int y) {
    x = root(x);
    y = root(y);
    if(rnk[x] > rnk[y]) {
        par[y] = x;
    } else {
        par[x] = y;
        if(rnk[x] == rnk[y]) rnk[y]++;
    }
}

int main(void) {
    cin.tie(0); ios::sync_with_stdio(false);
    int n;
    cin >> n;
    VVI g(n, VI(n, INF));
    REP(i, n) {
        int idx, k;
        cin >> idx >> k;
        REP(j, k) {
            int v, c;
            cin >> v >> c;
            g[idx][v] = c;
        }
    }
    // vvprint(g);
    VVI ans(n, VI(n, INF));
    REP(i, n) REP(j, n) ans[i][j] = i == j ? 0 : g[i][j];
    REP(k, n) REP(i, n) REP(j, n) ans[i][j] = min(ans[i][j], ans[i][k] + ans[k][j]);
    // vvprint(ans);
    REP(i, n) cout << i << " " << ans[0][i] << endl;
}

C++: #include<iostream>
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];

void dijkstra() {
	int color[n],d[n],p[n];
	for(int i=0;i<n;i++){
		color[i]=WHITE;
		d[i]=INF;
		p[i]=-1;
	}
	d[0]=0;
	while(true){
		int minv=INF;
		int u=-1;
		for(int i=0;i<n;i++){
			if(color[i]==BLACK) continue;
			if(minv>d[i]){
				minv=d[i];
				u=i;
			}
		}
		if(u==-1) break;
		color[u]=BLACK;
		for(int v=0;v<n;v++){
			if(color[v]==BLACK) continue;
			if(m[u][v]==INF) continue;
			if(d[v]>m[u][v]+d[u]){
				d[v]=m[u][v]+d[u];
				color[v]=GRAY;
			}
		}
	}
	for(int i=0;i<n;i++){
		cout << i << " " << d[i] << endl;
	}
}

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

	for(int i=0;i<n;i++){
		int id, k;
		cin >> id >> k;
		for(int j=0;j<k;j++){
			int id2,w;
			cin >> id2 >> w;
			m[i][id2]=w;
		}
	}
	dijkstra();
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
int main(){
    int n, u, k, v, c, l[101][101], ans[101];
    for (int i = 0; i < 101; i++) ans[i] = 1e9;
    ans[0] = 0;
    for (int i = 0; i < 101; i++) for (int j = 0;j < 101; j++)l[i][j] = 1e9;
    queue<int> q;
    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> u >> k;
        for(int j = 0;j < k; j++){
            cin >> v >> c;
            l[u][v] = c;
        }
    }
    q.push(0);
    while(!q.empty()){
        int _u = q.front();
        q.pop();
        for (int i = 0; i < n; i++){
            if (l[_u][i] != 1e9){
                if (ans[i] > ans[_u] + l[_u][i]){
                    ans[i] = ans[_u] + l[_u][i];
                    q.push(i);
                }
            }
        }
    }
    for (int i = 0 ; i < n; i++) cout << i << " "<< ans[i] << endl;
}

C++: #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <stack>
#include <vector>
using namespace std;
const int maxx=110;
const int infinity=(1<<30);

int A[maxx][maxx],d[maxx];
bool flag[maxx];

int main (){
	int n,a,b,c;
	cin>>n;
	for(int i=0;i<maxx;i++){
		flag[i]=false;
		d[i]=infinity;
		for(int j=0;j<maxx;j++){
			A[i][j]=infinity;
		}
	}
	for(int i=0;i<n;i++){
		cin>>a>>b;
		for(int j=0;j<b;j++){
			cin>>c>>A[a][c];
		}
	}
	
	d[0]=0;
	while(1){
		int minv=infinity,mini=-1;
		for(int i=0;i<n;i++){
			if(flag[i]==false && d[i]<minv){
				minv=d[i];
				mini=i;
			}
		}
		if(mini==-1 || minv==infinity) break;
		flag[mini]=true;
		for(int i =0;i<n;i++){
			if(A[mini][i]!=infinity && flag[i]==false){
				if(d[mini]+A[mini][i]<d[i]){
					d[i]=d[mini]+A[mini][i];
				}
			}
		}
		
	}
	for(int i=0;i<n;i++) cout<<i<<" "<<d[i]<<endl;
	
	return 0;

}