feat: add solutions to lc problem: No.2368 (doocs#2377)

No.2368.Reachable Nodes With Restrictions

Author: yanglbme

solution/2300-2399/2368.Reachable Nodes With Restrictions/README.md

@@ -51,11 +51,15 @@
 
 ## 解法
 
-### 方法一：DFS/BFS
+### 方法一：DFS
 
-建图，利用哈希表 $vis$ 记录有哪些受限的节点，然后 $DFS$ 或者 $BFS$ 搜索整个图，记录访问过的节点数目。
+我们首先根据给定的边构建一个邻接表 $g$，其中 $g[i]$ 表示与节点 $i$ 相邻的节点列表。然后我们定义一个哈希表 $vis$，用于记录受限节点或者已经访问过的节点，初始时将受限节点加入到 $vis$ 中。
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。
+接下来我们定义一个深度优先搜索函数 $dfs(i)$，表示从节点 $i$ 出发，可以到达的节点数。在 $dfs(i)$ 函数中，我们首先将节点 $i$ 加入到 $vis$ 中，然后遍历节点 $i$ 的相邻节点 $j$，如果 $j$ 不在 $vis$ 中，我们递归调用 $dfs(j)$，并将返回值加到结果中。
+
+最后我们返回 $dfs(0)$ 即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
 
 <!-- tabs:start -->
 
@@ -64,89 +68,76 @@ class Solution:
     def reachableNodes(
         self, n: int, edges: List[List[int]], restricted: List[int]
     ) -> int:
+        def dfs(i: int) -> int:
+            vis.add(i)
+            return 1 + sum(j not in vis and dfs(j) for j in g[i])
+
         g = defaultdict(list)
-        vis = [False] * n
-        for v in restricted:
-            vis[v] = True
         for a, b in edges:
             g[a].append(b)
             g[b].append(a)
-
-        def dfs(u):
-            nonlocal ans
-            if vis[u]:
-                return
-            ans += 1
-            vis[u] = True
-            for v in g[u]:
-                dfs(v)
-
-        ans = 0
-        dfs(0)
-        return ans
+        vis = set(restricted)
+        return dfs(0)
 ```
 
 ```java
 class Solution {
     private List<Integer>[] g;
     private boolean[] vis;
-    private int ans;
 
     public int reachableNodes(int n, int[][] edges, int[] restricted) {
         g = new List[n];
-        Arrays.setAll(g, k -> new ArrayList<>());
         vis = new boolean[n];
-        for (int v : restricted) {
-            vis[v] = true;
-        }
-        for (int[] e : edges) {
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : edges) {
             int a = e[0], b = e[1];
             g[a].add(b);
             g[b].add(a);
         }
-
-        ans = 0;
-        dfs(0);
-        return ans;
+        for (int i : restricted) {
+            vis[i] = true;
+        }
+        return dfs(0);
     }
 
-    private void dfs(int u) {
-        if (vis[u]) {
-            return;
-        }
-        ++ans;
-        vis[u] = true;
-        for (int v : g[u]) {
-            dfs(v);
+    private int dfs(int i) {
+        vis[i] = true;
+        int ans = 1;
+        for (int j : g[i]) {
+            if (!vis[j]) {
+                ans += dfs(j);
+            }
         }
+        return ans;
     }
 }
 ```
 
 ```cpp
 class Solution {
 public:
-    int ans;
-
     int reachableNodes(int n, vector<vector<int>>& edges, vector<int>& restricted) {
-        vector<vector<int>> g(n);
+        vector<int> g[n];
+        vector<int> vis(n);
         for (auto& e : edges) {
             int a = e[0], b = e[1];
-            g[a].push_back(b);
-            g[b].push_back(a);
+            g[a].emplace_back(b);
+            g[b].emplace_back(a);
         }
-        vector<bool> vis(n);
-        for (int v : restricted) vis[v] = true;
-        ans = 0;
-        dfs(0, g, vis);
-        return ans;
-    }
-
-    void dfs(int u, vector<vector<int>>& g, vector<bool>& vis) {
-        if (vis[u]) return;
-        vis[u] = true;
-        ++ans;
-        for (int v : g[u]) dfs(v, g, vis);
+        for (int i : restricted) {
+            vis[i] = true;
+        }
+        function<int(int)> dfs = [&](int i) {
+            vis[i] = true;
+            int ans = 1;
+            for (int j : g[i]) {
+                if (!vis[j]) {
+                    ans += dfs(j);
+                }
+            }
+            return ans;
+        };
+        return dfs(0);
     }
 };
 ```
@@ -182,32 +173,40 @@ func reachableNodes(n int, edges [][]int, restricted []int) int {
 
 ```ts
 function reachableNodes(n: number, edges: number[][], restricted: number[]): number {
-    let res = 0;
-    const vis = new Array(n).fill(false);
-    const map = new Map<number, number[]>();
-    for (const [start, end] of edges) {
-        map.set(start, [...(map.get(start) ?? []), end]);
-        map.set(end, [...(map.get(end) ?? []), start]);
+    const vis: boolean[] = Array(n).fill(false);
+    const g: number[][] = Array.from({ length: n }, () => []);
+    for (const [a, b] of edges) {
+        g[a].push(b);
+        g[b].push(a);
     }
-    const dfs = (cur: number) => {
-        if (restricted.includes(cur) || vis[cur]) {
-            return;
-        }
-        res++;
-        vis[cur] = true;
-        for (const item of map.get(cur) ?? []) {
-            dfs(item);
+    for (const i of restricted) {
+        vis[i] = true;
+    }
+    const dfs = (i: number): number => {
+        vis[i] = true;
+        let ans = 1;
+        for (const j of g[i]) {
+            if (!vis[j]) {
+                ans += dfs(j);
+            }
         }
+        return ans;
     };
-    dfs(0);
-
-    return res;
+    return dfs(0);
 }
 ```
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：BFS
+
+与方法一类似，我们首先根据给定的边构建一个邻接表 $g$，然后定义一个哈希表 $vis$，用于记录受限节点或者已经访问过的节点，初始时将受限节点加入到 $vis$ 中。
+
+接下来我们使用广度优先搜索遍历整个图，统计可以到达的节点数。我们定义一个队列 $q$，初始时将节点 $0$ 加入到 $q$ 中，并且将节点 $0$ 加入到 $vis$ 中。然后我们不断从 $q$ 中取出节点 $i$，累加答案，并将节点 $i$ 的相邻节点中未访问过的节点加入到 $q$ 中，并将这些节点加入到 $vis$ 中。
+
+遍历结束后，返回答案即可。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点数。
 
 <!-- tabs:start -->
 
@@ -216,50 +215,46 @@ class Solution:
     def reachableNodes(
         self, n: int, edges: List[List[int]], restricted: List[int]
     ) -> int:
-        s = set(restricted)
         g = defaultdict(list)
         for a, b in edges:
             g[a].append(b)
             g[b].append(a)
+        vis = set(restricted + [0])
         q = deque([0])
-        vis = [False] * n
-        for v in restricted:
-            vis[v] = True
         ans = 0
         while q:
             i = q.popleft()
             ans += 1
-            vis[i] = True
             for j in g[i]:
-                if not vis[j]:
+                if j not in vis:
                     q.append(j)
+                    vis.add(j)
         return ans
 ```
 
 ```java
 class Solution {
     public int reachableNodes(int n, int[][] edges, int[] restricted) {
         List<Integer>[] g = new List[n];
+        boolean[] vis = new boolean[n];
         Arrays.setAll(g, k -> new ArrayList<>());
-        for (int[] e : edges) {
+        for (var e : edges) {
             int a = e[0], b = e[1];
             g[a].add(b);
             g[b].add(a);
         }
-        boolean[] vis = new boolean[n];
         for (int v : restricted) {
             vis[v] = true;
         }
         Deque<Integer> q = new ArrayDeque<>();
         q.offer(0);
         int ans = 0;
-        while (!q.isEmpty()) {
+        for (vis[0] = true; !q.isEmpty(); ++ans) {
             int i = q.pollFirst();
-            ++ans;
-            vis[i] = true;
             for (int j : g[i]) {
                 if (!vis[j]) {
                     q.offer(j);
+                    vis[j] = true;
                 }
             }
         }
@@ -272,77 +267,78 @@ class Solution {
 class Solution {
 public:
     int reachableNodes(int n, vector<vector<int>>& edges, vector<int>& restricted) {
-        vector<vector<int>> g(n);
-        vector<bool> vis(n);
+        vector<int> g[n];
+        vector<int> vis(n);
         for (auto& e : edges) {
             int a = e[0], b = e[1];
-            g[a].push_back(b);
-            g[b].push_back(a);
+            g[a].emplace_back(b);
+            g[b].emplace_back(a);
+        }
+        for (int i : restricted) {
+            vis[i] = true;
         }
-        for (int v : restricted) vis[v] = true;
         queue<int> q{{0}};
         int ans = 0;
-        while (!q.empty()) {
+        for (vis[0] = true; !q.empty(); ++ans) {
             int i = q.front();
             q.pop();
-            ++ans;
-            vis[i] = true;
-            for (int j : g[i])
-                if (!vis[j]) q.push(j);
+            for (int j : g[i]) {
+                if (!vis[j]) {
+                    vis[j] = true;
+                    q.push(j);
+                }
+            }
         }
         return ans;
     }
 };
 ```
 
 ```go
-func reachableNodes(n int, edges [][]int, restricted []int) int {
+func reachableNodes(n int, edges [][]int, restricted []int) (ans int) {
 	g := make([][]int, n)
 	vis := make([]bool, n)
 	for _, e := range edges {
 		a, b := e[0], e[1]
 		g[a] = append(g[a], b)
 		g[b] = append(g[b], a)
 	}
-	for _, v := range restricted {
-		vis[v] = true
+	for _, i := range restricted {
+		vis[i] = true
 	}
 	q := []int{0}
-	ans := 0
-	for len(q) > 0 {
+	for vis[0] = true; len(q) > 0; ans++ {
 		i := q[0]
 		q = q[1:]
-		ans++
-		vis[i] = true
 		for _, j := range g[i] {
 			if !vis[j] {
+				vis[j] = true
 				q = append(q, j)
 			}
 		}
 	}
-	return ans
+	return
 }
 ```
 
 ```ts
 function reachableNodes(n: number, edges: number[][], restricted: number[]): number {
-    const g = Array.from({ length: n }, () => []);
-    const vis = new Array(n).fill(false);
+    const vis: boolean[] = Array(n).fill(false);
+    const g: number[][] = Array.from({ length: n }, () => []);
     for (const [a, b] of edges) {
         g[a].push(b);
         g[b].push(a);
     }
-    for (const v of restricted) {
-        vis[v] = true;
+    for (const i of restricted) {
+        vis[i] = true;
     }
-    const q = [0];
+    const q: number[] = [0];
     let ans = 0;
-    while (q.length) {
-        const i = q.shift();
-        ++ans;
-        vis[i] = true;
+    for (vis[0] = true; q.length; ++ans) {
+        const i = q.pop()!;
         for (const j of g[i]) {
             if (!vis[j]) {
+                vis[j] = true;
                 q.push(j);
             }
         }