Go: package main

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

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Scan()
	num, _ := strconv.Atoi(sc.Text())
	nodes := make(map[int]*node)

	for i := 0; i < num; i++ {
		sc.Scan()
		id, _ := strconv.Atoi(sc.Text())
		sc.Scan()
		nodeNum, _ := strconv.Atoi(sc.Text())
		n := node{id, make([]int, 0), -1}
		for j := 0; j < nodeNum; j++ {
			sc.Scan()
			nid, _ := strconv.Atoi(sc.Text())
			n.nexts = append(n.nexts, nid)
		}
		nodes[id] = &n
	}
	nodes[1].depth = 0

	walk(1, 0, &nodes)
	for i := 1; i < len(nodes)+1; i++ {
		fmt.Printf("%v %v\n", (*nodes[i]).id, (*nodes[i]).depth)
	}
}

var time int
var record [100][100]bool
var q Queue

func walk(nid int, from int, nodes *map[int]*node) {
	q.Enqueue((*nodes)[nid])
	for !q.IsEmpty() {
		n := q.Dequeue().(*node)
		for _, v := range n.nexts {
			n2 := (*nodes)[v]
			if n2.depth != -1 {
				continue
			}
			n2.depth = n.depth + 1
			q.Enqueue((*nodes)[v])
		}
	}
}

type node struct {
	id    int
	nexts []int
	depth int
}

// Queue is Queue
type Queue struct {
	val []interface{}
}

// Enqueue value
func (queue *Queue) Enqueue(val interface{}) {
	queue.val = append(queue.val, val)
}

// Dequeue value
func (queue *Queue) Dequeue() interface{} {
	res := queue.val[0]
	queue.val = queue.val[1:len(queue.val)]
	return res
}

// IsEmpty return true when queue is empty
func (queue *Queue) IsEmpty() bool {
	return len(queue.val) == 0
}

C++: #include <iostream>
#include "queue"
#include "string.h"
using namespace std;

static const int inf=(1<<21);

int n,m[107][107];
int d[107];

void bfs(int s)
{
	queue<int>q;
	q.push(s);
	for(int i=0;i<n;i++)d[i]=inf;
	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]!=inf)continue;
			d[v]=d[u]+1;
			q.push(v);
		}
	}
	for(int i=0;i<n;i++)
	{
		cout<<i+1<<" "<<((d[i]==inf)?(-1):d[i])<<endl;
	}	
		
}
int main(int argc, char *argv[]) {
	int u,k,v;
	
	cin>>n;
	memset(m, 0, sizeof(m));
	
	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;
}

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

using namespace std;

typedef struct node_{
    int id;
    int d;
    int k;//出次数
    int visited;
    vector<int> v;
}* node;

int main(){
    int n;
    scanf("%d", &n);
    vector<node> graph;
    node dummy;
    graph.push_back(dummy);
    for(int i = 1; i <= n; i++){
        node nd = new node_;
        nd -> d = -1;
        nd -> visited = 0;
        int id, k;
        scanf("%d %d", &id, &k);
        nd -> id = id;
        nd -> k = k;
        for(int i = 0; i < k; i++){
            int v1;
            scanf("%d", &v1);
            nd -> v.push_back(v1);
        }
        graph.push_back(nd);
    }
    graph[1] -> d = 0;

    queue<int> q;
    q.push(1);
    while(q.empty() != 1){
        int num = q.front();
        q.pop();
        node nd = graph[num];
        for(int i = 0; i < nd -> k; i++){
            if(graph[nd -> v[i]] -> d < 0){
                graph[nd -> v[i]] -> d = nd -> d + 1;
                q.push(nd -> v[i]);
            }
        }
    }
    for(int i = 1; i <= n; i++){
        node nd = graph[i];
        printf("%d %d\n", nd -> id, nd -> d);
    }
    return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
int N;
vector<int> dist;
vector<vector<int>> G;
int main(){
    cin >> N;
    dist.assign(N,-1);
    G.resize(N);
    for(int i=0;i<N;i++){
        int id;cin >> id;
        int k;cin >> k;
        for(int j=0;j<k;j++){
            int a;cin >> a;a--;
            G[i].push_back(a);
        }
    }
    queue<int> que;
    que.push(0);
    int d = 0;
    dist[0] = 0;
    while(!que.empty()){
        int now = que.front();
        que.pop();
        for(auto nv:G[now]){
            if(dist[nv]!=-1) continue;
            dist[nv] = dist[now]+1;
            que.push(nv);
        }
    }
    for(int i=0;i<N;i++){
        cout << i+1 << " " << dist[i] << endl;
    }
}

C++: #include <queue>
#include <cstdio>

using std::queue;

int main() {
        int n, u, k, v;
        const int N = 100;
        bool graph[N][N] = {{false}};
        int cost[N];
        queue<int> q;
        for (int i = 0; i < N; i++) {
                cost[i] = -1;
        }

        scanf("%d", &n);
        for (int i = 0; i < n; i++) {
                scanf("%d %d", &u, &k);
                for (int j = 0; j < k; j++) {
                        scanf("%d", &v);
                        graph[u-1][v-1] = true;
                }
        }
        q.push(0);
        cost[0]++;
        while (!q.empty()) {
                int cur = q.front();
                q.pop();
                for (int to = 0; to < n; to++) {
                        if (!graph[cur][to] || cost[to] > -1) {
                                continue;
                        }
                        q.push(to);
                        cost[to] = cost[cur] + 1;
                }
        }
        for (int i = 0; i < n; i++) {
                printf("%d %d\n", i+1, cost[i]);
        }

        return 0;
}

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

const int MAX_N = 100;
int to[MAX_N][MAX_N];
int ans[MAX_N];
bool visited[MAX_N];

int main() {
  int N;
  cin >> N;
  for (int i=0; i<N; i++) {
    for (int j=0; j<N; j++) {
      to[i][j] = -1;
    }
    ans[i] = -1;
    visited[i] = false;
  }
  for (int i=0; i<N; i++) {
    int tmp, n;
    cin >> tmp >> n;
    for (int j=0; j<n; j++) {
      int t;
      cin >> t; t--;
      to[i][j] = t;
    }
  }

  queue<pair<int, int> > que;
  que.push(make_pair(0, 0));
  while (!que.empty()) {
    pair<int, int> tmp = que.front(); que.pop();
    int x = tmp.first, depth = tmp.second;
    if (ans[x] == -1) {
      ans[x] = depth;
    } else {
      continue;
    }
    for (int i=0; to[x][i] != -1; i++) {
      que.push(make_pair(to[x][i], depth + 1));
    }
  }

  for (int i=0; i<N; i++) {
    cout << i+1 << " " << ans[i] << endl;
  }
  return 0;
}

C++: #include<stdio.h>
#include<stack>
#include<iostream>
#include<string>
using namespace std;

int n = 0;//pointing at number of line
int u = 0;//number of top
int k[101];//output order(connect)
int v[101][101];//number of top
int Short[101] = { 0 };//Short(d[v])
//into n = 0;//element count
int p = 0;//Pointer
int fptr = 0;
int lptr = 0;
int x1[10000];
int y1[10000];
void Enqueue(int y, int x)
{
	x1[lptr] = x;//top of number
	y1[lptr] = y;//shortest
	lptr = (lptr + 1) % 10000;
}
void bfs(int l) {
	int i;
	while (fptr!=lptr) {
		l=x1[fptr];
		p=y1[fptr];
		fptr = (fptr + 1) % 10000;
		if(Short[l]!=-1){
			continue;
		}
		for(i=0;i<k[l];i++){
			if(v[l][i]){
				Enqueue(p+1,v[l][i]);
			}
		}
		//Enqueue(v[l][in]);
		Short[l]=++p;
	}
}
int main()
{
	int i;
	int j;
	cin >> n;
	for (i = 0; i < n; i++) {
		cin >> u;
		cin >> k[u];
		for (j = 0; j < k[u]; j++) {
			cin >> v[u][j];
		}
	}
	Enqueue(-1,1);
	for(i=0;i<n+1;i++){
		Short[i]=-1;
	}
	bfs(0);
	
	for (i = 1; i < n + 1; i++) {
		cout << i << " " << Short[i] << endl;
	}
}