Go: package main

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

func main() {
	scn := bufio.NewScanner(os.Stdin)
	scn.Split(bufio.ScanWords)
	nextInt := func() int { scn.Scan(); r, _ := strconv.Atoi(scn.Text()); return r }
	w := bufio.NewWriter(os.Stdout)

	n := nextInt()
	vecs := make([][]int, n)
	for i := 0; i < n; i++ {
		u := nextInt()
		k := nextInt()
		for j := 0; j < k; j++ {
			vecs[u-1] = append(vecs[u-1], nextInt()-1)
		}
	}

	ds := make([]int, n)
	fs := make([]int, n)
	founds := make([]bool, n)
	t := 0
	for i := range founds {
		if !founds[i] {
			t = dfs(vecs, ds, fs, founds, i, t)
		}
	}

	for i := 0; i < n; i++ {
		fmt.Fprintln(w, i+1, ds[i], fs[i])
	}

	w.Flush()
}

func dfs(vecs [][]int, ds, fs []int, founds []bool, i, t int) (time int) {
	t++
	ds[i] = t
	founds[i] = true
	for _, v := range vecs[i] {
		if !founds[v] {
			t = dfs(vecs, ds, fs, founds, v, t)
		}
	}
	t++
	fs[i] = t

	return t
}

C++: #include<iostream>
using namespace std;
int visit[101],d[101],f[101],t;
//   訪問状態     発見    完了
int n,M[101][101];
const int WHITE=0; //未訪問
const int GRAY=1;  //訪問はした
void dfs(int u){
  visit[u]=GRAY; //訪問はした
  d[u]=++t; //発見した時刻
  for(int v=0;v<n;v++){
    if(M[u][v]==0) continue; //辺がない
    if(visit[v]==WHITE) dfs(v);
  }
  f[u]=++t; //訪問完了時刻
}
int main(){
  int u,v,k;
  scanf("%d",&n);
  for(int i=0;i<n;i++){
    scanf("%d%d",&u,&k);
    u--;
    for(int j=0;j<k;j++){
      scanf("%d",&v);
      v--;
      M[u][v]=1;
    }
  }
  for(int i=0;i<n;i++){
    if(visit[i]==WHITE) //訪問していないか
      dfs(i); //iを始点に
  }
  for(int i=0;i<n;i++){
    printf("%d %d %d\n",i+1,d[i],f[i]);
  }
  return 0;
}

C++: #include <iostream>
#include <string>
#include <stdio.h>
using namespace std;

int d[100];
int f[100];
int map[100][100];
int tim;
int n;
void visit(int);

int main(){
	tim=0;
	int i,j,k,u,v;
	for(i=0;i<100;i++) d[i]=-1;
	for(i=0;i<100;i++) f[i]=-1;
	cin >> n;
	for(i=0;i<n;i++){
		for(j=0;j<n;j++){
			map[i][j]=0;
		}
	}
	for(i=0;i<n;i++){
		cin>>u>>k;
		for(j=0;j<k;j++){
			cin>>v;
			map[u-1][v-1]=1;
		}
	}
	visit(0);
	// ??¨???????????????????????????????????°?¨????????????¨??????
	for(i=0;i<n;i++){
		cout<< i+1 << " "<<d[i]<< " "<<f[i];
		cout<<endl;
	}
	return 0;
}

void visit(int k){
	int i;
	d[k]=++tim;
	for(i=0;i<n && f[k]==-1;i++){
		if(map[k][i]==1&&d[i]==-1){
			visit(i);
		}
	}
	f[k]=++tim;
}

C++: #include<bits/stdc++.h>

using namespace std;
using ll = long long;


int n;
vector<vector<int>> hen;
vector<int> in, out;
vector<bool> seen;

void dfs(int cur, int& tim)
{
    tim++;
    in[cur] = tim;
    seen[cur] = true;
    for(auto i : hen[cur])
    {
        if(seen[i])continue;
        dfs(i, tim);
    }
    tim++;
    out[cur] = tim;
}


int main()
{
    cin >> n;
    hen.resize(n);
    in.resize(n);
    out.resize(n);
    seen.resize(n);
    for(int i = 0; i < n; i++){
        int u,k;cin >> u >> k; u--;
        for(int j = 0; j < k; j++){
            int v; cin >> v; v--;
            hen[u].push_back(v);
        }
        sort(hen[u].begin(), hen[u].end());
    }

    int t = 0;
    for(int i = 0; i < n; i++){
        if(!seen[i])dfs(i,t);
    }

    for(int i = 0; i < n; i++){
        cout << i + 1 << " " << in[i] << " " << out[i] << endl;
    }
}

C++: #include <iostream>

using namespace std;

#define MAX 100

int n,Time;
int G[MAX][MAX],d[MAX],f[MAX];
bool used[MAX];

void dfs(int v){
  d[v] = Time++;
  used[v] = true;

  for(int i = 0 ; i < n ; i++){
    if(!used[i] && G[v][i]){
      dfs(i);
    }
  }

  f[v] = Time++;
}

int main(){
  cin >> n;

  for(int i = 0 ; i < n ; i++){
    int u,k,v;
    cin >> u >> k;
    for(int j = 0 ; j < k ; j++){
      cin >> v;
      G[u-1][v-1] = v-1;
    }
  }

  Time = 1;
  for(int i = 0 ; i < n ; i++){
    if(!used[i]){
      dfs(i);
    }
  }

  for(int i = 0 ; i < n ; i++){
    cout << i+1 << " " << d[i] << " " << f[i] << endl;
  }

  return 0;
}

C++: #include<queue>
#include<stack>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;
 
int n, dd[100], f[100], tmap[100][100];
int color[100], t = 1;
stack<int> S;
 
int a(){
    int d = S.top();
    dd[d] = t;
    t++;
    color[d] = 1;

    for (int i = 1; i <= n; i++){
        if (color[i] == 0 && tmap[d][i] == 1){
            S.push(i);
            a();
        }
    }

    f[d] = t;
    t++;
    return 0;
}
 
 
int main(){
    cin >> n;
    for (int i = 0; i < 100; i++){
        dd[i] = f[i] = color[i] = 0;
        for (int j = 0; j < 100; j++){
            tmap[i][j] = 0;
        }
    }
 
    int u, k, v;
 
    for (int i = 0; i < n; i++){
        cin >> u >> k;
        for (int j = 0; j < k; j++){
            cin >> v;
            tmap[u][v] = 1;
        }
    }
    for(int i=1;i<=n;i++){
        if(color[i] == 0){
             S.push(i);
             a();
         }
    }
    for (int i = 1; i <= n; i++){
        cout << i << " " << dd[i] << " " << f[i] << endl;
    }
    return 0;
}

C++: #include <iostream>
#include <string>
#include <map>
#include <stack>
#include <algorithm>
using namespace std;
#define MAX 100000

static const int N=100;
static const int WHITE=0;
static const int GRAY=1;
static const int BLACK=2;

int n, M[N][N];
int color[N],d[N],f[N],tt;
int nt[N];

int next(int u){
  for(int v=nt[u];v<n;v++){
    nt[u]=v+1;
    if(M[u][v]) return v;
  }
  return -1;
}

void dfs_visit(int r){
  for(int i=0;i<n;i++) nt[i]=0;
  stack<int> S;
  S.push(r);
  color[r]=GRAY;
  d[r]=++tt;
  while(!S.empty()){
    int u=S.top();
    int v=next(u);
    if(v!=-1){
      if(color[v]=WHITE){
        color[v]=GRAY;
        d[v]=++tt;
        S.push(v);
      }
      else{
        S.pop();
        color[u]=BLACK;
        f[u]=++tt;
      }
    }
  }
}

void dfs(){
  for(int i=0;i<n;i++){
    color[i]=white;
    nt[i]=0;
  }
  tt=0;

  for(int u=0;u<n;u++){
    if(color[u]==WHITE) dfs_visit(u);
  }
  for(int i=0;i<n;i++){
    cout << i+1 << " " << d[i] << " " << f[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;
    }
  }
  dfs();
  return 0;
}

C++: #include<iostream>
#include<stack>
#include<queue>
using namespace std;
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;

struct Node{
	int color, d, f;
	queue<int> Q;
};

int main(){
	int n;
	cin >> n;
	Node node[n + 1];
	stack<int> move;
	for(int i = 1; i <= n; i++){
		int u, k, v;
		cin >> u >> k;
		node[u].color = WHITE;
		while(k--){
			cin >> v;
			node[u].Q.push(v);
		}
	}

	move.push(1);
	int tt = 1, p, next;
	node[1].color = GRAY;
	node[1].d = tt;
	tt++;

	while(!move.empty()){
		p = move.top();
		if(node[p].Q.empty()){
			node[p].color = BLACK;
			node[p].f = tt;
			move.pop();
			tt++;
		} else {
			next = node[p].Q.front();
			if(node[next].color == WHITE){
				move.push(next);
				node[next].color == GRAY;
				node[next].d = tt;
				tt++;
			} else {
				node[p].Q.pop();
			}
		}
	}

	for(int i = 1; i <= n; i++){
		cout << i << " " << node[i].d << " " << node[i].f << endl;
	}
	return 0;
}