feat: add solutions to lc problem: No.1466 (doocs#2886)

* feat: add iterative TS solution to lc problem: No.1466

* Update README.md

* Update README_EN.md

* Update Solution2.ts

* Create Solution2.py

* Create Solution2.java

* Create Solution2.cpp

* Create Solution2.go

* style: format code and docs with prettier

---------

Co-authored-by: Libin YANG <contact@yanglibin.info>

Author: rain84

solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/README.md

@@ -230,4 +230,155 @@ impl Solution {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：BFS
+
+我们可以使用广度优先搜索的方法，从节点 $0$ 出发，搜索其他所有节点，过程中，如果遇到需要变更方向的边，则累加一次变更方向的次数。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是题目中节点的数量。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minReorder(self, n: int, connections: List[List[int]]) -> int:
+        g = [[] for _ in range(n)]
+        for a, b in connections:
+            g[a].append((b, 1))
+            g[b].append((a, 0))
+        q = deque([0])
+        vis = {0}
+        ans = 0
+        while q:
+            a = q.popleft()
+            for b, c in g[a]:
+                if b not in vis:
+                    vis.add(b)
+                    q.append(b)
+                    ans += c
+        return ans
+```
+
+```java
+class Solution {
+    public int minReorder(int n, int[][] connections) {
+        List<int[]>[] g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : connections) {
+            int a = e[0], b = e[1];
+            g[a].add(new int[] {b, 1});
+            g[b].add(new int[] {a, 0});
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        boolean[] vis = new boolean[n];
+        vis[0] = true;
+        int ans = 0;
+        while (!q.isEmpty()) {
+            int a = q.poll();
+            for (var e : g[a]) {
+                int b = e[0], c = e[1];
+                if (!vis[b]) {
+                    vis[b] = true;
+                    q.offer(b);
+                    ans += c;
+                }
+            }
+        }
+        return ans;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minReorder(int n, vector<vector<int>>& connections) {
+        vector<pair<int, int>> g[n];
+        for (auto& e : connections) {
+            int a = e[0], b = e[1];
+            g[a].emplace_back(b, 1);
+            g[b].emplace_back(a, 0);
+        }
+        queue<int> q{{0}};
+        vector<bool> vis(n);
+        vis[0] = true;
+        int ans = 0;
+        while (q.size()) {
+            int a = q.front();
+            q.pop();
+            for (auto& [b, c] : g[a]) {
+                if (!vis[b]) {
+                    vis[b] = true;
+                    q.push(b);
+                    ans += c;
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```go
+func minReorder(n int, connections [][]int) (ans int) {
+	g := make([][][2]int, n)
+	for _, e := range connections {
+		a, b := e[0], e[1]
+		g[a] = append(g[a], [2]int{b, 1})
+		g[b] = append(g[b], [2]int{a, 0})
+	}
+	q := []int{0}
+	vis := make([]bool, n)
+	vis[0] = true
+	for len(q) > 0 {
+		a := q[0]
+		q = q[1:]
+		for _, e := range g[a] {
+			b, c := e[0], e[1]
+			if !vis[b] {
+				vis[b] = true
+				q = append(q, b)
+				ans += c
+			}
+		}
+	}
+	return
+}
+```
+
+```ts
+function minReorder(n: number, connections: number[][]): number {
+    const g: [number, number][][] = Array.from({ length: n }, () => []);
+    for (const [a, b] of connections) {
+        g[a].push([b, 1]);
+        g[b].push([a, 0]);
+    }
+
+    const q: number[] = [0];
+    const vis = new Set<number>();
+    vis.add(0);
+
+    let ans = 0;
+    while (q.length) {
+        const a = q.pop()!;
+        for (const [b, c] of g[a]) {
+            if (!vis.has(b)) {
+                vis.add(b);
+                q.push(b);
+                ans += c;
+            }
+        }
+    }
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/README_EN.md

@@ -229,4 +229,155 @@ impl Solution {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 2: BFS
+
+We can use the Breadth-First Search (BFS) method, starting from node $0$, to search all other nodes. During the process, if we encounter an edge that requires a change of direction, we increment the count of direction changes.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the number of nodes in the problem.
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minReorder(self, n: int, connections: List[List[int]]) -> int:
+        g = [[] for _ in range(n)]
+        for a, b in connections:
+            g[a].append((b, 1))
+            g[b].append((a, 0))
+        q = deque([0])
+        vis = {0}
+        ans = 0
+        while q:
+            a = q.popleft()
+            for b, c in g[a]:
+                if b not in vis:
+                    vis.add(b)
+                    q.append(b)
+                    ans += c
+        return ans
+```
+
+```java
+class Solution {
+    public int minReorder(int n, int[][] connections) {
+        List<int[]>[] g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : connections) {
+            int a = e[0], b = e[1];
+            g[a].add(new int[] {b, 1});
+            g[b].add(new int[] {a, 0});
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        boolean[] vis = new boolean[n];
+        vis[0] = true;
+        int ans = 0;
+        while (!q.isEmpty()) {
+            int a = q.poll();
+            for (var e : g[a]) {
+                int b = e[0], c = e[1];
+                if (!vis[b]) {
+                    vis[b] = true;
+                    q.offer(b);
+                    ans += c;
+                }
+            }
+        }
+        return ans;
+    }
+}
+```
+
+```cpp
+class Solution {
+public:
+    int minReorder(int n, vector<vector<int>>& connections) {
+        vector<pair<int, int>> g[n];
+        for (auto& e : connections) {
+            int a = e[0], b = e[1];
+            g[a].emplace_back(b, 1);
+            g[b].emplace_back(a, 0);
+        }
+        queue<int> q{{0}};
+        vector<bool> vis(n);
+        vis[0] = true;
+        int ans = 0;
+        while (q.size()) {
+            int a = q.front();
+            q.pop();
+            for (auto& [b, c] : g[a]) {
+                if (!vis[b]) {
+                    vis[b] = true;
+                    q.push(b);
+                    ans += c;
+                }
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```go
+func minReorder(n int, connections [][]int) (ans int) {
+	g := make([][][2]int, n)
+	for _, e := range connections {
+		a, b := e[0], e[1]
+		g[a] = append(g[a], [2]int{b, 1})
+		g[b] = append(g[b], [2]int{a, 0})
+	}
+	q := []int{0}
+	vis := make([]bool, n)
+	vis[0] = true
+	for len(q) > 0 {
+		a := q[0]
+		q = q[1:]
+		for _, e := range g[a] {
+			b, c := e[0], e[1]
+			if !vis[b] {
+				vis[b] = true
+				q = append(q, b)
+				ans += c
+			}
+		}
+	}
+	return
+}
+```
+
+```ts
+function minReorder(n: number, connections: number[][]): number {
+    const g: [number, number][][] = Array.from({ length: n }, () => []);
+    for (const [a, b] of connections) {
+        g[a].push([b, 1]);
+        g[b].push([a, 0]);
+    }
+
+    const q: number[] = [0];
+    const vis = new Set<number>();
+    vis.add(0);
+
+    let ans = 0;
+    while (q.length) {
+        const a = q.pop()!;
+        for (const [b, c] of g[a]) {
+            if (!vis.has(b)) {
+                vis.add(b);
+                q.push(b);
+                ans += c;
+            }
+        }
+    }
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution2.cpp

@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int minReorder(int n, vector<vector<int>>& connections) {
+        vector<pair<int, int>> g[n];
+        for (auto& e : connections) {
+            int a = e[0], b = e[1];
+            g[a].emplace_back(b, 1);
+            g[b].emplace_back(a, 0);
+        }
+        queue<int> q{{0}};
+        vector<bool> vis(n);
+        vis[0] = true;
+        int ans = 0;
+        while (q.size()) {
+            int a = q.front();
+            q.pop();
+            for (auto& [b, c] : g[a]) {
+                if (!vis[b]) {
+                    vis[b] = true;
+                    q.push(b);
+                    ans += c;
+                }
+            }
+        }
+        return ans;
+    }
+};

solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution2.go

@@ -0,0 +1,24 @@
+func minReorder(n int, connections [][]int) (ans int) {
+	g := make([][][2]int, n)
+	for _, e := range connections {
+		a, b := e[0], e[1]
+		g[a] = append(g[a], [2]int{b, 1})
+		g[b] = append(g[b], [2]int{a, 0})
+	}
+	q := []int{0}
+	vis := make([]bool, n)
+	vis[0] = true
+	for len(q) > 0 {
+		a := q[0]
+		q = q[1:]
+		for _, e := range g[a] {
+			b, c := e[0], e[1]
+			if !vis[b] {
+				vis[b] = true
+				q = append(q, b)
+				ans += c
+			}
+		}
+	}
+	return
+}

solution/1400-1499/1466.Reorder Routes to Make All Paths Lead to the City Zero/Solution2.java

@@ -0,0 +1,28 @@
+class Solution {
+    public int minReorder(int n, int[][] connections) {
+        List<int[]>[] g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : connections) {
+            int a = e[0], b = e[1];
+            g[a].add(new int[] {b, 1});
+            g[b].add(new int[] {a, 0});
+        }
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        boolean[] vis = new boolean[n];
+        vis[0] = true;
+        int ans = 0;
+        while (!q.isEmpty()) {
+            int a = q.poll();
+            for (var e : g[a]) {
+                int b = e[0], c = e[1];
+                if (!vis[b]) {
+                    vis[b] = true;
+                    q.offer(b);
+                    ans += c;
+                }
+            }
+        }
+        return ans;
+    }
+}