Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Breadth First Search

Write a program which reads an directed graph $G = (V, E)$, and finds the shortest distance from vertex $1$ to each vertex (the number of edges in the shortest path). Vertices are identified by IDs $1, 2, ... n$.

Input

In the first line, an integer $n$ denoting the number of vertices, is given. In the next $n$ lines, adjacent lists of vertex $u$ are given in the following format:

$u$ $k$ $v_1$ $v_2$ ... $v_k$

$u$ is ID of the vertex and $k$ denotes its degree.$v_i$ are IDs of vertices adjacent to $u$.

Constraints

$1 \leq n \leq 100$

Output

For each vertex $u$, print $id$ and $d$ in a line. $id$ is ID of vertex $u$ and $d$ is the distance from vertex $1$ to vertex $u$. If there are no path from vertex $1$ to vertex $u$, print -1 as the shortest distance. Print in order of IDs.

Sample Input 1

4
1 2 2 4
2 1 4
3 0
4 1 3

Sample Output 1

1 0
2 1
3 2
4 1

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

Solution in C# (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;

static class U
{
    public static int INFTY = (1 << 21);
}

class Edge{   
    public int from, to, cost;
    public Edge(int from, int to, int cost = 0)
    {
        this.from = from;
        this.to = to;
        this.cost = cost;
    }
        
    // TODO operator
};

class Node
{
    public List<Edge> edges;
    public int dist;
    public Node(){
        edges = new List<Edge>();
        dist = U.INFTY;
    }
};

class Graph{
    public List<Node> nodes;
    public Graph(int n) {
        nodes = new List<Node>();
        for (int i = 0; i < n; i++)
        {
            nodes.Add(new Node());   
        }
    }

    public Node this[int i]
    {
        get { return nodes[i]; }
    }
};

class Data
{
    public int dist;
    public Edge edge;
    public Data(int dist, Edge edge) {
        this.dist = dist;
        this.edge = edge;
    }
    // TODO operator
};
    
class Program
{
    public static void Main(string[] args)
    {
        int N = int.Parse(Console.ReadLine());
        Graph G = new Graph(N);
        
        for (int i = 0; i < N; i++)
        {
            string[] str = Console.ReadLine().Split(' ');
            int n = int.Parse(str[0]) - 1;
            int c = int.Parse(str[1]);
            for (int j = 0; j < c; j++)
            {
               G[n].edges.Add(new Edge(n, int.Parse(str[2+j]) - 1));                  
            }
        }

        var q = new Queue<Data>();
        q.Enqueue(new Data(0, new Edge(-1, 0)));
        while (q.Count > 0)
        {
            Data d = q.Dequeue();
            Node nd = G[d.edge.to];
            if(nd.dist != U.INFTY) continue;
            nd.dist = d.dist;
            foreach (var ee in nd.edges)
            {
                q.Enqueue(new Data(nd.dist+1, ee));
            }
        }

        for (int i = 0; i < N; i++)
        {
            if (G[i].dist == U.INFTY) G[i].dist = -1;
            Console.WriteLine("{0} {1}", i, G[i].dist);
        }
    }
}