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: Time Limit Exceeded)

#![allow(unused)]

use std::cmp::{min, max};
use std::collections::BinaryHeap;

macro_rules! dbg {
    ($($a:expr),*) => {
        use std::io::Write;
        writeln!(
            std::io::stderr(),
            concat!($(stringify!($a), " = {:?}, "),*),
            $($a),*);
    }
}

//
// Based on EbTech's Scanner https://stackoverflow.com/q/56449027
//
struct Scanner<'a, R: std::io::BufRead> {
    reader: R,
    buf: String,
    iter: std::str::SplitWhitespace<'a>,
}

impl<'a, R: std::io::BufRead> Scanner<'a, R> {
    fn new(reader: R) -> Scanner<'a, R> {
        Scanner { reader: reader, buf: String::new(), iter: "".split_whitespace() }
    }

    fn get_str(&mut self) -> &str {
        if let Some(t) = self.iter.next() {
            return t;
        }
        self.buf.clear();
        self.reader.read_line(&mut self.buf).expect("I/O error");
        self.iter = unsafe { std::mem::transmute(self.buf.split_whitespace()) };
        self.get_str()
    }

    fn get<T: std::str::FromStr>(&mut self) -> T {
        self.get_str().parse().ok().expect("Parse error")
    }
}

fn main() {
    let stdin = std::io::stdin();
    solve(Scanner::new(stdin.lock()));
}

fn solve<R: std::io::BufRead>(mut sc: Scanner<R>) {
    let n: usize = sc.get();
    let m: usize = sc.get();
    let edges: Vec<(usize, usize)> =
        (0..m).map(|_| (sc.get(), sc.get())).collect();

    let mut g = vec![vec![]; n];
    let mut indeg = vec![0; n];
    for (s, t) in edges {
        g[s - 1].push(t - 1);
        indeg[t - 1] += 1;
    }

    let mut ds = vec![0; n];
    let mut q = BinaryHeap::new();

    // 入次数が0の頂点から開始したときにパスは最も長くなる
    for u in 0..n {
        if indeg[u] == 0 {
            q.push((0, u));
            ds[u] = 0;
        }
    }

    while let Some((d, u)) = q.pop() {
        if d != ds[u] {
            continue;
        }
        let d_ = d + 1;
        for &v in &g[u] {
            if ds[v] < d_ {
                q.push((d_, v));
                ds[v] = d_;
            }
        }
    }

    println!("{}", ds.iter().max().unwrap());
}