Minimum Number of Vertices to Reach All Nodes solution and explanation

def findSmallestSetOfVertices(n, edges):
    has_incoming = [False] * n
    for from_node, to_node in edges:
        has_incoming[to_node] = True
    result = [i for i in range(n) if not has_incoming[i]]
    return result

import java.util.ArrayList;
import java.util.List;

public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
    boolean[] hasIncoming = new boolean[n];
    for (List<Integer> edge : edges) {
        hasIncoming[edge.get(1)] = true;
    }
    List<Integer> result = new ArrayList<>();
    for (int i = 0; i < n; i++) {
        if (!hasIncoming[i]) {
            result.add(i);
        }
    }
    return result;
}

#include <vector>

std::vector<int> findSmallestSetOfVertices(int n, std::vector<std::vector<int>>& edges) {
    std::vector<bool> hasIncoming(n, false);
    std::vector<int> result;
    for (const auto& edge : edges) {
        hasIncoming[edge[1]] = true;
    }
    for (int i = 0; i < n; ++i) {
        if (!hasIncoming[i]) {
            result.push_back(i);
        }
    }
    return result;
}

function findSmallestSetOfVertices(n, edges) {
    const hasIncoming = Array(n).fill(false);
    edges.forEach(([_, to]) => {
        hasIncoming[to] = true;
    });
    const result = [];
    for (let i = 0; i < n; i++) {
        if (!hasIncoming[i]) {
            result.push(i);
        }
    }
    return result;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int* findSmallestSetOfVertices(int n, int** edges, int edgesSize, int* edgesColSize, int* returnSize){
    bool *hasIncoming = (bool*)calloc(n, sizeof(bool));
    int *result = (int*)malloc(n * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < edgesSize; i++) {
        hasIncoming[edges[i][1]] = true;
    }
    for (int i = 0; i < n; i++) {
        if (!hasIncoming[i]) {
            result[(*returnSize)++] = i;
        }
    }
    free(hasIncoming);
    return result;
}

using System.Collections.Generic;

public IList<int> FindSmallestSetOfVertices(int n, IList<IList<int>> edges) {
    bool[] hasIncoming = new bool[n];
    foreach (var edge in edges) {
        hasIncoming[edge[1]] = true;
    }
    var result = new List<int>();
    for (int i = 0; i < n; i++) {
        if (!hasIncoming[i]) {
            result.Add(i);
        }
    }
    return result;
}

function findSmallestSetOfVertices(n: number, edges: number[][]): number[] {
    const cnt: number[] = new Array(n).fill(0);
    for (const [_, t] of edges) {
        cnt[t]++;
    }
    const ans: number[] = [];
    for (let i = 0; i < n; ++i) {
        if (cnt[i] === 0) {
            ans.push(i);
        }
    }
    return ans;
}

func findSmallestSetOfVertices(n int, edges [][]int) (ans []int) {
	cnt := make([]int, n)
	for _, e := range edges {
		cnt[e[1]]++
	}
	for i, c := range cnt {
		if c == 0 {
			ans = append(ans, i)
		}
	}
	return
}

impl Solution {
    pub fn find_smallest_set_of_vertices(n: i32, edges: Vec<Vec<i32>>) -> Vec<i32> {
        let mut arr = vec![true; n as usize];
        edges.iter().for_each(|edge| {
            arr[edge[1] as usize] = false;
        });
        arr.iter()
            .enumerate()
            .filter_map(|(i, &v)| if v { Some(i as i32) } else { None })
            .collect()
    }
}