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++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)


#include<bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5, inf = 2e9;
typedef long long ll;
vector<pair<ll, ll> > graph[N];
int nodesNum;

ll dijkstra(int startNode, int destination)
{
    ll maxi=-1e9;
   ll dist[N] = {};
   for (int i = 1; i <= nodesNum; i++)
       dist[i] = inf;
   priority_queue<pair<ll, ll>, vector<pair<ll, ll> >, greater<pair<ll, ll> > > pq;
   pq.push({0, startNode});
   dist[startNode] = 0;
   while (!pq.empty())
   {
       ll node = pq.top().second;
       ll curCost = pq.top().first;
       pq.pop();

       if (curCost > dist[node])
           continue;
       for (ll i=0;i<graph[node].size();i++)
       {
           ll child = graph[node][i].first;
           ll newCost = curCost + graph[node][i].second;
           if (newCost < dist[child])
           {
               pq.push({newCost, child});
               dist[child] = newCost;
               maxi=max(maxi,dist[child]*-1);
           }
       }
   }
   return maxi;
}

int main()
{
   ll edges;
   cin >> nodesNum >> edges;
   while (edges--)
   {
       ll x, y, w=-1;
       cin >> x >> y;
       graph[x].push_back({y, w});

   }
   ll maxi=0;
   for(int i=1;i<=nodesNum;i++)
  {
      maxi=max(maxi,dijkstra(i,1));
  }
  cout<<maxi;
   return 0;
}