Go: package main

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

func main() {
	scn := bufio.NewScanner(os.Stdin)
	scn.Split(bufio.ScanWords)
	nextInt := func() int { scn.Scan(); r, _ := strconv.Atoi(scn.Text()); return r }
	w := bufio.NewWriter(os.Stdout)

	n := nextInt()
	vecs := make([][]int, n)
	for i := 0; i < n; i++ {
		u := nextInt()
		k := nextInt()
		for j := 0; j < k; j++ {
			vecs[u-1] = append(vecs[u-1], nextInt()-1)
		}
	}

	ds := make([]int, 0, n)
	for i := 0; i < n; i++ {
		ds = append(ds, -1)
	}

	q := make([]int, 0, n)
	q = append(q, 0)
	ds[0] = 0

	for len(q) > 0 {
		i := pop(&q)
		for _, v := range vecs[i] {
			if ds[v] == -1 {
				ds[v] = ds[i]+1
				q = append(q, v)
			}
		}
	}

	for i, d := range ds {
		fmt.Fprintln(w, i+1, d)
	}

	w.Flush()
}

func pop(q *[]int) int {
	v := (*q)[0]
	*q = (*q)[1:]
	return v
}

C++: #include <iostream>
#include <queue> 
using namespace std;
int G[100][100];
int d[100];
int color[100];
int n;
queue<int> qu;
void bfs ()
{
    color[0] = 1;
    d[0] = 0;
    qu.push(0);
    while (!qu.empty())
    { 
        int u = qu.front(); qu.pop();
        for (int i = 0; i < n; i++)
        {
            if (G[u][i] == 1 && color[i] == 0)
            {
                color[i] = 1;
                d[i] = d[u] + 1;
                qu.push(i);
            }
        }
        color[u] = 2;
    } 
    return;
}

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

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

    for (int i = 0; i < n; i++)
    {
        d[i] = -1; 
        color[i] = 0;
    } 
    bfs();
    for (int i = 0; i < n; i++)
    {
         printf("%d %d\n", i+1, d[i]);
    } 
    return 0;
}

C++: #include <iostream>
#include <vector>
#include <numeric>
#include <cassert>
#include <queue>

const int MAXINT = 1000;

void bfs(std::vector<std::vector<int> >& adj_list, std::vector<int>& d, int root = 0 ){
  std::queue<int> target_q;
  // std::queue<int> dist_q;
  target_q.push(root);
  d[root] = 0;
  // dist_q.push(0;)
  while(!target_q.empty()){
    int vtx = target_q.front(); target_q.pop();
    for(int const&  u : adj_list[vtx]){
      if(d[vtx] + 1 < d[u]){
      target_q.push(u);
        // std::cout<< "/* message */" << std::endl;
        d[u] = d[vtx] + 1;
      }
    }
  }
}


int main(int argc, char const *argv[]) {
  int n; // .. 100
  std::cin >> n;
  std::vector<std::vector<int> > adj_list(n);
  std::vector<int> d(n, MAXINT);

  for(int q=0; q<n; ++q){
    int i_plus_1, k;
    std::cin >> i_plus_1;
    std::cin >> k;
    for(int p=0; p<k; ++p){
      int j_plus_1;
      std::cin >> j_plus_1;
      // adj[i_plus_1-1][j_plus_1-1] = true;
      adj_list[i_plus_1 - 1].push_back(j_plus_1-1);
    }
  }
  bfs(adj_list, d, 0);

  for(int i=0; i<n; ++i){

    // if(d[i] < MAXINT){
      std::cout << (i+1)
        << " " << (d[i]==MAXINT ? -1 : d[i])
        << std::endl;
  }


  // for(auto it = adj_list.begin(); it != adj_list.end(); ++it){
  //   std::cout << ": ";
  //   for(auto jt = (*it).begin(); jt != (*it).end(); ++jt){
  //     std::cout << (*jt) << ' ';
  //   }
  //   std::cout << std::endl;
  // }

  return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;

static const int N = 100;
//static const int white = 0;
//static const int gray = 1;
//static const int black = 2;
static const int inf = (1 << 30);

int n, m[N][N];
int d[N];
//color[N];

void bfs(int s) {
	queue<int> q;
	for (int i = 0; i < n; i++) {
		//color[i] = white;
		d[i] = inf;
	}
	d[s] = 0;
	q.push(s);
	//color[s] = gray;
	while (!q.empty()) {
		for (int  i = 0; i < n; i++) {
			if (m[s][i] == 1 && d[i] == inf) {
				q.push(i);
				d[i] = d[s] + 1;
			}
		}
	//	color[s] = black;
		q.pop();
		s = q.front();
	}
}

int main() {
	cin >> n;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			m[i][j] = 0;
		}
	}	
	int u, k, v;
	for (int i = 0; i < n; i++) {
		cin >> u >> k;
		u--;
		for (int j = 0; j < k; j++) {
			cin >> v;
			v--;
			m[u][v] = 1;
		}
	}
	bfs(0);
	for (int i = 0; i < n; i++) {
		if (d[i] == inf)
			cout << i + 1 << " " << -1 << endl;
		else
			cout << i + 1 << " " << d[i] << endl;
	}
	return 0;
}

C++: #include <iostream>
#include <algorithm>
#define NODE_SIZE 101
#define NIL -1

using namespace std;

int adj[NODE_SIZE][NODE_SIZE];
int depth[NODE_SIZE];
int n, d;

void bfs(int node, int parent){
    depth[node] = depth[parent] + 1;
    for(int i = 1; i <= n; i++){
        if(adj[node][i] && (depth[i] == NIL || depth[i] > depth[node] + 1)){
            bfs(i, node);
        }
    }
}

int main(){
    int u, k, v;

    cin >> n;
    for(int i = 0; i < n; i++){
        cin >> u >> k;
        depth[u] = NIL;
        while(k--){
            cin >> v;
            adj[u][v] = 1;
        }
    }


    depth[0] = NIL;
    bfs(1, 0);
    for(int i = 1; i <= n; i++){
        cout << i << " " << depth[i] << endl;
    }

    return 0;
}

C++: #include <iostream>
#include <cstring>
#include <cstdlib>
#include <sstream>
#include <stack>
#include <queue>
#include <list>
#include <stdio.h>
#include <algorithm>
#define MAX 100000
using namespace std;
typedef long long ll;
int map[255][255];
int d[255];
bool vis[255];
void bfs(int n,int pos,int distance)
{
	int a[255],j=0;
	vis[pos]=true;
	for(int i=1;i<=n;i++)
	{
		if(map[pos][i]&&!vis[i]){
			a[j++]=i;
			vis[i]=true;
			d[i]=distance;
		} 
	}
	for(int i=0;i<j;i++)
	{
		bfs(n,a[i],distance+1);
	}
}
int main()
{	
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=n;j++)
		{
			map[i][j]=0;
		}
	for(int i=0;i<n;i++)
	{
		int cur,k,u;
		cin>>cur>>k;
		while(k--)
		{
			cin>>u;
			map[cur][u]=1;
		}
	}
	for(int i=1;i<=n;i++)
	{
		vis[i]=false;
		d[i]=-1;
	}
	d[1]=0;
	bfs(n,1,1);
	for(int i=1;i<=n;i++)
	{
		cout<<i<<" "<<d[i]<<endl;
	}
	return 0;
}

C++: #include <iostream>
#include <queue>
using namespace std;

int D[100];
int mat[100][100];

void bfs(int src);

int main() {
  int n;
  for (int i=0;i<100;++i) {
    for (int j=0;j<100;++j)
      mat[i][j] = 0;
    D[i] = -1;
  }
  cin >> n;
  for (int i=0;i<n;++i) {
    int buf1,buf2;
    cin >> buf1 >> buf2;
    for (int j=0;j<buf2;++j) {
      int buf3;
      cin >> buf3;
      mat[i][buf3-1] = 1;
    }
  }
  bfs(0);
  for (int i=0;i<n;++i)
    cout << i+1 << " " << D[i] << endl;
}

void bfs(int src) {
  // cout << "bfs root = " << src << endl;
  queue<int> Q; // 整数を管理するキューの定義
  Q.push(src);
  D[src] = 0; // 出発点
  while (!Q.empty()) {
    int cur = Q.front(); // 先頭要素を取り出す
    Q.pop();
    // 動作確認用表示
    // cout << "visiting " << cur << " " << D[cur] << endl;
    for (int dst=0;dst<100;++dst) { // 各行き先 dst に対して
      if (mat[cur][dst]==1&&D[dst]==-1) {
	// cur から dst に辺があり, dst が未訪問なら
	D[dst] = D[cur]+1;
	Q.push(dst); // dst を訪問先に加える
      }
    }
  }
}