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++: //dijkstra算法 
#include <iostream>

using namespace std;

const int N = 100;
//INFTY要足够大 
const int INFTY = 1 << 21;

int Graph[N][N];

int n;

void dijkstra(int u0) {
	int *d = new int[n];
	char *color = new char[n];
	for (int i=0;i<n;i++) {
		d[i] = INFTY;
		color[i] = 'W';
	}
	
	d[u0] = 0;
	color[u0] = 'G';
	
	while (1) {
		int mincost = INFTY;
		int u = -1;
		for (int i = 0;i<n;i++) {
			if (color[i] != 'B' && mincost > d[i]) {
				mincost = d[i];
				u = i;
			}
		}
		

		
		if (mincost == INFTY) { //说明节点已经全部访问完毕 
			break;
		}
		
		color[u] = 'B';
		
		for (int v=0;v<n;v++) {
			if (color[v] != 'B' && Graph[u][v] != INFTY) {
				if (d[v] > d[u] + Graph[u][v]) {
					d[v] = d[u] + Graph[u][v];
					color[v] = 'G'; 
				}
			}
		}
	}
	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++) {
			Graph[i][j] = INFTY;
		}
	}
	
	for (int i=0;i<n;i++) {
		int u,k;
		cin >> u >> k;
		
		for (int j = 0;j<k;j++) {
			int v,c;
			cin >> v >> c;
			Graph[u][v] = c;
		}
	}
	dijkstra(0);
	return 0;
}

C++: #include <iostream>
using namespace std;
#define DEBUG(x) cout<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cout<<#v<<":";for(int i=0;i<v.size();i++) cout<<" "<<v[i]; cout<<endl
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define MOD 1000000007
#define mod 1000000009
#define pi 3.14159265358979323846
#define Sp(p) cout<<setprecision(15)<< fixed<<p<<endl;

int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 };

int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
typedef long long ll;
const int inf = 1000000001;
const ll INF = 1e18 * 4;

void relax(int u, int v, int* d, int** mat){ 
    if(d[v] > d[u] + mat[u][v]) d[v] = d[u] + mat[u][v];
}

void dijkstra(int n, int** mat, int* d){
    int cur_v = 0;
    int* visited = new int[n];
    rep(i, 0, n) visited[i] = 0;
    d[cur_v] = 0;
    while(true){
        visited[cur_v] = 1;
        rep(j, 0, n){
            if(mat[cur_v][j] > -1){
                relax(cur_v, j, d, mat); 
            }
        }
        // pick next cur_v (with minimum unvisited)
        int min_visited = inf;
        int next_v = -1;
        rep(k, 0, n){
            if(!visited[k] && d[k] < min_visited){
                min_visited = d[k];
                next_v = k;
           }
        }
        if(next_v == -1) break;
        cur_v = next_v;
    } 
}


int main(){
    int n;
    cin >> n;
    int** mat = new int*[n];
    rep(i, 0, n){
        mat[i] = new int[n];
        rep(j, 0, n){
            mat[i][j] = -1;
        }
    }

    rep(i, 0, n){
        int v;
        int k;
        cin >> v >> k;
        rep(j, 0, k){
            int vout, c;
            cin >> vout >> c;
            mat[v][vout] = c;
        }
    }
    int* d = new int[n];
    rep(i, 0, n){ d[i] = inf; }
    dijkstra(n, mat, d);
    rep(i, 0, n){
        cout << i << " " << d[i] << endl;
    }


    return 0;
}

C++: #include<iostream>
#include<algorithm>
#include<math.h>
#include<queue>
#include<vector>
#include<climits>
#include<map>
#include<string>
#include<functional>
#include<iomanip>

using namespace std;
typedef long long ll;

ll n, u, k, v, c;

const int INF = 7 + (1e+9);
typedef int Weight;
struct Edge {  //src:辺の始点,dst:辺の終点,weight:辺の重さ
	int src, dst;
	Weight weight;
	Edge(int src, int dst, Weight weight) :
		src(src), dst(dst), weight(weight) { }
};
bool operator < (const Edge &e, const Edge &f) {
	return e.weight != f.weight ? e.weight > f.weight : //辺は重さが重いものを"小さい"と定義する
	e.src != f.src ? e.src < f.src : e.dst < f.dst;
}
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;

//引数 g:隣接リスト,s:始点,dist:各頂点までの距離が入る,prev:最短路木の親頂点が入る
//戻値 なし
void shortestPath(const Graph &g, int s, vector<Weight> &dist, vector<int> &prev) {
	int n = g.size();
	dist.assign(n, INF); dist[s] = 0;
	prev.assign(n, -1);
	priority_queue<Edge> Q;
	Q.push(Edge(-2, s, 0));
	while (!Q.empty()) {
		Edge e = Q.top(); Q.pop();
		if (prev[e.dst] != -1) continue;
		prev[e.dst] = e.src;
		for (auto f = g[e.dst].begin(); f != g[e.dst].end(); f++) {
			if (dist[f->dst] > e.weight + f->weight) {
				dist[f->dst] = e.weight + f->weight;
				Q.push(Edge(f->src, f->dst, e.weight + f->weight));
			}
		}
	}
}

int main() {
	cin >> n;
	Graph g(n);
	for (int i = 0; i < n; i++) {
		cin >> u >> k;
		for (int j = 0; j < k; j++) {
			cin >> v >> c;
			g[u].push_back(Edge(u, v, c));
		}
	}
	vector<Weight> dist;
	vector<int> prev;
	shortestPath(g, 0, dist, prev);
	for (int i = 0; i < n; i++) {
		cout << i << " " << dist[i] << endl;
	}
}

C++: #include<cstdio>
#include<iostream>
#define INF 200001
using namespace std;
int main(){
 int u,k,C,V,A[1000][1000],D[1000][1000],n;
  scanf("%d",&n);
   for(int i=0;i<n;i++)for(int j=0;j<n;j++)D[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);
    D[u][V] = C;
      }   
  }
  for(int i=0;i<n;i++)D[i][i] = 0;
  for(int k=0;k<n;k++)for(int i=0;i<n;i++)for(int j=0;j<n;j++)D[i][j]= min(D[i][j],D[i][k] + D[k][j]);
  for(int i=0;i<n;i++)printf("%d %d\n",i,D[0][i]);
  return 0;
}