Go: package main

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

// I/O
type Scanner struct {
	sc *bufio.Scanner
}

func NewScanner() *Scanner {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)
	sc.Buffer(make([]byte, 1024), int(1e+9))
	return &Scanner{sc}
}

func (s *Scanner) nextStr() string {
	s.sc.Scan()
	return s.sc.Text()
}

func (s *Scanner) nextInt() int {
	i, e := strconv.Atoi(s.nextStr())
	if e != nil {
		panic(e)
	}
	return i
}

func (s *Scanner) nextFloat() float64 {
	f, e := strconv.ParseFloat(s.nextStr(), 64)
	if e != nil {
		panic(e)
	}
	return f
}

func (s *Scanner) nextRuneSlice() []rune {
	return []rune(s.nextStr())
}

func (s *Scanner) nextIntSlice(n int) []int {
	res := make([]int, n)
	for i := 0; i < n; i++ {
		res[i] = s.nextInt()
	}
	return res
}

func (s *Scanner) nextFloatSlice(n int) []float64 {
	res := make([]float64, n)
	for i := 0; i < n; i++ {
		res[i] = s.nextFloat()
	}
	return res
}

// Arithmetic
func max(nums ...int) int {
	m := nums[0]
	for _, i := range nums {
		if m < i {
			m = i
		}
	}
	return m
}

func min(nums ...int) int {
	m := nums[0]
	for _, i := range nums {
		if m > i {
			m = i
		}
	}
	return m
}

func abs(x int) int {
	if x > 0 {
		return x
	}
	return -x
}

func pow(x, y int) int {
	res := 1
	for i := 0; i < y; i++ {
		res *= x
	}
	return res
}

func ceil(a, b int) int {
	if a%b == 0 {
		return a / b
	} else {
		return a/b + 1
	}
}

// Sort
type RuneSlice []rune

func (a RuneSlice) Len() int           { return len(a) }
func (a RuneSlice) Less(i, j int) bool { return a[i] < a[j] }
func (a RuneSlice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

// Main
type Queue struct {
	arr []int
}

func (q *Queue) push(v int) {
	q.arr = append(q.arr, v)
}

func (q *Queue) pop() int {
	res := q.arr[0]
	q.arr = q.arr[1:]
	return res
}

func (q *Queue) isEmpty() bool {
	return len(q.arr) == 0
}

func main() {
	sc := NewScanner()
	wtr := bufio.NewWriter(os.Stdout)
	N := sc.nextInt()
	G := make([][]int, N)
	for i := 0; i < N; i++ {
		u, k := sc.nextInt()-1, sc.nextInt()
		for j := 0; j < k; j++ {
			G[u] = append(G[u], sc.nextInt()-1)
		}
	}
	var q Queue
	seen := make([]int, N)
	for i := 0; i < N; i++ {
		seen[i] = -1
	}
	var search func(cur int)
	search = func(cur int) {
		for i := 0; i < len(G[cur]); i++ {
			next := G[cur][i]
			if seen[next] == -1 {
				q.push(next)
				seen[next] = seen[cur] + 1
			}
		}
	}
	q.push(0)
	seen[0] = 0
	for !q.isEmpty() {
		search(q.pop())
	}

	for i := 0; i < N; i++ {
		fmt.Fprintln(wtr, i+1, seen[i])
	}
	wtr.Flush()
}

C++: /**
 * @brief 幅優先探索のテスト
 * @date  作成日     : 2016/02/13
 * @date  最終更新日 : 2016/02/13
 */



//****************************************
// 必要なヘッダファイルのインクルード
//****************************************

#include <iostream>
#include <iterator>
#include <functional>
#include <utility>
#include <algorithm>
#include <vector>
#include <cassert>



//****************************************
// グラフに関する定義
//****************************************


using weight_t = std::int32_t;
using index_t  = std::int32_t;  

/**
 * @brief  頂点色列挙構造体(scoped enum)
 * @detail (u, v) ∈ Eで頂点uが黒ならば頂点vは灰か黒である
 *         すなわち、黒頂点に隣接する全ての頂点は発見済みである
 *         灰頂点は白頂点に隣接することがあり、これらの頂点が既発見頂点と未発見頂点の境界をなす
 */
enum color : std::int32_t {
    white,  /**< 未発見頂点   */
    black,  /**< 発見済み頂点 */
    gray,   /**< 発見済み頂点 */
};

/**
 * @brief グラフ用ノード(頂点) 
 */
struct vertex {
    index_t index;        /**< 頂点の添字      */
    weight_t d;           /**< 始点sからの距離  */
    index_t pi;           /**< 先行頂点(の添字) */
    union {
        color color;      /**< 頂点の色        */
        bool  visited;    /**< 発見済みか?     */
    };
    weight_t f;           /**< 時刻印          */
    
    vertex() : index(0), d(0), pi(0), color(color::white) {}
};

/**
 * @brief グラフ用エッジ(辺)
 * @note  G = (V, E)を重み関数wを持つ重み付きグラフとすると、
 *        辺(u, v) ∈ Eの重みはw(u, v)と表される
 */
struct edge {
    index_t  u;     /**< 辺の始点u */
    index_t  v;     /**< 辺の終点v */
    weight_t w;     /**< 辺(u, v)への重み(コスト) */
};



using edges    = std::vector<edge>;
using vertices = std::vector<vertex>;
using array    = std::vector<weight_t>;
using matrix   = std::vector<array>;
using list     = std::vector<std::vector<index_t>>;

/**
 * @brief グラフ構造体
 * @note  この構造体はのちに拡張されていく可能性が大きい
 */
struct graph {
    vertices vs;   /**< グラフGに含まれる頂点V */
    edges    es;   /**< グラフGに含まれる辺E */

    list   lst;    /**< 隣接リスト */
    matrix mat;    /**< 隣接行列   */

    enum {
        inf = std::numeric_limits<weight_t>::max() / 3,  /**< @brief 辺が存在しない場合に使用される値  */
        nil = std::numeric_limits<index_t>::min() / 3,   /**< @brief 先行点が存在しない場合に使用される値 */
    };
};



//****************************************
// キューに関する定義
//****************************************

/**
 * @brief キュー
 * @tparam class T         キューの要素の型
 * @tparam class Allocator Tのアロケータ 
 */
template <class T, class Allocator = std::allocator<T>>
struct queue {
    std::vector<T, Allocator> Q;
    std::int32_t head, tail;
    std::int32_t _max;
    
    explicit queue(std::int32_t n) :Q(n+1), head(0), tail(0), _max(n+1)  { };
    ~queue() {};

    /**< @brief キューが空かどうか判定 */
    bool empty()
    {
        return head == tail;
    }

    /**< @brief キューが満杯かどうか判定 */
    bool full()
    {
        return ((tail + 1) % _max == head);
    }

    /**< @brief キューに要素xを格納する */
    void enqueue(T x)
    {
        assert(!full());        // オーバーフローチェック
        Q[tail] = x;
        tail = (tail + 1) % _max;  // 循環処理
    }

    /**< @brief キューから一番上の要素を取り出す */
    T dequeue()
    {
        assert(!empty());       // アンダーフローチェック
        T x = Q[head];
        head = (head + 1) % _max;  // 循環処理
        return x;
    }
};



//****************************************
// 関数の定義
//****************************************

/**
 * @brief  幅優先探索を行います
 *
 * @note   幅優先探索(breadth-first-search)は最も単純なグラフ探索アルゴリズムの1つである
 *         グラフG=(V, E)を始点(source vertex)sが与えられたとき、幅優先探索はGの辺を組織的に探索して、
 *         sから到達可能なすべての頂点を"発見し"、すべての到達可能な頂点についてsからの距離(変数の最小値)を計算する
 *         さらに、sを根とし、到達可能な頂点をすべて含む「幅優先木」を構成する. sから到達可能な任意の頂点vについて、
 *         幅優先木におけるsからvへの単純道はGにおけるsからvへの「最短路」、すなわち最小数の辺を含む道に対応する
 *         有向グラフと無向グラフのどちらに対してもこのアルゴリズムは正しく動く
 *
 *         探索頂点と未探索頂点の境界を、境界の幅一杯にわたって一様に拡張することが幅優先探索という名前の由来である
 *         すなわち、このアルゴリズムはsから距離k+1にある頂点を発見する前に距離kにあるすべての頂点を発見する
 *
 * @note   手続きBFSはグラフを探索しながら幅優先木を構築する.この木はπ属性に対応する.形式的に言うと、
 *         sを始点とするグラフG=(V, E)に対して、Gの先行点部分グラフ(predecessor subgraph)をGπ=(Vπ, Eπ)として定義する.ただし、
 *           Vπ = { v ∈ V : v.π != NIL } ∪ {s}
 *         かつ
 *           Eπ = { (v.π, v) : v ∈ Vπ - {s} }
 *         である.Vπがsから到達可能な全頂点から構成され、すべてのv∈Vπに対して、sからvに至る唯一の単純道がGπに存在し、
 *         しかもこれがGにおけるsからvに至る最短路になっているとき、先行点部分グラフGπを幅優先木(breadth-first tree)と呼ぶ
 *         幅優先木は連結で|Eπ| = |Vπ| - 1を満たすから、実際に木である. Eπの辺を木辺(tree edge)と呼ぶ
 *
 * @note   BFSの総実行時間はΟ(V+E)である.したがって、幅優先探索はGの隣接リスト表現のサイズの線形時間で走る
 *
 * @param  const graph& G  グラフG
 * @param  std::int32_t s  始点s
 * @return graph bfstree   幅優先木
 */
graph bfs(const graph& G, index_t s)
{
    vertices vs(G.vs.size()); std::copy(G.vs.begin(), G.vs.end(), vs.begin());
    list  adj(G.lst.size()); std::copy(G.lst.begin(), G.lst.end(), adj.begin());

    for (auto& u : vs) {            // すべての頂点uについて、
        u.color = color::white;     // uを白に彩色し、
        u.d     = graph::inf;       // u.dを無限大に設定し、
        u.pi    = graph::nil;       // uの親をNILに設定する
    }
    // 手続き開始と同時に始点sを発見すると考え、
    vs[s].color = color::gray;      // 始点sを灰色に彩色する 
    vs[s].d     = 0;                // s.dを0に初期化し、
    vs[s].pi    = graph::nil;       // 始点の先行点をNILに設定する

    queue<index_t> Q(vs.size());
    Q.enqueue(s);                   // sだけを含むようにQを初期化する

    // 以下のwhile文に対して、つぎのループ不変式が成立する
    // while文の条件判定を行う時点ではキューQはすべての灰頂点を含む
    while (!Q.empty()) {
        index_t u = Q.dequeue();
        for (auto& v : adj[u]) {                 // uの隣接リストに属する各頂点vを考える
            if (vs[v].color == color::white) {   // vが白ならvは未発見である
                vs[v].color = color::gray;       // vを灰色に彩色し、
                vs[v].d     = vs[u].d + 1;       // 距離v.dをu.d+1に設定し、
                vs[v].pi    = u;                 // uをその親v.piとして記録し、
                Q.enqueue(v);                    // vをキューQの末尾に置く
            }
        }
        vs[u].color = color::black;  // uの隣接リストに属するすべての頂点の探索が完了すると、この頂点を黒に彩色する
    }
    // ある頂点を灰に彩色したときには、この頂点をQへ挿入し、ある頂点をQから削除したときには、この頂点を黒に彩色するので、
    // ループ不変式が保存される

    

    graph bfstree; bfstree.vs = std::move(vs); bfstree.lst = std::move(adj);
    return bfstree;
}





int main()
{
    graph G;
    int u, k, v, n;
    std::cin >> n;
    G.vs.resize(n);
    G.lst.resize(n);
    for (int i = 0; i < n; i++) {
        std::cin >> u >> k;
        u--;
        G.lst[i].resize(k);
        for (int j = 0; j < k; j++) {
            std::cin >> v;
            v--;
            G.lst[i][j] = v;
        }
    }

    graph GG = bfs(G, 0);
    for (int i = 0; i < n; i++) {
        std::cout << i + 1 << " "
                  << ((GG.vs[i].d == graph::inf)
                      ? -1 : GG.vs[i].d) << std::endl;
    }
    return 0;
}