Go: #include <bits/stdc++.h>
using namespace std;
static const int WHITE = 0;
static const int GRAY  = 1;
static const int BLACK = 2;
static const int N     = 100;

int n, tt;
vector<vector<int>> M(N, vector<int>(N));
vector<int> color(N), d(N), f(N);

void dfs_visit(int u) {
  color[u] = GRAY;
  d[u]     = ++tt;
  for (int 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() {
  tt = 0;

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

int main() {
  int u, v, k;
  cin >> n;
  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();
}

C++: #include<iostream>
#include<stack>
using namespace std;

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];

// uに隣接するvを番号順に取得
int next(int u){
    for(int v=nt[u]; v<n; v++){ // 訪問した場所は探索しなくていいため、v+1にしている？
        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;

    // 未訪問のuを始点として深さ優先探索
    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 argc, char const *argv[])
{
    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--; // 0 origin
        for(int j=0; j<k; j++){
            cin >> v;
            v--;
            M[u][v] = 1;
        }
    }

    dfs();

    return 0;
}

C++: #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define dump(x) cout << (x) << '\n'

using namespace std;
using Graph = vector<vector<int>>;

typedef int64_t Int;
const double pi = M_PI;

vector<bool> seen;
vector<vector<int>> timestamp; // タイムスタンプ

void dfs(const Graph &G, int v, int &time_ptr) {
    // 発見時刻
    timestamp[v][0] = time_ptr++;

    seen[v] = true; // v を探索済みにする

    // v から行ける各頂点について
    for (auto next_v : G[v]) {
        if (seen[next_v])
            continue; // 探索済みなら飛ばす

        dfs(G, next_v, time_ptr); // 再帰探索
    }

    // 完了時刻
    timestamp[v][1] = time_ptr++;
}

int main() {
    // 入力
    int N;
    cin >> N;

    // グラフの入力
    Graph G(N);
    for (int u = 0; u < N; u++) {
        int ig, k, v;
        cin >> ig >> k;
        for (; k >= 1; k--) {
            cin >> v;
            v--;
            G[u].push_back(v);
        }
    }

    // 初期化
    seen.assign(N, false);
    timestamp.assign(N, vector<int>(2, 0));
    int time_ptr = 1;
    // 探索開始
    for (int v = 0; v < N; v++) {
        if (seen[v])
            continue;

        dfs(G, v, time_ptr);
    }

    // 出力
    for (int v = 0; v < N; v++) {
        cout << v + 1 << ' ' << timestamp[v][0] << ' ' << timestamp[v][1] << endl;
    }
}

C++: #include <bits/stdc++.h>
using namespace std;

int t;
vector<int> d, f;
int n;
vector<vector<int> > G;

void dfs(int v) {
  if ( d[v] ) return;
  d[v] = ++t;  

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

  f[v] = ++t;  
}

int main() {
  cin >> n;

  d = vector<int>(n, 0);
  f = vector<int>(n, 0);

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

  for ( int i = 0; i < n; i++ ) {
    for ( int j = 0; j < n; j++ ) {
      if ( j ) cout << " ";
      cout << G[i][j];
    }
    cout << endl;
  }

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

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

C++: #include <iostream>
#include <vector>
#include <stack>
using namespace std;
static const int MAX=101;
bool Visited[MAX]; //??\?????????????¢??????????
vector<int> Adjacency[MAX];
int dTime[MAX]; int fTime[MAX]; //?¢??????°??¶??´????¢?????????¶??´
void dfs(int j,int& clock)
{

    stack<int> S;
    S.push(j);dTime[j]=++clock;
    Visited[j]=true;
    while(!S.empty())
    {
        int p=S.top(); //???????????¶??????
        if(Adjacency[p].size()==0)
        {
            S.pop();
            fTime[p]=++clock;
            continue;
        }
        int i=0;
        if(Adjacency[p].size())
          while(Visited[Adjacency[p][i]]==true)
          {
            i++;
            if(i==Adjacency[p].size()) //???????°??????????????±?????????????
            {
                S.pop();
                fTime[p]=++clock;
                break;
            }
          }
        if(i==Adjacency[p].size()) continue;
        //if founded
        S.push(Adjacency[p][i]); dTime[Adjacency[p][i]]=++clock;
        Visited[Adjacency[p][i]]=true;
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) Visited[i]=false;

    for(int i=1;i<=n;i++)
    {
        int p;cin>>p;
        int num;
        cin>>num;

        for(int j=0;j<num;j++)
        {
            int t;
            cin>>t;
            Adjacency[p].push_back(t);
        }
    }
    int clock=0;
    for(int i=1;i<=n;i++)  //???????????????????????°DFS?£?????????????
    {
        if(Visited[i]==false) dfs(i,clock);
    }
    for(int i=1;i<=n;i++)
        cout<<i<<' '<<dTime[i]<<' '<<fTime[i]<<endl;
}

C++: #include <iostream>
//#define int long long
//#define _DEBUG
#include <vector>
using namespace std;
int const infty = -1, none = -9;

//input
int N, T[107][107]; //T[i][j]:i->T[i][j]の辺

int /*D[107], */t, d[107], f[107];
bool visited[107];
void dfs(int cur){
    visited[cur] = true;
    d[cur] = t;
    t++;
    //cerr << "Visiting " << cur << " " << t << endl;
    for(int j=0; j<107; j++){
        if(T[cur][j]==none) break;
        if(!visited[T[cur][j]]/* || (D[T[cur][j]]!=infty || D[T[cur][j]]>D[cur])*/){
            //D[T[cur][j]] = D[cur]+1;
            dfs(T[cur][j]);
        }
    }
    f[cur] = t;
    t++;
}
void solve(){
    t = 1;
    //D[0] = 0;
    for(int i=0; i<N; i++){
        if(!visited[i]) dfs(i);
    }
}
void get(){
    cin >> N;
    //fill(D, D+N, infty);
    for(int i=0; i<N; i++){
        for(int j=0; j<N; j++){
            T[i][j] = none;
        }
    }

    for(int i=0; i<N; i++){
        int _i, k;
        cin >> _i >> k;
        for(int j=0; j<k; j++){
            int vj;
            cin >> vj;
            T[i][j] = vj-1;
        }
    }
    fill(visited, visited+N, false);
}

signed main(){
    get();
    solve();
    /*for(int i=0; i<N; i++){
        cout << i+1 << " " << D[i] << endl;
    }*/
    for(int i=0; i<N; i++){
        cout << i+1 << " " << d[i] << " " << f[i] << endl;
    }
}