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 C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public class MainClass
{
	public const long Giri = 1000000007;
	
	class Node
	{
		public List<int> Vectors {get;set;}
		public Node()
		{
			Vectors = new List<int>();
		}
	}
	public static void Main(string[] args)
	{
		int[] p = Input().ToInt();
		int n = p[0];
		int m = p[1];
		Node[] nodes = new Node[n];
		dp = new long[n+1];
		
		for(int i = 0; i < n; i++)
		{
			nodes[i] = new Node();
			dp[i]=-1;
		}
		for(int i = 0; i < m; i++)
		{
			p = Input().ToInt();
			nodes[p[0]-1].Vectors.Add(p[1]-1);
		}
		long r = 0;
		for(int i = 0; i < n; i++)
		{
			r = Math.Max(r, Update(nodes, i, 0));
		}
		
		Console.WriteLine(r);
	}
	private static long[] dp;
	
	private static long Update(Node[] nodes, int index, long distance)
	{
		if(dp[index]>=distance)
		{
			return dp[index];
		}
		dp[index] = distance;
		long dr = distance;
		foreach(int p in nodes[index].Vectors)
		{
			dr = Math.Max(dr, Update(nodes, p, distance+1));
		}
		return dr;
	}
	
	public static long GCD(long a, long b)
	{
		if(b == 1) return a;
		long p = b / a;
		return GCD(a, b - a*p);
	}
	
	public static string[] Input() { return Console.ReadLine().Split(' '); }
	public static int Clamp(int val, int max, int min = 0) { return Math.Min(max, Math.Max(min, val)); }
}

public static class Smarter
{
	public static int ToInt(this string str) { return int.Parse(str); }
	public static long ToLong(this string str) { return long.Parse(str); }
	public static int[] ToInt(this string[] str)
	{
		int[] r = new int[str.Length];
		for(int i = 0; i < str.Length; i++) r[i] = str[i].ToInt();
		return r;
	 }
	
}