Go: package main

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

type vertexId int

type vertex struct {
	id vertexId
	firstVisitAt int
	finishVisitAt int
	adjs []vertexId
}

func createVertex(id int, adjsInt []int) vertex {
	adjs := make([]vertexId, len(adjsInt))
	for i := 0; i < len(adjs); i++ {
		adjs[i] = vertexId(adjsInt[i])
	}
	return vertex{
		id: vertexId(id),
		firstVisitAt: 0,
		finishVisitAt: 0,
		adjs: adjs,
	}
}

func (v *vertex) isVisited() bool {
	return v.firstVisitAt > 0
}

func dfs(currentId vertexId, timestamp int, vertices []vertex) int {
	currentVertex := &vertices[currentId-1]
	if currentVertex.isVisited() {
		return timestamp
	}
	timestamp = timestamp + 1
	currentVertex.firstVisitAt = timestamp
	for _, adjId := range currentVertex.adjs {
		timestamp = dfs(adjId, timestamp, vertices)
	}
	timestamp = timestamp + 1
	currentVertex.finishVisitAt = timestamp
	return timestamp
}

func solveDfs(vertices []vertex) {
	timestamp := 0
	for {
		vid := vertexId(-1)
		for i := 0; i < len(vertices); i++ {
			if !vertices[i].isVisited() {
				vid = vertexId(i+1)
				break
			}
		}
		if vid > 0 {
			timestamp = dfs(vid, timestamp, vertices)
		} else {
			break
		}
	}
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Split(bufio.ScanWords)

	n, err := nextInt(sc)
	if err != nil {
		panic(err)
	}

	vertices := make([]vertex, n)
	for i := 0; i < n; i++ {
		id, err := nextInt(sc)
		if err != nil {
			panic(err)
		}
		adjN, err := nextInt(sc)
		if err != nil {
			panic(err)
		}
		adjs := make([]int, adjN)
		for j := 0; j < adjN; j++ {
			adjId, err := nextInt(sc)
			if err != nil {
				panic(err)
			}
			adjs[j] = adjId
		}
		vertices[i] = createVertex(id, adjs)
	}

	solveDfs(vertices)

	for i := 0; i < n; i++ {
		fmt.Printf("%d %d %d\n", vertices[i].id, vertices[i].firstVisitAt, vertices[i].finishVisitAt)
	}
}

func nextText(sc *bufio.Scanner) string {
	sc.Scan()
	return sc.Text()
}

func nextInt(sc *bufio.Scanner) (int, error) {
	return strconv.Atoi(nextText(sc))
}

C++: #include<iostream>
#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",u+1,d[u],f[u]);
    }
}

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

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

    dfs();
    return 0;
}

C++: #include <iostream>
#include <stdio.h>

using namespace std;

int** gmtrx;
int* d, *f;
int t, n;

class Stack{
public:
	Stack(int num):head(0){
		s = new int [num];
		for(int i=0; i<num; ++i){
			s[i] = 0;
		}
	}
	~Stack(){ delete[] s; }
	void push_back(int vtx){
		s[head++] = vtx;
	}
	int pop_back(){
		--head;
		int tmp = s[head];
		s[head] = 0;
		return tmp;
	}
	int back(){
		if(head<=0) return -1;
		return s[head-1];
	}
private:
	int head;
	int* s;
};


int main()
{
	scanf("%d",&n);

	gmtrx = new int*[n];
	d = new int [n]; //discovery
	f = new int [n]; //finish
	Stack st(n);

	for(int i=0; i<n; ++i){
		gmtrx[i] = new int[n];
		for(int j=0; j<n; ++j){
			gmtrx[i][j] = 0;
		}
		d[i] = 0;
		f[i] = 0;
	}

	for(int i=0; i<n; ++i){
		int v, num, a;
		scanf("%d %d",&v,&num);
		--v;
		for(int j=0; j<num; ++j){
			scanf("%d",&a);
			--a;
			gmtrx[v][a] = 1;
		}
	}

	for(int i=0; i<n; ++i){
		int vtmp=i;
		if( d[vtmp]!= 0) continue;
		st.push_back(vtmp);
		vtmp=0;
		while(st.back()!=-1){
			if(d[st.back()]==0){
				++t;
				d[st.back()] = t;
			}
			else if(f[st.back()]!=0){
				vtmp = st.pop_back();
				++vtmp;
				continue;
			}
			for(int j=vtmp; j<=n; ++j){
				if(j==n){
					++t;
					f[st.back()] = t;
					vtmp = st.pop_back();
					++vtmp;
					break;
				}
				if(gmtrx[st.back()][j]){
					if(d[j]==0) st.push_back(j);
					else continue;
					break;
				}
			}
		}
	}

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

	for(int i=0; i<n; ++i){
		delete[] gmtrx[i];
	}
	delete[] gmtrx;
	delete[] d;
	delete[] f;

	return 0;
}

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

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

    stack<int> s;
    int current_time = 1;
    for (int i = 0; i < n; i++)
    {
        if (time[i][0] == 0)
        {
            int src = i;
            s.push(src);
            while (!s.empty())
            {
                int cur = s.top();
                s.pop();
                //cout << cur << " " << current_time << endl;
                if (time[cur][0] == 0)
                {
                    time[cur][0] = current_time;
                    s.push(cur);
                    for (int dst = n - 1; dst >= 0; dst--)
                    {
                        //cout << cur << " " << dst << " " << Adj[cur][dst] << endl;
                        if (Adj[cur][dst] && time[dst][0] == 0)
                        {
                            s.push(dst);
                        }
                    }
                    current_time++;
                }
                else if (time[cur][0] != 0 && time[cur][1] == 0)
                {
                    time[cur][1] = current_time;
                    current_time++;
                }
            }
        }
    }

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

    return 0;
}