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 <iostream>
#include <vector>
#define INFTY 10000000
using namespace std;
int n,G[100][100];
int d[100],flag[100];
vector<int>path;
void dijkstra(){
    path.push_back(0);
    //int distance=0;
    int mini,min;
    while(path.size()<n){
        min=INFTY;
        int index=path.size()-1;
        //distance+=path[path.size()-1];
        for(int i=1;i<n;i++)
        {
            int temp=d[path[index]]+G[path[index]][i];
            if(d[i]>temp)
                d[i]=temp;
        }
        for(int i=1;i<n;i++)
        {
            if(flag[i])continue;
            if(d[i]<min)
            {
                min=d[i];
                mini=i;
            }
        }
        path.push_back(mini);
        flag[mini]=1;
        //distance+=path[path.size()-1];
    }
}
int main()
{
    int u,k,v,c;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        d[i]=INFTY;
        flag[i]=0;
        for(int j=0;j<n;j++)
            G[i][j]=INFTY;
    }
    for(int i=0;i<n;i++)
    {
        cin>>u>>k;
        for(int j=0;j<k;j++)
        {
            cin>>v>>c;
            G[u][v]=c;
        }
    }
    d[0]=0;
    dijkstra();
    for(int i=0;i<n;i++)
        cout<<i<<' '<<d[i]<<endl;
    return 0; 
}

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

void dijkstra(){
	int minv;
	int d[MAX], color[MAX];
	
	for(int i=0;i < n;++i){
		d[i] = INFTY;
		color[i] = WHITE;
	}
	
	d[0] = 0;
	color[0] = GRAY;
	while(1){
		minv = INFTY;
		int u = -1;
		for(int i=0;i < n;++i){
			if(minv > d[i] && color[i] != BLACK){
				u = i;
				minv = d[i];
			}
		}
		if(u == -1)break;
		color[u] = BLACK;
		for(int v = 0;v < n;++v){
			if(color[v] != BLACK && M[u][v] != INFTY){
				if(d[v] > d[u] + M[u][v]){
					d[v] = d[u] + M[u][v];
					color[v] = GRAY;
				}
			}
		}
	}
	for(int i=0;i < n;++i){
		cout << i << " ";
		if(d[i] == INFTY) cout << -1 << endl;
		else cout << d[i] << endl;
	}
}

int main(){
	cin >> n;
	
	for(int i=0; i < n;++i){
		for(int j=0; j < n;++j){
			M[i][j] = INFTY;
		}
	}
	
	int k, c, u, v;
	for(int i=0;i < n;++i){
		cin >> u >> k;
		for(int j=0;j < k;++j){
			cin >> v >> c;
			M[u][v] = c;
		}
	}
	
	dijkstra();
	
	return 0;
}

C++: #include<iostream>
#include<cstdio>
#define W 0
#define G 1
#define B 2
#define inf 1000000
#define MAX 100
#define NIL -1
using namespace std;

int n;
int A[MAX][MAX];

void Prim(){
    int color[MAX],d[MAX],p[MAX];
    int min,u;
    for(int i = 0; i < n; i++){
        color[i] = W;
        d[i] = inf;
        p[i] = NIL;
    }
    
    d[0] = 0;
    
    while(1){
        u = -1;
        min = inf;
        for(int i = 0; i < n; i++){
            if(d[i] < min && color[i] != B){
                u = i;
                min = d[i];
            }
        }
        
        if(u == -1) break;
            
        color[u] = B;
            
        for(int i = 0; i < n; i++){
            if(color[i] != B && A[u][i] != NIL){
                if(A[u][i] + d[u] < d[i]){
                    d[i] = A[u][i] + d[u];
                    color[i] = G;
                    p[i] = u;
                }
            }
        }
    }
    
    for (int i = 0; i < n; i++){
        printf("%d %d\n",i,d[i]);
    }
}

int main(){
    int u,k,c,v;
    scanf("%d",&n);
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            A[i][j] = inf;
        }
    }
    for(int i = 0; i < n; i++){
        scanf("%d %d", &u, &k);
        for(int j =0; j < k; j++){
            scanf("%d %d",&v,&c);
            A[i][v] = c;
        }
    }
    
    
    Prim();
    return 0;
}

C++: // -*- mode:c++; coding:utf-8; c-basic-offset:2; -*-
// ALDS1_12_B: Single Source Shortest Path I

#include <algorithm>
#include <cstdio>

using uint = unsigned int;

class Graph {
  const uint n_;
  uint* const g_;
  const uint INFINIT;
  
public:

  Graph(uint n) : n_(n), g_(new uint[(n_*n_)]), INFINIT(100000*n_) {
    std::fill_n(g_, (n_*n_), INFINIT);
  }

  ~Graph() { delete[] g_; }
  
  uint* operator [](uint i) const { return g_+(n_*i); }

  void dijkstra(uint* dist)
  {
    std::fill_n(dist, n_, INFINIT);
    bool visited[n_];
    std::fill_n(visited, n_, false);
    auto i = 0u; // 0-start
    visited[i] = true;
    dist[i] = 0u;
    for (auto n = 0u; n < n_-1; ++n) {
      auto cur_min = INFINIT;
      auto es = (*this)[i];
      auto base_dist = dist[i];
      for (auto j = 0u; j < n_; ++j) {
        if (visited[j]) continue;
        dist[j] = std::min(dist[j], base_dist+es[j]);
        if (cur_min > dist[j]) {
          cur_min = dist[j];
          i = j;
        }
      }
      visited[i] = true;
      dist[i] = cur_min;
    }
  }
};

int main()
{
  uint n;
  std::scanf("%u", &n);

  Graph g(n);

  uint u, k, c, v;
  for (auto i = 0u; i < n; ++i) {
    std::scanf("%u %u", &u, &k);
    for (auto j = 0u; j < k; ++j) {
      std::scanf("%u %u", &c, &v);
      g[u][c] = v;
    }
  }

  uint dist[n];
  g.dijkstra(dist);
  for (auto i = 0u; i < n; ++i) {
    std::printf("%u %u\n", i, dist[i]);
  }
}

// eof

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];
void dijkstra(){
    int minv;
    int d[MAX],color[MAX];

    for(int i=0;i<n;i++){
	d[i]=INFTY;
	color[i]=white;
    }
    d[0]=0;
    color[0]=gray;
    while(1){
	minv=INFTY;
	int u=-1;
	for(int i=0;i<n;i++){
	    if(minv>d[i]&&color[i]!=black){
		u=i;
		minv=d[i];
	    }
	}
	if(u==-1)break;

	color[u]=black;
	for(int v=0;v<n;v++){
	    if(color[v]!=black&&M[u][v]!=INFTY){
		if(d[v]>d[u]+M[u][v]){
		    d[v]=d[u]+M[u][v];
		    color[v]=gray;
		}
	    }
	}
    }
    for(int i=0;i<n;i++){
	cout<<i<<" "<<(d[i]==INFTY?-1:d[i])<<endl;
    }
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
	for(int j=0;j<n;j++){
	    M[i][j]=INFTY;
	}
    }

    int k,c,u,v;
    for(int i=0;i<n;i++){
	cin>>u>>k;
	for(int j=0;j<k;j++){
	    cin>>v>>c;
	    M[u][v]=c;
	}
    }
    dijkstra();
    return 0;
}

C++: #include<bits/stdc++.h>
#define pb push_back
using namespace std;
long long dis[10002];
bool vis[10002];
vector<int> a[10002];
vector<int> b[10002];
int n,u,k,x,t=1,w,m,s,v;
queue<int> q;
int main(){
	cin>>n;
	memset(vis,false, sizeof(vis));
	memset(dis,0x1f1f1f1f,sizeof(dis));
	for (int i=0; i<n; i++){
		cin>>u>>k;
		while (2*k--){
			  cin>>v>>w;
			  a[u].pb(v);
		      b[u].pb(w);
		}
	}
	q.push(0);
	dis[0]=0;
	while (!q.empty()){
		  x=q.front(); q.pop(); vis[x]=false;
		  for (int i=0; i<a[x].size(); i++){
		  	  if (dis[a[x][i]]>dis[x]+b[x][i]){
		  	  	  dis[a[x][i]]=dis[x]+b[x][i];
		  	  	  if (!vis[a[x][i]]){
		  	  	  	  vis[a[x][i]]=true;
		  	          q.push(a[x][i]);
                  }
			 }
		  	  
		  }
	}
    for (int i=0; i<n; i++){
		cout<<i<<' '<<dis[i]<<'\n';
	}
	return 0;
}