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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

import Data.List hiding (find)
import Data.Array as A
import Data.Array.Unboxed
import Data.Array.MArray
import Data.Array.ST
import Data.Graph
import Control.Monad
import Control.Monad.ST

type DP s = STUArray s Int Int

--DFS
dp_i :: DP s -> Graph -> Vertex -> Int -> ST s Int
dp_i dparr graph v0 n | graph A.! v0 == [] = writeArray dparr v0 0 >> return 0
                      | otherwise = do
   let vs = graph A.! v0
   forM_ vs $ \v -> do
     dpv0 <- readArray dparr v0
     dpv  <- readArray dparr v
     dpv' <- if dpv == (-1) then dp_i dparr graph v n >> readArray dparr v else return dpv
     writeArray dparr v0 $ max dpv0 (dpv'+1)
   dpv0' <- readArray dparr v0
   return dpv0'

solve :: [Edge] -> Int -> Int -> ST s Int
solve ls n m = do
  let graph = buildG (1,n) ls
  dparr <- newArray (1,n) (-1)
  list  <- forM [1..n] $ \v0 -> dp_i dparr graph v0 n
  let ans = maximum list
  return ans

main :: IO ()
main = do
  [n,m] <- map read.words <$> getLine
  ls <- replicateM m $ do
    (x:y:e) <- map read.words <$> getLine
    return (x,y)
  putStrLn $ show $ runST $ solve ls n m