Distances to the Nearest Infected Node

You are given an undirected, unweighted graph with n nodes numbered from 0 to n - 1. The array infected contains the distinct nodes that are already infected.
Return an integer array distance of length n, where distance[v] is the minimum number of edges on a path from node v to any infected node. Return -1 for a node that cannot reach any infected node.

Function
nearestInfectedDistances(n: int, edges: int[][], infected: int[]) → int[]

Examples
Example 1
n = 7
edges = [[0,1],[1,2],[2,3],[4,5]]
infected = [0,3,5]
return = [0,1,1,0,1,0,-1]
Nodes 0, 3, and 5 start at distance 0. Nodes 1, 2, and 4 are one edge from an infected node. Node 6 is isolated, so its distance is -1.
Example 2
n = 5
edges = [[0,1],[1,2],[2,3],[3,4]]
infected = [1,4]
return = [1,0,1,1,0]
A shortest path may end at either infected source. Node 3, for example, is one edge from node 4.

Constraints
1 <= n <= 200000
0 <= edges.length <= 200000
Every row of edges is [u, v] with 0 <= u, v < n and u != v.
1 <= infected.length <= n
All entries of infected are distinct valid node indices.

The trick: don't compute distance per node. Build an adjacency list, create a distance array filled with -1, and push every infected node into the queue with distance 0 at the start. Then run a normal BFS. The first time a node gets reached is its shortest distance, because BFS expands in layers. Nodes never reached keep -1, which handles the isolated node in Example 1 for free. The common pitfall is running BFS from each node, which is O(n * (n + m)) and dies on the constraints. Another is using a visited set separate from the distance array, which is fine but redundant. Also remember edges are undirected, so add both directions. Use an index pointer or deque so pops are O(1). Total cost is O(n + m). StealthCoder is your hedge if the multi-source framing escapes you during the live OA.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.