Added Leetcode 1971

Author: gahogg

Find if Path Exists in Graph - Leetcode 1971/Find if Path Exists in Graph - Leetcode 1971.cpp

@@ -0,0 +1,36 @@
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+
+using namespace std;
+
+class Solution {
+public:
+    bool validPath(int n, vector<vector<int>>& edges, int source, int destination) {
+        if (source == destination) return true;
+
+        unordered_map<int, vector<int>> graph;
+        for (const auto& edge : edges) {
+            graph[edge[0]].push_back(edge[1]);
+            graph[edge[1]].push_back(edge[0]);
+        }
+
+        unordered_set<int> seen;
+        seen.insert(source);
+
+        return dfs(source, destination, graph, seen);
+    }
+
+private:
+    bool dfs(int node, int destination, unordered_map<int, vector<int>>& graph, unordered_set<int>& seen) {
+        if (node == destination) return true;
+
+        for (int neighbor : graph[node]) {
+            if (seen.find(neighbor) == seen.end()) {
+                seen.insert(neighbor);
+                if (dfs(neighbor, destination, graph, seen)) return true;
+            }
+        }
+        return false;
+    }
+};

Find if Path Exists in Graph - Leetcode 1971/Find if Path Exists in Graph - Leetcode 1971.java

@@ -0,0 +1,32 @@
+// Recurisve DFS
+
+import java.util.*;
+
+public class Solution {
+    public boolean validPath(int n, int[][] edges, int source, int destination) {
+        if (source == destination) return true;
+
+        Map<Integer, List<Integer>> graph = new HashMap<>();
+        for (int[] edge : edges) {
+            graph.computeIfAbsent(edge[0], k -> new ArrayList<>()).add(edge[1]);
+            graph.computeIfAbsent(edge[1], k -> new ArrayList<>()).add(edge[0]);
+        }
+
+        Set<Integer> seen = new HashSet<>();
+        seen.add(source);
+
+        return dfs(source, destination, graph, seen);
+    }
+
+    private boolean dfs(int node, int destination, Map<Integer, List<Integer>> graph, Set<Integer> seen) {
+        if (node == destination) return true;
+
+        for (int neighbor : graph.getOrDefault(node, Collections.emptyList())) {
+            if (!seen.contains(neighbor)) {
+                seen.add(neighbor);
+                if (dfs(neighbor, destination, graph, seen)) return true;
+            }
+        }
+        return false;
+    }
+}

Find if Path Exists in Graph - Leetcode 1971/Find if Path Exists in Graph - Leetcode 1971.js

@@ -0,0 +1,29 @@
+var validPath = function(n, edges, source, destination) {
+    if (source === destination) return true;
+
+    const graph = new Map();
+    for (const [u, v] of edges) {
+        if (!graph.has(u)) graph.set(u, []);
+        if (!graph.has(v)) graph.set(v, []);
+        graph.get(u).push(v);
+        graph.get(v).push(u);
+    }
+
+    const seen = new Set();
+    seen.add(source);
+
+    const dfs = (node) => {
+        if (node === destination) return true;
+
+        for (const neighbor of graph.get(node) || []) {
+            if (!seen.has(neighbor)) {
+                seen.add(neighbor);
+                if (dfs(neighbor)) return true;
+            }
+        }
+        return false;
+    };
+
+    return dfs(source);
+}
+

Find if Path Exists in Graph - Leetcode 1971/Find if Path Exists in Graph - Leetcode 1971.py

@@ -0,0 +1,84 @@
+# Recursive DFS
+class Solution:
+    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
+        if source == destination:
+            return True
+        
+        graph = defaultdict(list)
+        for u, v in edges:
+            graph[u].append(v)
+            graph[v].append(u)
+        
+        seen = set()
+        seen.add(source)
+
+        def dfs(i):
+            if i == destination:
+                return True
+            
+            for nei_node in graph[i]:
+                if nei_node not in seen:
+                    seen.add(nei_node)
+                    if dfs(nei_node):
+                        return True
+            
+            return False
+        
+        return dfs(source)
+
+
+# Iterative DFS with Stack
+class Solution:
+    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
+        if source == destination:
+            return True
+        
+        graph = defaultdict(list)
+        for u, v in edges:
+            graph[u].append(v)
+            graph[v].append(u)
+        
+        seen = set()
+        seen.add(source)
+        stack = [source]
+
+        while stack:
+            node = stack.pop()
+            if node == destination:
+                return True
+            for nei_node in graph[node]:
+                if nei_node not in seen:
+                    seen.add(nei_node)
+                    stack.append(nei_node)
+        
+        return False
+
+
+
+# BFS With Queue
+from collections import deque
+class Solution:
+    def validPath(self, n: int, edges: List[List[int]], source: int, destination: int) -> bool:
+        if source == destination:
+            return True
+        
+        graph = defaultdict(list)
+        for u, v in edges:
+            graph[u].append(v)
+            graph[v].append(u)
+        
+        seen = set()
+        seen.add(source)
+        q = deque()
+        q.append(source)
+
+        while q:
+            node = q.popleft()
+            if node == destination:
+                return True
+            for nei_node in graph[node]:
+                if nei_node not in seen:
+                    seen.add(nei_node)
+                    q.append(nei_node)
+        
+        return False # Time: O(N + E), Space: O(N + E)