Go: package main

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

var sc = bufio.NewScanner(os.Stdin)

const T = 10000000

var n int
var A [101][101]int

func nextInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}
func Shortestsearch() {
	var Minimum int
	var d, color [100]int
	var u int

	for i := 0; i < n; i++ {
		d[i] = T
		color[i] = 0
	}

	d[0] = 0
	color[0] = 1

	for {
		Minimum = T
		u = -1
		for i := 0; i < n; i++ {
			if Minimum > d[i] && color[i] != 2 {
				u = i
				Minimum = d[i]
			}
		}
		if u == -1 {
			break
		}
		color[u] = 2
		for j := 0; j < n; j++ {
			if color[j] != 2 && A[u][j] != T {
				if d[j] > d[u]+A[u][j] {
					d[j] = d[u] + A[u][j]
					color[j] = 1
				}
			}
		}
	}
	for i := 0; i < n; i++ {
		fmt.Printf("%d %d\n", i, d[i])
	}
}
func main() {
	sc.Split(bufio.ScanWords)
	n = nextInt()

	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			A[i][j] = T
		}
	}
	for i := 0; i < n; i++ {
		u := nextInt()
		k := nextInt()
		for j := 0; j < k; j++ {
			v := nextInt()
			c := nextInt()
			A[u][v] = c
		}
	}
	Shortestsearch()
}

C++: #include"iostream"
#include"algorithm"
#include"cstdio"
#include"cstring"
#include"string"
#include"vector"
#include"queue"
#include"map"
#include"set"
#include"stack"
#include"cmath"
using namespace std;
#define INF 0xfffffff
const int maxn = 100000 + 10;
const int maxm = 500000 + 10;
int n, m;
int s,t;
int fir[maxn], nxt[maxm], to[maxm], val[maxm], cnt;
void add_edge(int u, int v, int w)
{
    nxt[++cnt] = fir[u];
    fir[u] = cnt;
    to[cnt] = v;
    val[cnt] = w;
}
struct Node 
{
    int d, id;
    Node(){}
    Node(int d, int id) : d(d), id(id){}
    bool operator < (const Node& rhs) const
      {
        return d > rhs.d;
      }
};
int dis[maxn], vis[maxn];
void Dijkstra(int s)
{
    for(int i = 1; i <= n; i++) dis[i] = INF;
    dis[s]=0;
    priority_queue<Node> Q;
    Q.push(Node(0,s));
    while(!Q.empty()) 
      {
        Node u = Q.top(); Q.pop();
        if(vis[u.id]) continue;
        vis[u.id] = 1;
        for(int e = fir[u.id]; e; e = nxt[e]) 
          {
            int v = to[e], w = val[e];
            if(u.d + w < dis[v]) 
              {
                dis[v] = u.d + w;
                Q.push(Node(dis[v],v));
              }
          }
      }
}
int main()
{
		cin >> m;
		for(int i=0; i<m; i++)
        {
			int k;
			memset(dis,0,sizeof(dis));
			memset(vis,0,sizeof(vis));
			scanf("%d%d",&n,&k);
			for(int j=0;j<k;j++)
			{
            int  b, c;
            cin >> b >> c;
            add_edge(n,b,c);
			}
			Dijkstra(0);
			printf("%d %d\n",n,dis[n]);
        }
    return 0;
}

C++: // ダイクストラ法
// Dijkstra's Algorithm
// Single Source Shortest Path 1 単一始点最短経路
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <vector>
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 minv;
    int d[MAX], color[MAX];

    for(int i = 0; i < n; i++) {
        d[i] = INF;
        color[i] = WHITE;
    }

    d[0] = 0;
    color[0] = GRAY;

    while (true) {
        minv = INF;
        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] != INF) {
                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] == INF ? -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] = INF;
        }
    }

    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"
using namespace std;
static const int MAX=10000;
static const int INFTY=(1<<21);
static const int WHITE=0;
static const int GRAY=1;
static const int BLACK=2;

int n;
//????????????????????°???????????£??\???????????¨???
vector<pair<int,int> >adj[MAX];

void dijkstra(){
	priority_queue<pair<int,int> > PQ;
	int color[MAX];
	int d[MAX];
	for (int i = 0; i < n; ++i) {
		d[i]=INFTY;
		color[i]=WHITE;
	}
	d[0]=0;
	PQ.push(make_pair(0,0));
	color[0]=GRAY;
	while(!PQ.empty()){
		pair<int,int> f=PQ.top();PQ.pop();
		int u=f.second;
		color[u]=BLACK;
		//????°???????????????????????????????????????§???????????°??????
		if(d[u]<f.first *(-1))continue;

		for (int j = 0; j < adj[u].size(); ++j) {
			int v=adj[u][j].first;
			if(color[v]==BLACK)continue;
			if(d[v]>d[u]+adj[u][j].second){
				d[v]=d[u]+adj[u][j].second;
				//priority_queue????????????????????§??§??????????????????????????????-1????????????
				PQ.push(make_pair(d[v]*(-1),v));
				color[v]=GRAY;
			}
		}
	}
	for (int i = 0; i < n; ++i) {
		cout<<i<< " "<<(d[i]==INFTY?-1:d[i])<<endl;
   }
}


int main(){
	cin>>n;
	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;
			adj[u].push_back(make_pair(v,c));
		}
	}
	dijkstra();
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
constexpr int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define sort(v) sort((v).begin(), (v).end())
#define sortr(v) sort((v).rbegin(), (v).rend())
#define all(v) (v).begin(), (v).end()
#define max 100005
#define nil -1
constexpr int inf = 100000000;

struct edge{
    int from,to,cost;
};

vector<edge> es;
vector<int> d;
int n;

void be(int s){
    d.resize(max);
   fill(d.begin(),d.end(),inf);
   d[s]=0;
   while(true){
       bool update=false;
       for(int i=0;i<es.size();i++){
           edge e=es[i];
           if(d[e.from]!=inf&&d[e.from]+e.cost<d[e.to]){
               d[e.to]=d[e.from]+e.cost;
               update=true;
           }
       }
       if(!update){
           break;
       }
   }
}

int main() {
  int  u,k,v,c;
  cin>>n;
    d.resize(n);
  rep(i,n){
      cin>>u>>k;
      for(int j=0;j<k;j++){
          cin>>v>>c;
          es.push_back({u,v,c});
        }
    }
    be(0);
    rep(i,n){
        cout<<i<<" "<<d[i]<<endl;
    }
  return 0;
}