Go: package main

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

type AdjacentList struct {
	matrix [][]int
}

func NewEmptyAdjacentList(dim int) *AdjacentList {
	matrix := make([][]int, dim)
	for i := 0; i < dim; i++ {
		matrix[i] = make([]int, dim)
	}
	return &AdjacentList{matrix: matrix}
}

func (al *AdjacentList) set(node int, adjacent int) {
	al.matrix[node-1][adjacent-1] = 1
}

func (al *AdjacentList) findAdjacentsFor(node int) []int {
	adjacents := []int{}
	for i, v := range al.matrix[node-1] {
		if v == 1 {
			adjacents = append(adjacents, i+1)
		}
	}
	return adjacents
}

type DistanceList struct {
	list []int
}

func NewDistanceList(dim int) *DistanceList {
	list := make([]int, dim)
	for i := 0; i < dim; i++ {
		list[i] = -1
	}
	return &DistanceList{list: list}
}

func (dl *DistanceList) set(node int, distance int) {
	dl.list[node-1] = distance
}

func (dl *DistanceList) get(node int) int {
	return dl.list[node-1]
}

func (dl *DistanceList) isVisited(node int) bool {
	return dl.list[node-1] >= 0
}

type Position struct {
	node     int
	distance int
}

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

	dim, err := nextInt(sc)
	if err != nil {
		panic(err)
	}

	al := NewEmptyAdjacentList(dim)

	for i := 1; i <= dim; i++ {
		node, err := nextInt(sc)
		if err != nil {
			panic(err)
		}

		adjacentNum, err := nextInt(sc)
		if err != nil {
			panic(err)
		}
		for j := 0; j < adjacentNum; j++ {
			adjacent, err := nextInt(sc)
			if err != nil {
				panic(err)
			}
			al.set(node, adjacent)
		}
	}

	dl := NewDistanceList(dim)

	bfs(al, dl)

	for i := 1; i <= dim; i++ {
		fmt.Printf("%d %d\n", i, dl.get(i))
	}
}

func bfs(al *AdjacentList, dl *DistanceList) {
	stack := []Position{Position{node: 1, distance: 0}}
	for len(stack) > 0 {
		currentPosition := stack[0]
		stack = stack[1:]
		if !dl.isVisited(currentPosition.node) {
			dl.set(currentPosition.node, currentPosition.distance)
		}
		for _, v := range al.findAdjacentsFor(currentPosition.node) {
			stack = append(stack, Position{node: v, distance: currentPosition.distance + 1})
		}
	}
}

func nextInt(sc *bufio.Scanner) (int, error) {
	sc.Scan()
	return strconv.Atoi(sc.Text())
}

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

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

  StDist(int nDist) : m_nDist(nDist), m_nDmy(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();

    for (int ny = 1; ny < cnrvvnAdjcy[nx].size(); ++ny)
    {
      if (!cnrvvnAdjcy[nx][ny])          continue;
      if (rvoDist[ny].m_nDist != nIMPOS) continue; 

      int nDist = rvoDist[nx].m_nDist + 1;
      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 "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;
}