Go: package main

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

var N int
var A [][]int
var t int
var color, d, f []int

const (
	WHITE = iota
	GRAY
	BLACK
)

func dfsVisit(u int) {
	color[u] = GRAY
	t ++
	d[u] = t
	for v:=0; v<N; v++ {
		if A[u][v] == 0 {
			continue
		}
		if color[v] == WHITE {
			dfsVisit(v)
		}
	}
	color[u] = BLACK
	t++
	f[u] = t
}

func dfs() {
	for u:=0; u<N; u++ {
		if color[u] == WHITE {
			dfsVisit(u)
		}
	}
	for u:=0; u<N; u++{
		fmt.Printf("%d %d %d\n", u+1, d[u], f[u])
	}
}


func nextInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	num, _ := strconv.Atoi(scanner.Text())
	return num
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	N = nextInt(scanner)
	color = make([]int, N)
	d = make([]int, N)
	f = make([]int, N)
	A = make([][]int, N)
	for i:=0; i<N; i++{
		A[i] = make([]int, N)
	}
	for i:=0; i<N; i++{
		index := nextInt(scanner) - 1
		cnt := nextInt(scanner)
		for j:=0; j<cnt; j++ {
			v := nextInt(scanner) - 1
			A[index][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;





//用栈实现深度优先搜索


/**
 * color 标记访问状态的数组，
 * M[N][N] 邻接矩阵 如果存在定点i到顶点j的边，则M[i][j]=trul
 * Stack 栈，暂存访问过程中的顶点
**/
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++){
        nt[u]=v+1;
        if(M[u][v]) return v;
    }
    return -1;
}

//用栈实现深度优先搜索
void dfs(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(u);
    }
    for(int i=0;i<n;i++){
        cout<<i+1<<" "<<d[i]<<" "<<f[i]<<endl;
    }
    return;
}
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<k;i++){
            cin>>v;
            v--;
            M[u][v]=1;
        }
    }

    dfs();
    return 0;
}

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

template<typename T>
T gcd(T a, T b)
{
	return b ? gcd(b, a%b) : a;
}

template<typename T>
T lcm(T a, T b)
{
	return a / gcd(a, b) * b;
}

//(a^e)%mod
template<typename T>
T power(T a, T e, T mod)
{
	if(e == 0)
	{
		return 1;
	}
	if(e % 2 != 0)
	{
		//a^e=a^(e-1)*a
		return (power(a, e - 1, mod) * a) % mod;
	}
	T res = power(a, e / 2, mod);
	//a^e=a^(e/2)*a^(e/2)
	return (res * res) % mod;
}

template<typename T>
class Tree
{
private:
public:
	T data;
	Tree* parent = NULL;
	std::vector<Tree*> children;
	void setData(T x)
	{
		data = x;
	}
	void setParent(Tree* t)
	{
		parent = t;
	}
	void addChild(Tree* t)
	{
		children.push_back(t);
	}
	Tree(){}
	~Tree(){}
	
};

template<typename T>
class Graph
{
public:
	T index;
	vector<T> edge;
	void setEdge(T t)
	{
		edge.push_back(t);
	}
	Graph(){}
	~Graph(){}
};

Graph<int> G[101];
pair<int, int> timeStamp[101] = {};
int cn = 1;

void rec(int now)
{
	if(timeStamp[now].first != 0)
	{
		return;
	}
	timeStamp[now].first = cn++;
	for (auto t : G[now].edge)
	{
		rec(t);
	}
	timeStamp[now].second = cn++;
}

int main()
{
	using namespace std;
	int n;
	cin >> n;
	for (int i = 0; i < n; ++i)
	{
		int index, k;
		cin >> index >> k;
		G[index].index = index;
		for (int j = 0; j < k; ++j)
		{
			int in;
			cin >> in;
			G[index].setEdge(in);
		}
		sort(G[index].edge.begin(), G[index].edge.end());
	}
	for (int i = 1; i <= n; ++i)
	{
		rec(i);
	}
	for (int i = 1; i <= n; ++i)
	{
		cout << i <<" " << timeStamp[i].first << " " << timeStamp[i].second << endl;
	}
	return 0;
}

C++: #include<iostream>

using namespace std;
int v[105],d[105],f[105],m[105][105];
int tt,n;
void dfs(int u)
{
    d[u]=++tt;
    v[u]=true;
    for(int i=0;i<n;i++)
        if(m[u][i]&&!v[i])dfs(i);
    f[u]=++tt;
}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int u,v,k;
        cin>>u>>k;
        for(int j=0;j<k;j++)cin>>v,m[u-1][v-1]=true;
    }
    for(int i=0;i<n;i++)if(!v[i])dfs(i);
    for(int i=0;i<n;i++)cout<<i+1<<' '<<d[i]<<' '<<f[i]<<endl;
    return 0;
}

C++: n = int(raw_input())
 
d = [0 for i in range(n)]
f = [0 for i in range(n)]
a = [[0 for i in range(n)] for j in range(n)]
st = [0 for i in range(n)]
time = [0]
G = [0 for i in range(n)]
 
 
def dfs_visit(s):
    st[s] = 1
    time[0] += 1
    d[s] = time[0]
     
    for k in range(n):  
      if a[s][k] == 1 and st[k] == 0:
          dfs_visit(k)
    st[s] ==2
    time[0] += 1
    f[s] = time[0]
 
def main():
    for s in range(n):
        if st[s] == 0:
            dfs_visit(s)
    for s in range(n):
        print'{0} {1} {2}'.format(s+1, d[s], f[s])
 
for i in range(n):
    G = map(int, raw_input().split())
    for j in range(G[1]):
        a[G[0]-1][G[2+j]-1] = 1

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

void dfs(int cur);

int A[100][100], d[100], f[100];;
int n,t=0;

int main()
{
    	cin>>n;
        
    	for(int i=0;i<n;++i){

		d[i]=0;
		f[i]=0;

        	for(int j=0;j<n;++j){
            		A[i][j]=0;
        	}
        
        	int m,k; //k=number of adj
        	cin>>m>>k;
        	assert(m==i+1);
        
        	for(int j=0;j<k;++j){
            		int adj;
            		cin>>adj;
            		if(adj){
                		A[i][adj-1]=1;
            		}
        	}
    	}

	dfs(0);

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

    	return 0;
}

void dfs(int cur)
{
	t+=1;
	d[cur]=t;

	for(int dst=0;dst<n;++dst){
		if(A[cur][dst]==1&&d[dst]==0){
			dfs(dst);
		}
	}

	t+=1;
	f[cur]=t;

	return;
}