<p>You are given a <strong>directed</strong> graph of <code>n</code> nodes numbered from <code>0</code> to <code>n - 1</code>, where each node has <strong>at most one</strong> outgoing edge.</p>

<p>The graph is represented with a given <strong>0-indexed</strong> array <code>edges</code> of size <code>n</code>, indicating that there is a directed edge from node <code>i</code> to node <code>edges[i]</code>. If there is no outgoing edge from node <code>i</code>, then <code>edges[i] == -1</code>.</p>

<p>Return <em>the length of the <strong>longest</strong> cycle in the graph</em>. If no cycle exists, return <code>-1</code>.</p>

<p>A cycle is a path that starts and ends at the <strong>same</strong> node.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/06/08/graph4drawio-5.png" style="width: 335px; height: 191px;" />
<pre>
<strong>Input:</strong> edges = [3,3,4,2,3]
<strong>Output:</strong> 3
<strong>Explanation:</strong> The longest cycle in the graph is the cycle: 2 -&gt; 4 -&gt; 3 -&gt; 2.
The length of this cycle is 3, so 3 is returned.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2022/06/07/graph4drawio-1.png" style="width: 171px; height: 161px;" />
<pre>
<strong>Input:</strong> edges = [2,-1,3,1]
<strong>Output:</strong> -1
<strong>Explanation:</strong> There are no cycles in this graph.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>n == edges.length</code></li>
	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
	<li><code>-1 &lt;= edges[i] &lt; n</code></li>
	<li><code>edges[i] != i</code></li>
</ul>

#define pb push_back
class Solution {
public:
    void dfs(int node,int &c,vector<int>&vis,vector<int>adj[]){
        vis[node]=1;
        c++;
        for(auto adjnode:adj[node]){
            if(!vis[adjnode]){
                dfs(adjnode,c,vis,adj);
            }
        }
    }
    int longestCycle(vector<int>& edges) {
        //key in the question,each node will be part of atmost one cycle, so visit the graph using topo sort once, all the unvisited nodes will form part of cycles, simple dfs to conclude the problem
        int n=edges.size();
        vector<int>adj[n];
        vector<int>in(n);
        for(int i=0;i<n;i++){
            if(edges[i]!=-1){
                adj[i].pb(edges[i]);
                in[edges[i]]++;
            }
        }
        queue<int>q;
        vector<int>vis(n);
        for(int i=0;i<n;i++){
            if(in[i]==0){
                vis[i]=1;
                q.push(i);
            }
        }
        int cnt=0;
        while(!q.empty()){
            int node=q.front();
            cnt++;
            q.pop();
            for(auto adjnode:adj[node]){
                in[adjnode]--;
                if(in[adjnode]==0){
                    q.push(adjnode);
                    vis[adjnode]=1;
                }
            }
        }
        if(cnt==n){
            return -1;
        }
        int ans=0;
        for(int i=0;i<n;i++){
            if(!vis[i]){
                int c=0;
                dfs(i,c,vis,adj);
                ans=max(ans,c);
            }
        }
        return ans;

    }
};
141735