feat: add solutions to lc problem: No.2359 (#4423)

No.2359.Find Closest Node to Given Two Nodes

Author: yanglbme

solution/2300-2399/2359.Find Closest Node to Given Two Nodes/README.md

@@ -86,25 +86,25 @@ tags:
 ```python
 class Solution:
     def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
-        def dijkstra(i):
+        def f(i):
             dist = [inf] * n
             dist[i] = 0
-            q = [(0, i)]
+            q = deque([i])
             while q:
-                i = heappop(q)[1]
+                i = q.popleft()
                 for j in g[i]:
-                    if dist[j] > dist[i] + 1:
+                    if dist[j] == inf:
                         dist[j] = dist[i] + 1
-                        heappush(q, (dist[j], j))
+                        q.append(j)
             return dist
 
         g = defaultdict(list)
         for i, j in enumerate(edges):
             if j != -1:
                 g[i].append(j)
         n = len(edges)
-        d1 = dijkstra(node1)
-        d2 = dijkstra(node2)
+        d1 = f(node1)
+        d2 = f(node2)
         ans, d = -1, inf
         for i, (a, b) in enumerate(zip(d1, d2)):
             if (t := max(a, b)) < d:
@@ -129,8 +129,8 @@ class Solution {
                 g[i].add(edges[i]);
             }
         }
-        int[] d1 = dijkstra(node1);
-        int[] d2 = dijkstra(node2);
+        int[] d1 = f(node1);
+        int[] d2 = f(node2);
         int d = 1 << 30;
         int ans = -1;
         for (int i = 0; i < n; ++i) {
@@ -143,19 +143,18 @@ class Solution {
         return ans;
     }
 
-    private int[] dijkstra(int i) {
+    private int[] f(int i) {
         int[] dist = new int[n];
         Arrays.fill(dist, 1 << 30);
         dist[i] = 0;
-        PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] - b[0]);
-        q.offer(new int[] {0, i});
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(i);
         while (!q.isEmpty()) {
-            var p = q.poll();
-            i = p[1];
+            i = q.poll();
             for (int j : g[i]) {
-                if (dist[j] > dist[i] + 1) {
+                if (dist[j] == 1 << 30) {
                     dist[j] = dist[i] + 1;
-                    q.offer(new int[] {dist[j], j});
+                    q.offer(j);
                 }
             }
         }
@@ -179,26 +178,24 @@ public:
         }
         const int inf = 1 << 30;
         using pii = pair<int, int>;
-        auto dijkstra = [&](int i) {
+        auto f = [&](int i) {
             vector<int> dist(n, inf);
             dist[i] = 0;
-            priority_queue<pii, vector<pii>, greater<pii>> q;
-            q.emplace(0, i);
+            queue<int> q{{i}};
             while (!q.empty()) {
-                auto p = q.top();
+                i = q.front();
                 q.pop();
-                i = p.second;
                 for (int j : g[i]) {
-                    if (dist[j] > dist[i] + 1) {
+                    if (dist[j] == inf) {
                         dist[j] = dist[i] + 1;
-                        q.emplace(dist[j], j);
+                        q.push(j);
                     }
                 }
             }
             return dist;
         };
-        vector<int> d1 = dijkstra(node1);
-        vector<int> d2 = dijkstra(node2);
+        vector<int> d1 = f(node1);
+        vector<int> d2 = f(node2);
         int ans = -1, d = inf;
         for (int i = 0; i < n; ++i) {
             int t = max(d1[i], d2[i]);
@@ -224,27 +221,27 @@ func closestMeetingNode(edges []int, node1 int, node2 int) int {
 		}
 	}
 	const inf int = 1 << 30
-	dijkstra := func(i int) []int {
+	f := func(i int) []int {
 		dist := make([]int, n)
 		for j := range dist {
 			dist[j] = inf
 		}
 		dist[i] = 0
-		q := hp{}
-		heap.Push(&q, pair{0, i})
+		q := []int{i}
 		for len(q) > 0 {
-			i := heap.Pop(&q).(pair).i
+			i = q[0]
+			q = q[1:]
 			for _, j := range g[i] {
-				if dist[j] > dist[i]+1 {
+				if dist[j] == inf {
 					dist[j] = dist[i] + 1
-					heap.Push(&q, pair{dist[j], j})
+					q = append(q, j)
 				}
 			}
 		}
 		return dist
 	}
-	d1 := dijkstra(node1)
-	d2 := dijkstra(node2)
+	d1 := f(node1)
+	d2 := f(node2)
 	ans, d := -1, inf
 	for i, a := range d1 {
 		b := d2[i]
@@ -256,15 +253,6 @@ func closestMeetingNode(edges []int, node1 int, node2 int) int {
 	}
 	return ans
 }
-
-type pair struct{ d, i int }
-type hp []pair
-
-func (h hp) Len() int           { return len(h) }
-func (h hp) Less(i, j int) bool { return h[i].d < h[j].d }
-func (h hp) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
-func (h *hp) Push(v any)        { *h = append(*h, v.(pair)) }
-func (h *hp) Pop() any          { a := *h; v := a[len(a)-1]; *h = a[:len(a)-1]; return v }
 ```
 
 #### TypeScript
@@ -309,187 +297,50 @@ function closestMeetingNode(edges: number[], node1: number, node2: number): numb
 }
 ```
 
-<!-- tabs:end -->
-
-<!-- solution:end -->
-
-<!-- solution:start -->
-
-### 方法二
-
-<!-- tabs:start -->
-
-#### Python3
-
-```python
-class Solution:
-    def closestMeetingNode(self, edges: List[int], node1: int, node2: int) -> int:
-        def f(i):
-            dist = [inf] * n
-            dist[i] = 0
-            q = deque([i])
-            while q:
-                i = q.popleft()
-                for j in g[i]:
-                    if dist[j] == inf:
-                        dist[j] = dist[i] + 1
-                        q.append(j)
-            return dist
-
-        g = defaultdict(list)
-        for i, j in enumerate(edges):
-            if j != -1:
-                g[i].append(j)
-        n = len(edges)
-        d1 = f(node1)
-        d2 = f(node2)
-        ans, d = -1, inf
-        for i, (a, b) in enumerate(zip(d1, d2)):
-            if (t := max(a, b)) < d:
-                d = t
-                ans = i
-        return ans
-```
-
-#### Java
-
-```java
-class Solution {
-    private int n;
-    private List<Integer>[] g;
-
-    public int closestMeetingNode(int[] edges, int node1, int node2) {
-        n = edges.length;
-        g = new List[n];
-        Arrays.setAll(g, k -> new ArrayList<>());
-        for (int i = 0; i < n; ++i) {
-            if (edges[i] != -1) {
-                g[i].add(edges[i]);
-            }
-        }
-        int[] d1 = f(node1);
-        int[] d2 = f(node2);
-        int d = 1 << 30;
-        int ans = -1;
-        for (int i = 0; i < n; ++i) {
-            int t = Math.max(d1[i], d2[i]);
-            if (t < d) {
-                d = t;
-                ans = i;
-            }
-        }
-        return ans;
-    }
-
-    private int[] f(int i) {
-        int[] dist = new int[n];
-        Arrays.fill(dist, 1 << 30);
-        dist[i] = 0;
-        Deque<Integer> q = new ArrayDeque<>();
-        q.offer(i);
-        while (!q.isEmpty()) {
-            i = q.poll();
-            for (int j : g[i]) {
-                if (dist[j] == 1 << 30) {
-                    dist[j] = dist[i] + 1;
-                    q.offer(j);
-                }
-            }
-        }
-        return dist;
-    }
-}
-```
+#### Rust
 
-#### C++
+```rust
+use std::collections::VecDeque;
 
-```cpp
-class Solution {
-public:
-    int closestMeetingNode(vector<int>& edges, int node1, int node2) {
-        int n = edges.size();
-        vector<vector<int>> g(n);
-        for (int i = 0; i < n; ++i) {
-            if (edges[i] != -1) {
-                g[i].push_back(edges[i]);
+impl Solution {
+    pub fn closest_meeting_node(edges: Vec<i32>, node1: i32, node2: i32) -> i32 {
+        let n = edges.len();
+        let mut g = vec![Vec::new(); n];
+        for i in 0..n {
+            if edges[i] != -1 {
+                g[i].push(edges[i] as usize);
             }
         }
-        const int inf = 1 << 30;
-        using pii = pair<int, int>;
-        auto f = [&](int i) {
-            vector<int> dist(n, inf);
+        let inf = 1 << 30;
+        let f = |mut i: usize| -> Vec<i32> {
+            let mut dist = vec![inf; n];
             dist[i] = 0;
-            queue<int> q{{i}};
-            while (!q.empty()) {
-                i = q.front();
-                q.pop();
-                for (int j : g[i]) {
-                    if (dist[j] == inf) {
+            let mut q = VecDeque::new();
+            q.push_back(i);
+            while !q.is_empty() {
+                i = q.pop_front().unwrap();
+                for &j in &g[i] {
+                    if dist[j] == inf {
                         dist[j] = dist[i] + 1;
-                        q.push(j);
+                        q.push_back(j);
                     }
                 }
             }
-            return dist;
+            dist
         };
-        vector<int> d1 = f(node1);
-        vector<int> d2 = f(node2);
-        int ans = -1, d = inf;
-        for (int i = 0; i < n; ++i) {
-            int t = max(d1[i], d2[i]);
-            if (t < d) {
+        let d1 = f(node1 as usize);
+        let d2 = f(node2 as usize);
+        let mut ans = -1;
+        let mut d = inf;
+        for i in 0..n {
+            let t = std::cmp::max(d1[i], d2[i]);
+            if t < d {
                 d = t;
-                ans = i;
+                ans = i as i32;
             }
         }
-        return ans;
+        ans
     }
-};
-```
-
-#### Go
-
-```go
-func closestMeetingNode(edges []int, node1 int, node2 int) int {
-	n := len(edges)
-	g := make([][]int, n)
-	for i, j := range edges {
-		if j != -1 {
-			g[i] = append(g[i], j)
-		}
-	}
-	const inf int = 1 << 30
-	f := func(i int) []int {
-		dist := make([]int, n)
-		for j := range dist {
-			dist[j] = inf
-		}
-		dist[i] = 0
-		q := []int{i}
-		for len(q) > 0 {
-			i = q[0]
-			q = q[1:]
-			for _, j := range g[i] {
-				if dist[j] == inf {
-					dist[j] = dist[i] + 1
-					q = append(q, j)
-				}
-			}
-		}
-		return dist
-	}
-	d1 := f(node1)
-	d2 := f(node2)
-	ans, d := -1, inf
-	for i, a := range d1 {
-		b := d2[i]
-		t := max(a, b)
-		if t < d {
-			d = t
-			ans = i
-		}
-	}
-	return ans
 }
 ```