Go: package main

/*
グラフの表現 隣接行列による表現
*/

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

func main() {
	scanner := makeScanner(8192)
	n := eGetInt(scanner)
	g := make([][]int, n+1)
	for i := 1; i < n+1; i++ {
		g[i] = make([]int, n+1)
		ints := eGetInts(scanner)
		num := ints[0]
		for j := 0; j < ints[1]; j++ {
			g[num][ints[j+2]] = 1
		}
	}
	dist := make([]int, n+1)
	for i := 0; i < len(dist); i++ {
		dist[i] = -1
	}
	q := []int{}

	// 訪問する
	q = append(q, 1)
	dist[1] = 0

	// キューが空でない限り
	for len(q) > 0 {
		// 先頭を取り出す
		top := 0
		top, q = q[0], q[1:]
		// 隣接マスを入れる.
		for i := 1; i < n+1; i++ {
			// 辺がある
			if g[top][i] == 1 {
				if dist[i] == -1 {
					// 訪問済みでなければ
					q = append(q, i)
					dist[i] = dist[top] + 1
				}
			}
		}
	}
	for i := 1; i < n+1; i++ {
		fmt.Println(i, dist[i])
	}
}

////////////////////////////////////////////////////////////////////////////////
// ライブラリ
////////////////////////////////////////////////////////////////////////////////
func makeScanner(maxByte int) *bufio.Scanner {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]uint8, 0, 8192), maxByte)
	return scanner
}
func makeWordScanner() *bufio.Scanner {
	scanner := makeScanner(8192)
	scanner.Split(bufio.ScanWords)
	return scanner
}
func eGetLine(r *bufio.Scanner) string {
	if r.Scan() {
		return r.Text()
	}
	err := r.Err()
	if err != nil {
		log.Fatal(err)
	}
	// EOF
	return ""
}
func eGetInt(r *bufio.Scanner) int {
	line := eGetLine(r)
	return eAtoi(line)
}
func eGetInt64(r *bufio.Scanner) int64 {
	line := eGetLine(r)
	return eAtoInt64(line)
}
func eGetFields(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Fields(line)
}
func eGetInts(r *bufio.Scanner) []int {
	fields := eGetFields(r)
	ints := make([]int, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoi(fields[i])
	}
	return ints
}
func eGetInt64s(r *bufio.Scanner) []int64 {
	fields := eGetFields(r)
	ints := make([]int64, len(fields))
	for i := 0; i < len(ints); i++ {
		ints[i] = eAtoInt64(fields[i])
	}
	return ints
}
func eGetChars(r *bufio.Scanner) []string {
	line := eGetLine(r)
	return strings.Split(line, "")
}
func eAtoi(s string) int {
	n, err := strconv.Atoi(s)
	if err != nil {
		log.Fatal(err)
	}
	return n
}
func eAtoInt64(s string) int64 {
	n, err := strconv.ParseInt(s, 10, 64)
	if err != nil {
		log.Fatal(err)
	}
	return n
}

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

typedef long long ll;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)

const int INF  = 1000001;

int main() {
    int n; cin>>n;
    
    vector<int> to[100];
    rep(i,n){
        int a,m;
        cin>>a>>m;
        --a;
        
        rep(j,m){
            int b;cin>>b;
            --b;
            to[a].push_back(b);
//            to[b].push_back(a);
//          cout<<a<<" "<<b<<endl;
        }
    }

    queue<int> q;
    vector<int> dist(n, INF);
    dist[0]=0;
    q.push(0);

    while(!q.empty()){
        int v = q.front(); q.pop();
      for(int u : to[v]){
        if (dist[u] != INF) continue;
            dist[u] = dist[v] + 1;
            q.push(u);
//          cout<<u<<" "<<dist[u]<<endl;
        }
    }
  
    rep(i,n){
        int res1 = i+1;
        int res2 = dist[i];
        if(i == 0)res2 = 0;
        if(res2 == INF) res2 = -1;
        cout<<res1<<" "<<res2<<endl;
    }
    
	return 0;
}

C++: #include<iostream>
#include<cstdlib>
using namespace std;
int main() {
	int n, u, k[101], data[101][100]; cin >> n;
	for (int i = 1; i <= n; ++i) {
		cin >> u >> k[i];
		for (int j = 0; j<k[i]; ++j) cin >> data[u][j];
	}
	int queue[10000], head = 0, tail = 1, cost[101];
	for (int i = 2; i <= n; ++i) cost[i] = -1;
	queue[0] = 1; cost[1] = 0;
	while (head != tail) {
		int val = queue[head++];
		for (int i = 0; i < k[val]; ++i) {
			if (cost[data[val][i]] == -1) {
				queue[tail++] = data[val][i];
				cost[data[val][i]] = cost[val] + 1;
			}
		}
	}
	for (int i = 1; i <= n; ++i) cout << i << " " << cost[i] << endl;
	return 0;
}

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

const int nIMPOS = -1;
struct StDist
{
  int m_nDist;
  int m_nFromMeTo;

  StDist(int nDist) : m_nDist(nDist), m_nFromMeTo(0)
  { }
};

void fnInput(vector<vector<int>>& rvvnAdjcy, vector<StDist>& rvoDist)
{
  int nxSiz;
  cin >> nxSiz;

  rvvnAdjcy.resize(nxSiz + 1, vector<int>(nxSiz + 1, 0));
  for (int i = 0; i < nxSiz; ++i)
  {
    int nx, nySiz;
    cin >> nx >> nySiz;
    for (int j = 0; j < nySiz; ++j)
    {
      int ny;
      cin >> ny;
      rvvnAdjcy[nx][ny] = 1;
    }
  }
  StDist oDist(nIMPOS);
  rvoDist.resize(nxSiz + 1, oDist);
}

void fnBreadthFirstSearch(const vector<vector<int>>& cnrvvnAdjcy, 
                          queue<int>& rqnBFSrch, vector<StDist>& rvoDist)
{
  while (rqnBFSrch.size())
  {
    int nx = rqnBFSrch.front(); rqnBFSrch.pop();
    if (rvoDist[nx].m_nDist == nIMPOS)  continue;
    if (rvoDist[nx].m_nFromMeTo)        continue; 

    rvoDist[nx].m_nFromMeTo = 1;
    for (int ny = 1; ny < cnrvvnAdjcy[nx].size(); ++ny)
      if (cnrvvnAdjcy[nx][ny])
      {
        int nDist = rvoDist[nx].m_nDist + 1;
        if (rvoDist[ny].m_nDist == nIMPOS)
          rvoDist[ny].m_nDist = nDist;
        else
          rvoDist[ny].m_nDist = min(rvoDist[ny].m_nDist, nDist);

        rqnBFSrch.push(ny);
      }
  }
}

void fnResult(const vector<StDist>& cnrvoDist)
{
  for (int i = 1; i < cnrvoDist.size(); ++i)
    cout << i <<  " " << cnrvoDist[i].m_nDist << endl;
}

int main()
{
  cin.tie(0);
  ios::sync_with_stdio(false);
  vector<vector<int>> vvnAdjcy;
  queue<int>  qnBFSrch;
  vector<StDist> voDist;

  fnInput(vvnAdjcy, voDist);

  voDist[1].m_nDist = 0;
  qnBFSrch.push(1);
  fnBreadthFirstSearch(vvnAdjcy, qnBFSrch, voDist);
  fnResult(voDist);

  return 0;
}

C++: #include <iostream>
#include <vector>
#include <queue>
 
using namespace std;
static const int INF = 1e9;
static const int SIZE = 101;
typedef pair<int, int> P;
 
int d[SIZE];
vector<int> G[SIZE];
 
void solve()
{
    int n;
    cin >> n;
    for (int i = 0; i < n; ++i)
    {
        int u, k;
        cin >> u >> k;
        for (int j = 0; j < k; ++j)
        {
            int v;
            cin >> v;
            G[u].push_back(v);
        }
    }
    for (int i = 0; i < SIZE; ++i)
    {
        d[i] = INF;
    }
    d[1] = 0;
    queue<P> que;
    que.push(P(0, 1));
    while (!que.empty())
    {
        P p = que.front();
        que.pop();
        int v = p.second;
        for (int i = 0; i < G[v].size(); ++i)
        {
            int to = G[v][i];
            if (d[to] > p.first + 1)
            {
                d[to] = p.first + 1;
                que.push(P(d[to], to));
            }
        }
    }
    for (int i = 1; i <= n; ++i)
    {
        if (d[i] == INF)
        {
            cout << i << " " << -1 << endl;
        }
        else
        {
            cout << i << " " << d[i] << endl;
        }
    }
}
 
int main()
{
    solve();
    return(0);
}

C++: #include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <string>
#include <cctype>
#include <stack>
#include <queue>
#include <vector>
#include <cstdlib>
#include <list>
#define _USE_MATH_DEFINES
#include <math.h>

using namespace std;

static const int N = 100;
static const int INFTY = (1 << 21);

int n, M[N][N] = { 0 }, d[N];

void bfs(int s);

int main() {

	int u, k, v;

	cin >> n;

	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);

	return 0;
}

void bfs(int s) {
	queue<int> q;
	q.push(s);

	for (int i = 0; i < n; i++) {
		d[i] = INFTY;
	}
	d[s] = 0;
	int u;
	while (!q.empty()) {
		u = q.front();
		q.pop();
		for (int v = 0; v < n; v++) {
			if (M[u][v] == 0)continue;
			if (d[v] != INFTY)continue;
			d[v] = d[u] + 1;
			q.push(v);
		}
	}
	for (int i = 0; i < n; i++) {
		cout << i + 1 << " " << ((d[i] == INFTY) ? (-1) : d[i]) << endl;
	}
}