Choose a Shortest Path That Avoids Bob

Alice and Bob move simultaneously along one edge per second in an undirected, unweighted graph. Alice must choose a shortest path from her start to the destination. Bob may choose any walk to catch her.
Return whether Alice can choose a shortest path such that Bob cannot occupy the same node at the same or an earlier time at any step, including the destination. Bob's earliest arrival time therefore determines safety.

Function
canAliceReachSafely(n: int, edges: int[][], aliceStart: int, bobStart: int, destination: int) → boolean

Examples
Example 1
n = 5
edges = [[0,1],[1,4],[0,2],[2,3],[3,4]]
aliceStart = 0
bobStart = 3
destination = 4
return = false
Alice takes 0-1-4; Bob reaches the destination too late.
Example 2
n = 4
edges = [[0,1],[1,3],[2,1]]
aliceStart = 0
bobStart = 2
destination = 3
return = false
Bob reaches the shared middle node before Alice.
Example 3
n = 3
edges = [[0,1],[1,2]]
aliceStart = 0
bobStart = 0
destination = 2
return = false
Bob starts on Alice, so capture is immediate.

Constraints
1 <= n <= 100000.
0 <= edges.length <= 200000.

Run BFS from Alice's start to get distA, and BFS from Bob's start to get distB. Alice's shortest paths only use edges where distA increases by exactly 1 toward the destination. A node v on such a path is safe only if distA[v] < distB[v], since Bob arriving at the same time or earlier counts as capture. So restrict to nodes on shortest paths (distA[u] + distToDest[u] == distA[dest]) and check that a chain of safe nodes connects start to destination. A simple way: BFS or DP over the shortest-path DAG, only stepping into nodes where distA < distB. The pitfall is using less-than-or-equal instead of strict less-than, which flips example 3. Also handle unreachable destinations and watch recursion depth at n = 100000. If you freeze live, StealthCoder is the hedge, but the two-BFS idea is the whole trick.

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