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 Kotlin (1.0.0) (judge verdict: Accepted)

fun main(args: Array<String>) {
    val (N, M) = readLine()!!.split(" "). map { it.toInt() }
    val list = Array(N) { mutableListOf<Int>() }
    val sorted = mutableListOf<Int>() // ソートされたグラフ
    // 入次数
    val indegree = IntArray(N)
    for (i in 0 until M) {
        val (x, y) = readLine()!!.split(" "). map { it.toInt() }
        list[x-1].add(y-1)
        indegree[y-1]++ // 入次数をincrement
    }

    // 入次数が0の物がグラフの始点
    val st = mutableListOf<Int>() // 注意 : Stackの方が良い
    list.forEachIndexed { index, mutableList ->
        if (indegree[index] == 0) st.add(index)
    }

    // ソート
    while(st.isNotEmpty()) {
        val i = st[0]; st.removeAt(0)
        sorted.add(i) // ソート済みのリストに追加

        // 隣接する頂点
        list[i].forEach { j ->
            indegree[j]-- // 隣接する頂点の入次数をデクリメント
            if (indegree[j] == 0) st.add(j) // 入次数が0になればstに追加
        }
    }

    // 最長パスを判定
    val ans = IntArray(N)
    ans[0] = 0
    sorted.forEach { i ->
        list[i].forEach {
            ans[it] = Math.max(ans[it], ans[i] + 1)
        }
    }
    println(ans.max())
}