Given a&nbsp;directed acyclic graph,&nbsp;with&nbsp;n&nbsp;vertices numbered from&nbsp;0&nbsp;to&nbsp;n-1,&nbsp;and an array&nbsp;edges&nbsp;where&nbsp;edges[i] = [fromi, toi]&nbsp;represents a directed edge from node&nbsp;fromi&nbsp;to node&nbsp;toi.

Find the smallest set of vertices from which all nodes in the graph are reachable. It's guaranteed that a unique solution exists.

Notice that you can return the vertices in any order.

&nbsp;
Example 1:



Input: n = 6, edges = [[0,1],[0,2],[2,5],[3,4],[4,2]]
Output: [0,3]
Explanation: It's not possible to reach all the nodes from a single vertex. From 0 we can reach [0,1,2,5]. From 3 we can reach [3,4,2,5]. So we output [0,3].

Example 2:



Input: n = 5, edges = [[0,1],[2,1],[3,1],[1,4],[2,4]]
Output: [0,2,3]
Explanation: Notice that vertices 0, 3 and 2 are not reachable from any other node, so we must include them. Also any of these vertices can reach nodes 1 and 4.


&nbsp;
Constraints:


	2 &lt;= n &lt;= 10^5
	1 &lt;= edges.length &lt;= min(10^5, n * (n - 1) / 2)
	edges[i].length == 2
	0 &lt;= fromi,&nbsp;toi &lt; n
	All pairs (fromi, toi) are distinct.

class Solution:
	def findSmallestSetOfVertices(self, n: int, edges: List[List[int]]) -> List[int]:

		parent=[[] for i in range(n)]
		for i in edges:
			parent[i[1]].append(i[0])
		ans=[]
		for i in range(n):
			if len(parent[i])==0:
				ans.append(i)
		return ans
class Solution {
    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {

        int[] indegree = new int[n];

        for(List<Integer> edge : edges) {
            indegree[edge.get(1)]++;
        }

        List<Integer> result = new ArrayList<>();

        for(int i=0; i<n;i ++) {
            if(indegree[i]==0)
                result.add(i);
        }

        return result;
    }
}
class Solution {
public:
    vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
        vector<int>ans;
        vector<int>indegree(n+2),outdegree(n+2);
        for(auto i:edges)
        {
            indegree[i[1]]++;
            outdegree[i[0]]++;
        }
        for(int i=0;i<n;i++)
        {
            if(indegree[i]==0 && outdegree[i]!=0)
            {
                ans.push_back(i);
            }
        }
        return ans;
    }
};
/**
 * @param {number} n
 * @param {number[][]} edges
 * @return {number[]}
 */
var findSmallestSetOfVertices = function(n, edges) {
    let indegree=[];
    for(let i=0;i<n;i++){
        indegree.push(0);
    }
    let ans=[];
    for( const arr of edges ){
        indegree[arr[1]]++;
    }
    for(let i=0;i<n;i++){
        if(indegree[i]==0){
            ans.push(i);
        }
    }
    return ans;
};
Minimum Number of Vertices to Reach All Nodes