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 Rust (1.15.1) (judge verdict: Accepted)

use std::cmp::max;
use std::collections::HashMap;

fn solve(xys: Vec<(usize, usize)>, n: usize) -> usize {
    let mut m = vec![vec![]; n + 1];

    for (x, y) in xys {
        m[x].push(y);
    }

    let mut dp = vec![None; n + 1];

    fn f(x: usize, dp: &mut Vec<Option<usize>>, m: &Vec<Vec<usize>>) -> usize {
        if let Some(n) = dp[x] {
            n
        } else {
            if m[x].is_empty() {
                dp[x] = Some(0);
                0
            } else {
                let mut maxp = 0;
                for &y in m[x].iter() {
                    maxp = max(maxp, f(y, dp, m) + 1);
                }
                dp[x] = Some(maxp);
                maxp
            }
        }
    }

    let mut ans = 0;
    for x in 1..(n + 1) {
        ans = max(ans, f(x, &mut dp, &m));
    }

    ans
}

#[test]
fn solve_test() {
    assert_eq!(solve(vec![(1, 2), (1, 3), (3, 2), (2, 4), (3, 4)], 4), 3);
}

#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => {{
        let mut line = String::new();
        ::std::io::stdin().read_line(&mut line).unwrap();
        line.pop();
        line
    }};
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => {{
        let mut line = String::new();
        ::std::io::stdin().read_line(&mut line).unwrap();
        let iter = line.split_whitespace();
        iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
    }};
}

fn main() {
    let (n, m) = parse_line!(usize, usize);

    let xys = (0..m)
        .map(|_| parse_line!(usize, usize))
        .collect::<Vec<_>>();
    println!("{}", solve(xys, n));
}