Go: package main

import (
	"fmt"
	"container/heap"
)

type Node struct {
	Id int
	Dis int
}

type PriorityQueue []*Node

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

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].Dis < pq[j].Dis
}

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

func (pq *PriorityQueue) Push(x interface{}) {
	*pq = append(*pq, x.(*Node))
}

func (pq *PriorityQueue) Pop() interface{} {
	n := len(*pq)
	pop := (*pq)[n-1]
	*pq = (*pq)[0:n-1]
	return pop
}

func main() {
	var n int
	fmt.Scan(&n)

	g := make([][]int, n)
	c := make([][]int, n)
	pq := make(PriorityQueue, 0, n)
	d := make([]int, n)
	for i := 0; i < n; i++ {
		var u,k int
		fmt.Scan(&u)
		fmt.Scan(&k)
		g[u] = make([]int, k)
		c[u] = make([]int, k)
		for j := 0; j < k; j++ {
			fmt.Scan(&g[u][j])
			fmt.Scan(&c[u][j])
		}

		if u == 0 {
			d[u] = 0
		} else {
			d[u] = 1 << 30
		}
		pq.Push(&Node{u, d[u]})
	}
	heap.Init(&pq)

	for pq.Len() > 0 {
		node := heap.Pop(&pq).(*Node)
		for i := 0; i < len(g[node.Id]); i++ {
			nextId := g[node.Id][i]
			nextDis := node.Dis + c[node.Id][i]
			if nextDis < d[nextId] {
				d[nextId] = nextDis
				heap.Push(&pq, &Node{nextId, nextDis})
			}
		}
	}

	for i := 0; i < n; i++ {
		fmt.Println(i, d[i])
	}
}

C++: #include<iostream>
#include<vector>
#include<queue>
#define INF 2e9
using namespace std;

void Dikstra(const vector<vector<pair<int, int> > >& G, vector<int>& d){
    d[0] = 0;
    priority_queue<pair<int, int> , vector<pair<int, int> >, greater<pair<int, int> > > PQ;
    PQ.push(make_pair(0, 0));
    vector<bool> is_black(d.size(), false);
    is_black[0] = true;
    while (!PQ.empty()) {
        int t = PQ.top().second;
        PQ.pop();
        is_black[t] = true;
        for (int i = 0; i < G[t].size(); i++) {
            int v = G[t][i].first;
            int w = G[t][i].second;
            if (!is_black[v] && d[t] + w < d[v]) {
                d[v] = d[t] + w;
                PQ.push(make_pair(d[v], v));
            }
        }
    }
}

int main(){
    int n;
    cin >> n;
    vector<vector<pair<int, int> > > G(n);
    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;
            G[u].push_back(make_pair(v, c));
        }
    }
    vector<int> d(n, INF);
    Dikstra(G, d);
    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 s) {
    int color[n], d[n], p[n];
    for (int i=0; i<n; i++) {
        color[i] = WHITE;
        d[i] = INFTY;
    }
    d[s] = 0;
    color[s] = GRAY;

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

        if (mincost == INFTY) {
            break; // All nodes visited
        }

        color[u] = BLACK;
        for (int v=0; v<n; v++) {
            if (color[v]!=BLACK && M[u][v]<INFTY) {
                if (d[u]+M[u][v]<d[v]) {
                    d[v] = d[u]+M[u][v];
                    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] = INFTY;
        }
    }

    int u, k, v, c;
    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(0);
    return 0;
}

C++: #include <iostream>

using namespace std;
#define MAX 100
#define NIL (1<<21)
#define WHITE 0
#define GRAY 1
#define BLACK 2
int G[MAX][MAX];//图的邻接矩阵
int color[MAX];//节点状态
int n;
int d[MAX];//最小权值
int p[MAX];//父亲节点
void dijkstra(){
    for(int i=0;i<n;i++){
        color[i] = WHITE;
        d[i] = NIL;
        p[i] = -1;
    }
    d[0] = 0;
    while(1){
        int u;
        int mincost = NIL;
        for(int i=0;i<n;i++){//循环找到下一个要加入到S中的(d[u]最小值)
            if(color[i]!=BLACK&&d[i]<mincost){
                mincost = d[i];
                u = i;
            }
        }
        if(mincost==NIL){
            break;
        }
        color[u] = BLACK;
        for(int v=0;v<n;v++){//给相邻顶点的d赋值（与之前的相比较，找到最小的）
            if(color[v]!=BLACK&&G[u][v]!=-1){
                    if(d[u]+G[u][v]<d[v]){
                        d[v] = d[u]+G[u][v];
                        p[v] = u;
                    }
                }
            }
        }



}
int main()
{
    cin>>n;
     for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            G[i][j] = -1;
        }

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

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

C++: #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>

// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& p) {
  return os << '(' << p.first << ", " << p.second << ')';
}

template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
  int n = 0;
  for (auto e : vec) os << (n++ ? ", " : "{") << e;
  return os << (n ? "}" : "{}");
}

template <class T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& st) {
  int n = 0;
  for (auto e : st) os << (n++ ? ", " : "{") << e;
  return os << (n ? "}" : "{}");
}

template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::map<T, U>& mp) {
  int n = 0;
  for (auto e : mp) os << (n++ ? ", " : "{") << e;
  return os << (n ? "}" : "{}");
}

template <class T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
  for (T& e : vec) is >> e;
  return is;
}

#ifdef LOCAL
#define debug(...) \
  std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif

void debug_out() { std::cerr << '\n'; }

template <class Head, class... Tail>
void debug_out(Head&& head, Tail&&... tail) {
  std::cerr << head;
  if (sizeof...(Tail) != 0) std::cerr << ", ";
  debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;

const int VERY_LARGE_NUM = 1e8;

void dijkstra(int start_node_id, int size, const vector<vector<int>>& g,
              vector<int>& color, vector<int>& d) {
  d[start_node_id] = 0;
  color[start_node_id] = 1;
  while (1) {
    int min_cost = VERY_LARGE_NUM;
    int u = -1;
    for (int i = 0; i < size; i++) {
      if (color[i] != 2 && d[i] < min_cost) {
        min_cost = d[i];
        u = i;
      }
    }
    if (u == -1) break;
    color[u] = 2;
    for (int i = 0; i < size; i++) {
      if (g[u][i] > 0 && color[i] != 2) {
        if (d[i] > d[u] + g[u][i]) {
          d[i] = d[u] + g[u][i];
          color[i] = 1;
        }
      }
    }
  }
}

int main() {
  int n, u, k, c, v;
  cin >> n;
  vector<vector<int>> g(n, vector<int>(n));
  for (int i = 0; i < n; i++) {
    cin >> u >> k;
    for (int j = 0; j < k; j++) {
      cin >> v >> c;
      g[u][v] = c;
    }
  }
  debug(g);
  vector<int> color(n);
  vector<int> d(n, VERY_LARGE_NUM);
  dijkstra(0, n, g, color, d);
  for (int i = 0; i < n; i++) {
    cout << i << ' ' << d[i] << endl;
  }
  return 0;
}