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::VecDeque;

fn read<T: std::str::FromStr>(
    stdin_lock: &mut std::io::StdinLock,
    buf: &mut Vec<u8>,
    delimiter: u8,
) -> T {
    buf.clear();
    let l = std::io::BufRead::read_until(stdin_lock, delimiter, buf).unwrap();
    buf.truncate(l - 1); // remove delimiter
    let s = unsafe { std::str::from_utf8_unchecked(&buf) };
    s.parse().unwrap_or_else(|_| panic!("read"))
}

fn main() {
    let stdin = std::io::stdin();
    let mut stdin_lock = stdin.lock();
    let mut buf: Vec<u8> = Vec::new();
    let n: usize = read(&mut stdin_lock, &mut buf, b' ');
    let m: usize = read(&mut stdin_lock, &mut buf, b'\n');
    let mut ev: Vec<Vec<usize>> = vec![vec![]; n];
    let mut dv = vec![0i32; n];
    for _ in 0..m {
        let x: usize = read(&mut stdin_lock, &mut buf, b' ');
        let y: usize = read(&mut stdin_lock, &mut buf, b'\n');
        ev[x - 1].push(y - 1);
        dv[y - 1] += 1;
    }

    let mut q = VecDeque::new();
    for i in 0..n {
        if dv[i] == 0 {
            q.push_back(i);
        }
    }

    let mut nv = vec![0i32; n];
    while !q.is_empty() {
        let i = q.pop_front().unwrap();
        for &e in ev[i].iter() {
            dv[e] -= 1;
            if dv[e] == 0 {
                q.push_back(e);
                nv[e] = max(nv[e], nv[i] + 1);
            }
        }
    }
    println!("{}", nv.iter().max().unwrap());
}