Go: package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
	"strconv"
)

//make priority queue
type Item struct {
	id       int
	priority int // this state is priority and distans from start
	index    int
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

// we want the ascending-priority-queue.
// So we use less than here.
func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].priority < pq[j].priority
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
	pq[i].index = j
	pq[j].index = i
}

func (pq *PriorityQueue) Push(x interface{}) {
	n := len(*pq)
	item := x.(*Item)
	item.index = n
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	item.index = -1 //for safety
	*pq = old[0 : n-1]
	return item
}

func (pq *PriorityQueue) update(dist int, id int) {
	for _, i := range *pq {
		if i.id == id {
			if i.priority > dist {
				i.priority = dist
			}
		}
	}
}

// the main code
func nextInt(sc *bufio.Scanner) int {
	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	return n
}

func dikstra(dist [][]int, n int) []int {
	// preparate priority queue
	inf := 1 << 30
	pq := make(PriorityQueue, n)
	shortests := make([]int, n)
	for i := 0; i < n; i++ {
		pq[i] = &Item{
			id:       i,
			priority: inf,
			index:    i,
		}

		shortests[i] = inf
	}
	pq[0].priority = 0
	shortests[0] = 0
	heap.Init(&pq)

	for pq.Len() > 0 {
		item := heap.Pop(&pq).(*Item)
		shortests[item.id] = item.priority
		for id, d := range dist[item.id] {
			if d != -1 {
				pq.update(item.priority+d, id)
			}
		}
		heap.Init(&pq)
	}
	return shortests
}

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

	// init
	n := nextInt(sc)
	dist := make([][]int, n)
	for i := 0; i < n; i++ {
		dist[i] = make([]int, n)
		for j := 0; j < n; j++ {
			dist[i][j] = -1
		}
	}

	// std Input
	for i := 0; i < n; i++ {
		u := nextInt(sc)
		k := nextInt(sc)
		for j := 0; j < k; j++ {
			v, c := nextInt(sc), nextInt(sc)
			dist[u][v] = c
		}
	}

	shortests := dikstra(dist, n)
	for i, d := range shortests {
		fmt.Printf("%d %d\n", i, d)
	}
}

C++: #include <iostream>
#include <vector>

using namespace std;

#define MAX 10000
#define INFTY 99999999

#define WHITE 0
#define GRAY 1
#define BLACK 2


struct Node {
	vector<int> ch;
	vector<int> co;
};



Node G[MAX];


int n;
int d[MAX];
int p[MAX];
int color[MAX];




void dijkstra(int s)
{
	int u;

	for (int i = 0; i < n; i++) {
		p[i] = -1;
		d[i] = INFTY;
	}

	d[s] = 0;

	while (true) {

		int mincost = INFTY;

		for (int i = 0; i < n; i++) {
			if (color[i] != BLACK && d[i] < mincost) {
				mincost = d[i];
				u = i;
			}
		}

		if (mincost == INFTY) {
			break;
		}

		color[u] = BLACK;

		for (int i = 0; i < G[u].ch.size(); i++) {
			if (color[G[u].ch[i]] != BLACK) {
				if (d[u] + G[u].co[i] < d[G[u].ch[i]]) {
					d[G[u].co[i]] = d[u] + G[u].co[i];
					p[G[u].co[i]] = d[u];
					color[G[u].co[i]] = GRAY;
				}
			}
		}
	}

}

int main(void)
{
	int u;
	int k;
	int v;
	int c;

	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> u >> k;
		for (int j = 0; j < k; j++) {
			cin >> v >> c;
			G[u].ch.push_back(v);
			G[u].co.push_back(c);
		}
	}

	dijkstra(0);

	for (int i = 0; i < n; i++) {
		cout << i << " " << d[i] << endl;
	}

}

C++: #include<bits/stdc++.h>

std::vector<int> color;
std::vector<std::pair<int, int>> G[10000];
std::vector<int> d;
std::vector<int> p;
int INF = 1001001001;
int sum = 0;
std::priority_queue<std::pair<int, int>> que;

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

    d[0] = 0;
    p[0] = -1;

    que.push(std::make_pair(0, 0));

    while(que.empty() != 1){
        std::pair<int, int> f = que.top();
        que.pop();
        int u = f.second;

        color[u] = 1;

        // if(d[u] < )

        for(int i = 0; i < G[u].size(); i++){
            std::pair<int, int> pair = G[u][i];
            if(color[pair.first] != 1){
                if(d[u] + pair.second < d[pair.first]){
                    d[pair.first] = d[u] + pair.second;
                    que.push(std::make_pair(d[pair.first] * (-1), pair.first));
                }
            }
        }

    }
    
    for(int i = 0; i < d.size(); i++){
        sum += d[i];
    }

}

int main(void){
    int n;
    int tmp1, tmp2;
    std::cin >> n;

    color.resize(n);
    d.resize(n);
    p.resize(n);

    int u, k, v;

    for(int i = 0; i < n; i++){
        std::cin >> u >> k;
        for(int j = 0; j < k; j++){
            std::cin >> tmp1 >> tmp2;
            G[u].push_back(std::make_pair(tmp1, tmp2));
        }
        
    }
    
    
    dijkstra(n);
    
    for(int i = 0; i < n; i++){
        std::cout << i << " " << d[i] << std::endl;
    }

    return 0;
}

C++: #include <bits/stdc++.h>

using namespace std;

#ifdef DEBUG_MODE
	#define DBG(n) n;
#else
	#define DBG(n) ;
#endif
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define rep(i,s,g) for(ll (i) = (s);(i) < (g);++i)
#define rrep(i,s,g) for(ll (i) = (s);i >= (g);--(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {for(int W = 0;W < (n);W++)cerr << v[W] << ' ';cerr << endl << endl;}
#define SHOW2d(v,i,j) {for(int aaa = 0;aaa < i;aaa++){for(int bbb = 0;bbb < j;bbb++)cerr << v[aaa][bbb] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define MOD 1000000007

typedef long long ll;
typedef pair<ll,ll> P;
#define NODE 100001
#define INF 1000000000
vector<vector<pair<ll,ll> > > v(NODE);
int dist[NODE];
int dijkstra(int start){
	for(int i = 0;i < NODE;i++)dist[i] = INF;
	dist[start] = 0;
	priority_queue<P,vector<P>,greater<P> > pq;
	pq.push(make_pair(0,start));
	while(!pq.empty()){
		P now = pq.top();pq.pop();
		ll d = now.first;
		ll node = now.second;
		if(dist[node] < d)continue;
		for(int i = 0;i < v[node].size();i++){
			ll opp_n = v[node][i].first;
			ll opp_d = v[node][i].second;
			if(dist[opp_n] > d + opp_d){
				dist[opp_n] = d + opp_d;
				pq.push(make_pair(dist[opp_n],opp_n));
			}
		}
	}
}

int main(){
	int n;cin >> n;
	REP(i,n){
		int a,b;cin >> a >> b;
		REP(j,b){
			int x,y;cin >> x >> y;
			v[a].PB(MP(x,y));
		}
	}
	dijkstra(0);
	
	REP(i,n){
		cout << i << ' ' << dist[i] << endl;
	}
	
	return 0;
}