feat: add solutions to lc problem: No.1971 (doocs#3568)

No.1971.Find if Path Exists in Graph

Author: yanglbme

solution/1900-1999/1971.Find if Path Exists in Graph/README.md

@@ -1,19 +1,19 @@
 class Solution {
 public:
     bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
-        vector<bool> vis(n);
         vector<int> g[n];
-        for (auto& e : edges) {
-            int a = e[0], b = e[1];
-            g[a].emplace_back(b);
-            g[b].emplace_back(a);
+        vector<bool> vis(n);
+        for (const auto& e : edges) {
+            int u = e[0], v = e[1];
+            g[u].push_back(v);
+            g[v].push_back(u);
         }
         function<bool(int)> dfs = [&](int i) -> bool {
             if (i == destination) {
                 return true;
             }
             vis[i] = true;
-            for (int& j : g[i]) {
+            for (int j : g[i]) {
                 if (!vis[j] && dfs(j)) {
                     return true;
                 }

solution/1900-1999/1971.Find if Path Exists in Graph/README_EN.md

@@ -2,9 +2,9 @@ func validPath(n int, edges [][]int, source int, destination int) bool {
 	vis := make([]bool, n)
 	g := make([][]int, n)
 	for _, e := range edges {
-		a, b := e[0], e[1]
-		g[a] = append(g[a], b)
-		g[b] = append(g[b], a)
+		u, v := e[0], e[1]
+		g[u] = append(g[u], v)
+		g[v] = append(g[v], u)
 	}
 	var dfs func(int) bool
 	dfs = func(i int) bool {
@@ -20,4 +20,4 @@ func validPath(n int, edges [][]int, source int, destination int) bool {
 		return false
 	}
 	return dfs(source)
-}
+}

solution/1900-1999/1971.Find if Path Exists in Graph/Solution.cpp

@@ -4,15 +4,15 @@ class Solution {
     private List<Integer>[] g;
 
     public boolean validPath(int n, int[][] edges, int source, int destination) {
+        this.destination = destination;
+        vis = new boolean[n];
         g = new List[n];
-        Arrays.setAll(g, k -> new ArrayList<>());
+        Arrays.setAll(g, i -> new ArrayList<>());
         for (var e : edges) {
-            int a = e[0], b = e[1];
-            g[a].add(b);
-            g[b].add(a);
+            int u = e[0], v = e[1];
+            g[u].add(v);
+            g[v].add(u);
         }
-        vis = new boolean[n];
-        this.destination = destination;
         return dfs(source);
     }
 
@@ -21,7 +21,7 @@ private boolean dfs(int i) {
             return true;
         }
         vis[i] = true;
-        for (int j : g[i]) {
+        for (var j : g[i]) {
             if (!vis[j] && dfs(j)) {
                 return true;
             }

solution/1900-1999/1971.Find if Path Exists in Graph/Solution.go

@@ -2,18 +2,16 @@ class Solution:
     def validPath(
         self, n: int, edges: List[List[int]], source: int, destination: int
     ) -> bool:
-        def dfs(i):
+        def dfs(i: int) -> bool:
             if i == destination:
                 return True
-            vis.add(i)
-            for j in g[i]:
-                if j not in vis and dfs(j):
-                    return True
-            return False
+            if i in vis:
+                return False
+            return any(dfs(j) for j in g[i])
 
         g = [[] for _ in range(n)]
-        for a, b in edges:
-            g[a].append(b)
-            g[b].append(a)
+        for u, v in edges:
+            g[u].append(v)
+            g[v].append(u)
         vis = set()
         return dfs(source)

solution/1900-1999/1971.Find if Path Exists in Graph/Solution.java

@@ -1,28 +1,32 @@
 impl Solution {
     pub fn valid_path(n: i32, edges: Vec<Vec<i32>>, source: i32, destination: i32) -> bool {
-        let mut disjoint_set: Vec<i32> = vec![0; n as usize];
-        // Initialize the set
-        for i in 0..n {
-            disjoint_set[i as usize] = i;
-        }
-
-        // Traverse the edges
-        for p_vec in &edges {
-            let parent_one = Solution::find(p_vec[0], &mut disjoint_set);
-            let parent_two = Solution::find(p_vec[1], &mut disjoint_set);
-            disjoint_set[parent_one as usize] = parent_two;
-        }
+        let n = n as usize;
+        let source = source as usize;
+        let destination = destination as usize;
 
-        let p_s = Solution::find(source, &mut disjoint_set);
-        let p_d = Solution::find(destination, &mut disjoint_set);
+        let mut g = vec![Vec::new(); n];
+        let mut vis = vec![false; n];
 
-        p_s == p_d
-    }
+        for e in edges {
+            let u = e[0] as usize;
+            let v = e[1] as usize;
+            g[u].push(v);
+            g[v].push(u);
+        }
 
-    pub fn find(x: i32, d_set: &mut Vec<i32>) -> i32 {
-        if d_set[x as usize] != x {
-            d_set[x as usize] = Solution::find(d_set[x as usize], d_set);
+        fn dfs(g: &Vec<Vec<usize>>, vis: &mut Vec<bool>, i: usize, destination: usize) -> bool {
+            if i == destination {
+                return true;
+            }
+            vis[i] = true;
+            for &j in &g[i] {
+                if !vis[j] && dfs(g, vis, j, destination) {
+                    return true;
+                }
+            }
+            false
         }
-        d_set[x as usize]
+
+        dfs(&g, &mut vis, source, destination)
     }
 }

solution/1900-1999/1971.Find if Path Exists in Graph/Solution.py

@@ -1,10 +1,9 @@
 function validPath(n: number, edges: number[][], source: number, destination: number): boolean {
     const g: number[][] = Array.from({ length: n }, () => []);
-    for (const [a, b] of edges) {
-        g[a].push(b);
-        g[b].push(a);
+    for (const [u, v] of edges) {
+        g[u].push(v);
+        g[v].push(u);
     }
-
     const vis = new Set<number>();
     const dfs = (i: number) => {
         if (i === destination) {
@@ -13,10 +12,8 @@ function validPath(n: number, edges: number[][], source: number, destination: nu
         if (vis.has(i)) {
             return false;
         }
-
         vis.add(i);
         return g[i].some(dfs);
     };
-
     return dfs(source);
 }

solution/1900-1999/1971.Find if Path Exists in Graph/Solution.rs

@@ -2,10 +2,10 @@ class Solution {
 public:
     bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
         vector<vector<int>> g(n);
-        for (auto& e : edges) {
-            int a = e[0], b = e[1];
-            g[a].push_back(b);
-            g[b].push_back(a);
+        for (const auto& e : edges) {
+            int u = e[0], v = e[1];
+            g[u].push_back(v);
+            g[v].push_back(u);
         }
         queue<int> q{{source}};
         vector<bool> vis(n);

solution/1900-1999/1971.Find if Path Exists in Graph/Solution.ts

@@ -1,9 +1,9 @@
 func validPath(n int, edges [][]int, source int, destination int) bool {
 	g := make([][]int, n)
 	for _, e := range edges {
-		a, b := e[0], e[1]
-		g[a] = append(g[a], b)
-		g[b] = append(g[b], a)
+		u, v := e[0], e[1]
+		g[u] = append(g[u], v)
+		g[v] = append(g[v], u)
 	}
 	q := []int{source}
 	vis := make([]bool, n)