Path Existence in an Undirected Graph

You are given an undirected graph with n vertices numbered from 0 to n - 1. The array edges contains one unordered pair [u, v] for each edge between vertices u and v.
Return true if a path connects source to destination. Otherwise, return false.
A vertex always has a path to itself, including an isolated vertex.

Function
validPath(n: int, edges: int[][], source: int, destination: int) → boolean

Examples
Example 1
n = 3
edges = [[0,1],[1,2],[2,0]]
source = 0
destination = 2
return = true
The edge between 0 and 2 directly connects the two vertices.
Example 2
n = 6
edges = [[0,1],[0,2],[3,5],[5,4],[4,3]]
source = 0
destination = 5
return = false
Vertices 0 and 5 belong to different connected components.
Example 3
n = 1
edges = []
source = 0
destination = 0
return = true
The source and destination are the same isolated vertex.

Constraints
1 <= n <= 200000.
0 <= edges.length <= 200000.
Every edge contains two valid vertex numbers.
0 <= source, destination < n.
The graph may contain cycles, disconnected components, and repeated edges.

The trick is connectivity, not path finding. You don't need the path, only whether source and destination share a component. Two clean options: build an adjacency list and run BFS or DFS with a visited set, or use union-find over the edges and compare roots. Pitfalls are concrete. First, forgetting visited marks makes cycles like [[0,1],[1,2],[2,0]] loop forever. Second, recursive DFS can blow the stack at 200000 nodes, so go iterative or use BFS. Third, handle source == destination up front, since an isolated vertex with no edges must return true. Fourth, repeated edges are harmless with a visited set but bloat the lists, so don't dedupe by hand. Both approaches run in roughly O(n + E). If the live OA freezes you, StealthCoder is the hedge that reads the problem and gives you the iterative version.

StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.