Go: package main

import (
	"fmt"
)

func main() {
	var n int
	fmt.Scan(&n)
	g := make([][]int, n+1)
	for i := 0; i < n; i++ {
		var u,k int
		fmt.Scan(&u)
		fmt.Scan(&k)
		g[u] = make([]int, k)
		for j := 0; j < k; j++ {
			fmt.Scan(&g[u][j])
		}
	}

	d := make([]int, n+1)
	f := make([]int, n+1)
	dfs(&g, &d, &f, 1, 1)

	for i := 1; i <= n; i++ {
		fmt.Printf("%d %d %d\n", i, d[i], f[i])
	}
}

func dfs(g *[][]int, d *[]int, f *[]int, id int, t int) int {
	if (*d)[id] > 0 {
		return t
	}
	(*d)[id] = t
	t += 1
	for i := 0; i < len((*g)[id]); i++ {
		t = dfs(g, d, f, (*g)[id][i], t)
	}
	(*f)[id] = t
	return t+1
}

C++: #include<iostream>
using namespace std;
#define max 100

int aa[max][max];
int n;
int d[max];
int f[max];
int color[max];
int tt = 0;
int p[max];

void dfscount(int u) {
	color[u - 1] = 1;
	int x = -1;
	for (int i = n-1; i >= 0; i--) {
		if (aa[u - 1][i] == 1 && color[i] == 0) x = i + 1;
	}
	if (x == -1) {
		f[u - 1] = ++tt;
		color[u - 1] = 2;
		if (p[u - 1] == -1) {
			for (int i = 0; i < n; i++) {
				if (color[i] != 2) {
					d[i] = ++tt;
					dfscount(i + 1);
				}
			}
			return;
		}
		dfscount(p[u - 1]);
	}
	else {
		d[x - 1] = ++tt;
		p[x - 1] = u;
		dfscount(x);
	}
}

void dfs() {
	d[0] = ++tt;

	for (int i = 0; i < n; i++) {
		color[i] = 0;
		p[i] = -1;
	}

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

int main()
{
	cin >> n;

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			aa[i][j] = 0;
		}
	}
	for (int i = 0; i < n; i++) {
		int num;
		cin >> num;
		int num1;
		cin >> num1;
		for (int j = 0; j < num1; j++) {
			int x;
			cin >> x;
			aa[num - 1][x - 1] = 1;
		}
	}

	dfs();

	return 0;
}

C++: #include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<climits>
#include<iostream>
#include<sstream>
#include<utility>
#include<map>
#include<vector>
#include<queue>
#include<algorithm>
#include<set>
#include<stack>
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
int N,u,k,x,r=0;
vector<int>V[105];
bool f[105]={0};
P c[105];

void dfs(int p)
{
	if(f[p])return;
	r++;
	f[p]=1;
	c[p].first=r;
	for(int i=0;i<V[p].size();i++)
	{
		dfs(V[p][i]);
	}
	r++;
	c[p].second=r;
}

int main()
{
	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",&x);x--;
			V[u].push_back(x);
		}
		sort(V[u].begin(),V[u].end());
	}
	for(int i=0;i<N;i++)
		dfs(i);
	for(int i=0;i<N;i++)
		printf("%d %d %d\n",i+1,c[i].first,c[i].second);
	return 0;
}

C++: #include<iostream>
#include<stdio.h>
using namespace std;
#define N 100
int n, M[N][N];
int search[N], d[N], f[N], t;

void dfs_visit(int u) {
    int v;
    search[u] = 1;
    d[u] = ++t;
    for (v=0; v<n; v++) {
        if (M[u][v] == 0) continue;
        if (search[v] == 0) {
            dfs_visit(v);
        }
    }
    search[u] = 2;
    f[u] = ++t;
}

void dfs() {
    int u;
    for (u=0; u<n; u++) {
        search[u] = 0;
    }
    t=0;
    for (u=0; u<n; u++) {
        if(search[u] == 0) dfs_visit(u);
    }
    for (u=0; u<n; u++) {
        cout << u+1 << " " << d[u] << " " << f[u] << endl;
    }
}

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

C++: #include <stdio.h>
#define N 100
#define WHITE 0
#define GRAY 1
#define BLACK 2

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

void dfs_visit(int u){
  int v;
  color[u] = GRAY;
  d[u] = ++tt;
  for(v = 0 ; v < n; v++){
    if(M[u][v] == 0 ) continue;
    if(color[v] == WHITE){
      dfs_visit(v);
    }
  }
  color[u] = BLACK;
  f[u] = ++ tt;
}

void dfs(){
  int u;
  for(u = 0 ; u < n ; u++){
    color[u] = WHITE;
  }
  tt = 0;
  for(u = 0 ; u < n ; u++){
    if(color[u] == WHITE) dfs_visit(u);
  }
  for( u = 0 ; u < n ; u++){
    printf("%d %d %d\n" , u+1 , d[u] , f[u]);
  }
}

int main(){
  int u , v , k , i , j;

  scanf("%d" , &n);
  for(i = 0 ; i < n ; i++){
    scanf("%d %d" , &u , &k);
    u--;
    for(j = 0 ; j < k ; j++){
      scanf("%d" , &v);
      v--;
      M[u][v] = 1;
    }
  }

  dfs();

  return 0;
}

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

using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using pint = pair<int, int>;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const int MOD = 1000000009;
const long long INF = 1LL << 60;

vector<bool> seen;
vector<int> first_order;
vector<int> last_order;

void dfs(Graph &G, int v, int& ptr) {
    first_order[v] = ptr++;
    seen[v] = true;
    for (auto nv : G[v]) {
        if (seen[nv]) continue;
        dfs(G, nv, ptr);
    }
    last_order[v] = ptr++;
}

int main() {
    int N;
    cin >> N;
    Graph G(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;
            G[u].push_back(v);
        }
        sort(G[u].begin(), G[u].end());
    }
    seen.assign(N, false);
    first_order.assign(N, 0);
    last_order.assign(N, 0);
    int ptr = 0;
    for (int i = 0; i < N; ++i) {
        if (seen[i] == false) dfs(G, i, ptr);
    }

    for (int i = 0; i < N; ++i) {
        cout << i+1 << " " << first_order[i]+1 << " " << last_order[i]+1 << endl;
    }
    return 0;
}

C++: #include<iostream>
#include<stack>
using namespace 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[N];

int next() {
	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 u = 0; i < n; u++) {
		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 i = 0; i < N; i++) {
			cin >> v;
			v--;
			M[u][v] = 1;
		}
	}
	dfs();

	return 0;
}