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;
using System.Linq;

public class Program
{
  static List<Node> graphList = new List<Node>();
  static Queue<Node> queue = new Queue<Node>();
  public static void Main(string[] args)
  {
    int n = int.Parse(Console.ReadLine());

    for(int i = 0; i < n; i++)
    {
      var inputLine = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
      var children = new List<int>();
      var childCount = inputLine[1];
      for(int j = 0; j < childCount; j++)
      {
        children.Add(inputLine[j + 2]);
      }
      var node = new Node
      {
          Id = inputLine[0],
          ChildrenIds = children,
          Depth = -1,
      };

      graphList.Add(node);
    }

    Bfs(graphList[0]);

    foreach(var node in graphList)
    {
      Console.WriteLine("{0} {1}", node.Id, node.Depth + 1);
    }
  }

  private static void Bfs(Node start)
  {
    queue.Enqueue(start);
    while(queue.Count > 0)
    {
      var node = queue.Dequeue();
      foreach(var childId in node.ChildrenIds)
      {
        if(graphList[childId - 1].Depth == -1)
        {
          graphList[childId - 1].Depth = node.Depth + 1;
          queue.Enqueue(graphList[childId - 1]);
        }
      }
    }
  }
}

public class Node
{
  public int Id { get; set; }
  public List<int> ChildrenIds { get; set;}
  public int Depth { get; set;}
}