output_description: For each vertex, print $id$, $d$ and $f$ separated by a space character in a
  line. $id$ is ID of the vertex, $d$ and $f$ is the discover time and the
  finish time respectively. Print in order of vertex IDs.
input_description: In the first line, an integer $n$ denoting the number of vertices of $G$ is
  given. In the next $n$ lines, adjacency lists of $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$.
attempt: class Node:
      def __init__(self, v):
          self.d = 0
          self.f = 0
          self.v = v
  
      def __repr__(self):
          return "Node({},{},{})".format(self.d, self.f, self.v)
  
  
  def read_node():
      n = int(input())
      adj_list = [[] for _ in range(n + 1)]
  
      for _ in range(n):
          id, _, *v = [int(x) for x in input().split()]
          adj_list[id] = Node(v)
  
      return adj_list
  
  
  def depth_first_search(adj_list):
      def dfs(id):
          nonlocal adj_list, timestamp
  
          adj_list[id].d = timestamp
          for adj_id in adj_list[id].v:
              if adj_list[adj_id].d == 0:
                  timestamp += 1
                  dfs(adj_id)
          timestamp += 1
          adj_list[id].f = timestamp
  
      timestamp = 1
      for id in range(1, len(adj_list)):
          if adj_list[id].d == 0:
              dfs(id)
              timestamp += 1
  
  
  def print_result(adj_list):
      for id in range(1, len(adj_list)):
          print(id, adj_list[id].d, adj_list[id].f)
  
  
  def main():
      adj_list = read_node()
      depth_first_search(adj_list)
      print_result(adj_list)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Depth First Search
  
  Depth-first search (DFS) follows the strategy to search ”deeper” in the graph
  whenever possible. In DFS, edges are recursively explored out of the most
  recently discovered vertex $v$ that still has unexplored edges leaving it.
  When all of $v$'s edges have been explored, the search ”backtracks” to explore
  edges leaving the vertex from which $v$ was discovered.
  
  This process continues until all the vertices that are reachable from the
  original source vertex have been discovered. If any undiscovered vertices
  remain, then one of them is selected as a new source and the search is
  repeated from that source.
  
  DFS timestamps each vertex as follows:
  
    * $d[v]$ records when $v$ is first discovered.
    * $f[v]$ records when the search finishes examining $v$’s adjacency list.
  
  Write a program which reads a directed graph $G = (V, E)$ and demonstrates DFS
  on the graph based on the following rules:
  
    * $G$ is given in an adjacency-list. Vertices are identified by IDs $1, 2,... n$ respectively.
    * IDs in the adjacency list are arranged in ascending order.
    * The program should report the discover time and the finish time for each vertex.
    * When there are several candidates to visit during DFS, the algorithm should select the vertex with the smallest ID.
    * The timestamp starts with 1.
samples: [{"input": "4\n    1 1 2\n    2 1 4\n    3 0\n    4 1 3", "output": "1 1 8\n    2 2 7\n    3 4 5\n    4 3 6"}, {"input": "6\n    1 2 2 3\n    2 2 3 4\n    3 1 5\n    4 1 6\n    5 1 6\n    6 0", "output": "1 1 12\n    2 2 11\n    3 3 8\n    4 9 10\n    5 4 7\n    6 5 6\n    \n\n![](https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE2_ALDS1_11_B_2)\n\nThis is example for Sample Input 2 (discover/finish)"}]