Problem:
Score : 100 points

Problem Statement

There is a directed graph G with N vertices and M edges.
The vertices are numbered 1, 2, \ldots, N, and for each i (1 \leq i \leq M), the i-th directed edge goes from Vertex x_i to y_i.
G does not contain directed cycles.

Find the length of the longest directed path in G.
Here, the length of a directed path is the number of edges in it.

Constraints

All values in input are integers.

2 \leq N \leq 10^5

1 \leq M \leq 10^5

1 \leq x_i, y_i \leq N

All pairs (x_i, y_i) are distinct.

G does not contain directed cycles.

Input

Input is given from Standard Input in the following format:

N M
x_1 y_1
x_2 y_2
:
x_M y_M

Output

Print the length of the longest directed path in G.

Sample Input 1

4 5
1 2
1 3
3 2
2 4
3 4

Sample Output 1

3

The red directed path in the following figure is the longest:

Sample Input 2

6 3
2 3
4 5
5 6

Sample Output 2

2

The red directed path in the following figure is the longest:

Sample Input 3

5 8
5 3
2 3
2 4
5 2
5 1
1 4
4 3
1 3

Sample Output 3

3

The red directed path in the following figure is one of the longest:

Solution in Go (1.6) (judge verdict: Accepted)

package main

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

var sc = bufio.NewScanner(os.Stdin)

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

type edge struct {
	node int
}

var g [][]edge
var n int
var m int
var dp [100100]float64

func rec(v int) int {
	if dp[v] != -1 {
		return int(dp[v])
	}

	res := 0.0
	for i := 0; i < len(g[v]); i++ {
		chmax(&res, float64(rec(g[v][i].node))+1)
	}
	dp[v] = res
	return int(dp[v])
}

func main() {
	sc.Split(bufio.ScanWords)
	n = nextInt()
	m = nextInt()
	g = make([][]edge, n)
	for i := 0; i < n; i++ {
		g[i] = make([]edge, 0)
	}

	for i := 0; i < m; i++ {
		u, v := nextInt()-1, nextInt()-1
		g[u] = append(g[u], edge{v})
	}

	// 初期化
	for i := 0; i < n; i++ {
		dp[i] = -1
	}

	res := 0.0
	for i := 0; i < n; i++ {
		chmax(&res, float64(rec(i)))
	}
	fmt.Println(res)

}

func chmin(a *float64, b float64) bool {
	if *a > b {
		*a = b
		return true
	}
	return false
}

func chmax(a *float64, b float64) bool {
	if *a < b {
		*a = b
		return true
	}
	return false
}