Go: package main

import (
	"fmt"
	"os"
	"bufio"
	"strconv"
	"container/list"
)

const MaxNode int = 100

var d []int
var A [][]int
var N int
var l *list.List

func bfs(u int) {
	d[u] = 0
	l.PushBack(u)
	for ;l.Len() != 0; {
		u = l.Front().Value.(int)
		l.Remove(l.Front())
		for v:=0; v<N; v++ {
			if A[u][v] == 0 {
				continue
			}
			if d[v] != -1 {
				continue
			}
			d[v] = d[u] + 1
			l.PushBack(v)
		}
	}
}


func nextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	num, _ := strconv.Atoi(scanner.Text())
	return num
}

func print() {
	for i:=0; i<N; i++ {
		fmt.Printf("%d %d\n", i+1, d[i])
	}
}

func initVariable() {
	d = make([]int, MaxNode)
	A = make([][]int, MaxNode)
	l = list.New()
	for i:=0; i<MaxNode; i++ {
		A[i] = make([]int, MaxNode)
		d[i] = -1
	}
}


func main() {
	initVariable()
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	N = nextInt(scanner)
	for i:=0; i<N; i++ {
		idx := nextInt(scanner)
		cnt := nextInt(scanner)
		for j:=0; j<cnt; j++ {
			node := nextInt(scanner)
			A[idx-1][node-1] = 1 
		}
	}
	bfs(0)
	print()
}

C++: /*
AizuOJ ALDS1_11_C

???;BFS;????´¢;?????????;?¨????
*/
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;

const int MAXN=110, MAXM=110*110, INF=0x3f3f3f3f;
int n;
int adj[MAXN]; // 1 .. n
int to[MAXM], enext[MAXM]; // 1 .. m
int d[MAXN];

int s, v;
void bfs(int start) {
    queue<int> q;
    q.push(start);
    while (!q.empty()) {
        s=q.front();
        q.pop();
        for (int e=adj[s]; e!=0; e=enext[e]) {
            v=to[e];
            if (d[v]>d[s]+1) {
                d[v]=d[s]+1;
                q.push(v); // ?????????????????? !visited
            }
        }
    }
}

void add_edge(int no, int u, int v) {
    to[no]=v;
    enext[no]=adj[u];
    adj[u]=no;
}

int m=0, k, tmp;
//int v;
int main() {
    memset(d, INF, sizeof(d));
    d[1]=0;
    scanf("%d", &n);
    for (int u=1; u<=n; u++) {
        scanf("%d%d", &tmp, &k);
        while (k--) {
            scanf("%d", &v);
            add_edge(++m, u, v);
        }
    }
    bfs(1);
    for (int u=1; u<=n; u++) {
        printf("%d %d\n", u, d[u]==INF ? -1 : d[u]);
    }
    return 0;
}

C++: #include<stdio.h>
int n=0;
int u=0;
int k[101]={0};
int v[101][101]={0};
int d[101];//d[]=short[].
int cur=0;
int fptr=0;
int lptr=0;
int queue[1024]={};
int q2[1024]={};
int max=sizeof(queue)/sizeof(queue[0]);    //データの数/1データの使用メモリ
void enqueue(int p,int m){
	queue[lptr]=p;
	q2[lptr]=m;
	lptr=(lptr+1)%max;//エンキュー
}
void bfs(void){
	int id=0,m=0;
	while(lptr!=fptr){
	id=queue[fptr];
	m=q2[fptr];
	fptr=(fptr+1)%max;//デキュー
	if(d[id]!=-1){
		continue;
	}
	d[id]=m;
	for(int i=0;i<k[id];i++){
		enqueue(v[id][i],m+1);
	}
	}
	return;
	}
	int main(void)
{
	for(int r=0;r<101;r++){
	d[r]=-1;
	}
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&u);
		scanf("%d",&k[u]);
		for(int j=0;j<k[u];j++){
			scanf("%d",&v[u][j]);
		}
	}
		enqueue(1,0);
		
		bfs();
	for(int i=1;i<n+1;i++){
		printf("%d %d\n",i,d[i]);
	}
	return(0);
}

C++: #include<iostream>
using namespace std;
#define NIL -1
int n,ch[200],V[200][200],d[200],a;
void count(int x,int reach){
    d[x]=reach;
    for(int i=1;i<=ch[x];i++){
        int p=V[x][i];
        if(d[p]==NIL||d[p]>reach+1) count(p,reach+1);
    }
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a>>ch[i];
        d[i]=NIL;
        for(int j=1;j<=ch[i];j++){
            cin>>V[i][j];
        }
    }
    count(1,0);
    for(int i=1;i<=n;i++){
        cout<<i<<" "<<d[i]<<endl;
    }
}

C++: #include <iostream>
#include <queue>
using namespace std;
static const int N = 100;
static const int INFTY = (1<<21);

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

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

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) m[i][j] = 0;
    }

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

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

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

int n, M[N][N];
int d[N];

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

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

    cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            M[i][j] = 0;
        }
    }

    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 <stdio.h>

#define N 100     
#define SUCCESS 1 // 成功
#define FAILURE 0 // 失敗
#define INFTY 1 << 21 // 到達不可能を表す大きな値

int queue[N]; // キューの本体
int queue_head = 0; // データ先頭
int queue_num; // データ個数

int node_num, M[N][N];
int d[N]; // 距離で訪問状態(color)を管理する

int enqueue(int enq_data) // キューにデータを追加する
{
  if (queue_head + queue_num < N) {
    queue[queue_head + queue_num] = enq_data;
    queue_num++;
    return SUCCESS;
  } else {
    return FAILURE;
  }
}

int dequeue(int *deq_data) // キューからデータを取り出す
{
  if (queue_num > 0) {
    *deq_data = queue[queue_head];
    queue_num--;
    queue_head++;
    return SUCCESS;
  } else {
    return FAILURE;
  }
}

void bfs(int s) {
  enqueue(s); // 始点をキューに入れる
  for (int i = 1; i <= node_num; i++) d[i] = INFTY; // とりあえず全部INFTYにする
  d[s] = 0; // 始点から自分自身までの距離は0
  int u, p;
  while(queue_num > 0) { // キューが空でない間繰り返す
    u = queue[queue_head]; // キューの先頭からノードを取り出し，訪問
    dequeue(&p); // 同上
    for (int v = 1; v <= node_num; v++) {
        if (M[u][v] == 0) continue; // キュー先頭のノードとvが繋がってないならこのループは終了
        if (d[v] != INFTY) continue; // 既に距離を決めているならこのループは終了
        d[v] = d[u] + 1; // 次に訪問するノードまでの距離は，それまでの距離+1
        enqueue(v); // uに繋がっているノードは将来訪問しないといけない
    }
  }
  for (int i = 1; i <= node_num; i++) { // 表示部
    if (d[i] == INFTY) d[i] = -1;
    printf("%d %d\n", i, d[i]);
  }
}

// mainの流れはdfsと同じ(隣接行列の初期化→隣接行列にノード間の接続関係を登録→bfsを呼び出す)
int main(void)
{
  int u, v, k, i, j;
  
  scanf("%d", &node_num);
  for (i = 0; i <= node_num; i++) {
    for(j = 0; j <= node_num; j++) M[i][j] = 0;
  }

  for (i = 0; i < node_num; i++) {
    scanf("%d %d", &u, &k);
    for (j = 0; j < k; j++) {
      scanf("%d", &v);
      M[u][v] = 1;
    }
  }

  bfs(1);
  
  return 0;
}