feat: add solutions to lc problem: No.1557

No.1557.Minimum Number of Vertices to Reach All Nodes

Author: yanglbme

solution/1500-1599/1557.Minimum Number of Vertices to Reach All Nodes/README.md

@@ -43,27 +43,81 @@
 	<li>所有点对&nbsp;<code>(from<sub>i</sub>, to<sub>i</sub>)</code>&nbsp;互不相同。</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+找出所有入度为 0 的点即可。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def findSmallestSetOfVertices(self, n: int, edges: List[List[int]]) -> List[int]:
+        s = {to for _, to in edges}
+        return [i for i in range(n) if i not in s]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+        Set<Integer> s = new HashSet<>();
+        for (List<Integer> e : edges) {
+            s.add(e.get(1));
+        }
+        List<Integer> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (!s.contains(i)) {
+                ans.add(i);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
+        unordered_set<int> s;
+        for (auto& e : edges) s.insert(e[1]);
+        vector<int> ans;
+        for (int i = 0; i < n; ++i)
+        {
+            if (!s.count(i)) ans.push_back(i);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func findSmallestSetOfVertices(n int, edges [][]int) []int {
+	s := make(map[int]bool)
+	for _, e := range edges {
+		s[e[1]] = true
+	}
+	var ans []int
+	for i := 0; i < n; i++ {
+		if !s[i] {
+			ans = append(ans, i)
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/1500-1599/1557.Minimum Number of Vertices to Reach All Nodes/README_EN.md

@@ -6,26 +6,16 @@
 
 <p>Given a<strong>&nbsp;directed acyclic graph</strong>,&nbsp;with&nbsp;<code>n</code>&nbsp;vertices numbered from&nbsp;<code>0</code>&nbsp;to&nbsp;<code>n-1</code>,&nbsp;and an array&nbsp;<code>edges</code>&nbsp;where&nbsp;<code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>]</code>&nbsp;represents a directed edge from node&nbsp;<code>from<sub>i</sub></code>&nbsp;to node&nbsp;<code>to<sub>i</sub></code>.</p>
 
-
-
 <p>Find <em>the smallest set of vertices from which all nodes in the graph are reachable</em>. It&#39;s guaranteed that a unique solution exists.</p>
 
-
-
 <p>Notice that you can return the vertices in any order.</p>
 
-
-
 <p>&nbsp;</p>
 
 <p><strong>Example 1:</strong></p>
 
-
-
 <p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1500-1599/1557.Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes/images/untitled22.png" style="width: 231px; height: 181px;" /></p>
 
-
-
 <pre>
 
 <strong>Input:</strong> n = 6, edges = [[0,1],[0,2],[2,5],[3,4],[4,2]]
@@ -34,16 +24,10 @@
 
 <b>Explanation: </b>It&#39;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].</pre>
 
-
-
 <p><strong>Example 2:</strong></p>
 
-
-
 <p><img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1500-1599/1557.Minimum%20Number%20of%20Vertices%20to%20Reach%20All%20Nodes/images/untitled.png" style="width: 201px; height: 201px;" /></p>
 
-
-
 <pre>
 
 <strong>Input:</strong> n = 5, edges = [[0,1],[2,1],[3,1],[1,4],[2,4]]
@@ -54,14 +38,10 @@
 
 </pre>
 
-
-
 <p>&nbsp;</p>
 
 <p><strong>Constraints:</strong></p>
 
-
-
 <ul>
 	<li><code>2 &lt;= n &lt;= 10^5</code></li>
 	<li><code>1 &lt;= edges.length &lt;= min(10^5, n * (n - 1) / 2)</code></li>
@@ -77,13 +57,66 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def findSmallestSetOfVertices(self, n: int, edges: List[List[int]]) -> List[int]:
+        s = {to for _, to in edges}
+        return [i for i in range(n) if i not in s]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+        Set<Integer> s = new HashSet<>();
+        for (List<Integer> e : edges) {
+            s.add(e.get(1));
+        }
+        List<Integer> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (!s.contains(i)) {
+                ans.add(i);
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
+        unordered_set<int> s;
+        for (auto& e : edges) s.insert(e[1]);
+        vector<int> ans;
+        for (int i = 0; i < n; ++i)
+        {
+            if (!s.count(i)) ans.push_back(i);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func findSmallestSetOfVertices(n int, edges [][]int) []int {
+	s := make(map[int]bool)
+	for _, e := range edges {
+		s[e[1]] = true
+	}
+	var ans []int
+	for i := 0; i < n; i++ {
+		if !s[i] {
+			ans = append(ans, i)
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/1500-1599/1557.Minimum Number of Vertices to Reach All Nodes/Solution.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    vector<int> findSmallestSetOfVertices(int n, vector<vector<int>>& edges) {
+        unordered_set<int> s;
+        for (auto& e : edges) s.insert(e[1]);
+        vector<int> ans;
+        for (int i = 0; i < n; ++i)
+        {
+            if (!s.count(i)) ans.push_back(i);
+        }
+        return ans;
+    }
+};

solution/1500-1599/1557.Minimum Number of Vertices to Reach All Nodes/Solution.go

@@ -0,0 +1,13 @@
+func findSmallestSetOfVertices(n int, edges [][]int) []int {
+	s := make(map[int]bool)
+	for _, e := range edges {
+		s[e[1]] = true
+	}
+	var ans []int
+	for i := 0; i < n; i++ {
+		if !s[i] {
+			ans = append(ans, i)
+		}
+	}
+	return ans
+}

solution/1500-1599/1557.Minimum Number of Vertices to Reach All Nodes/Solution.java

@@ -0,0 +1,15 @@
+class Solution {
+    public List<Integer> findSmallestSetOfVertices(int n, List<List<Integer>> edges) {
+        Set<Integer> s = new HashSet<>();
+        for (List<Integer> e : edges) {
+            s.add(e.get(1));
+        }
+        List<Integer> ans = new ArrayList<>();
+        for (int i = 0; i < n; ++i) {
+            if (!s.contains(i)) {
+                ans.add(i);
+            }
+        }
+        return ans;
+    }
+}

solution/1500-1599/1557.Minimum Number of Vertices to Reach All Nodes/Solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def findSmallestSetOfVertices(self, n: int, edges: List[List[int]]) -> List[int]:
+        s = {to for _, to in edges}
+        return [i for i in range(n) if i not in s]