Shortest Path Node Count Avoiding Broken Nodes

You are given a directed graph as an adjacency list, a list of broken node indices, a start node, and a destination node. Return the minimum number of nodes on a directed path from start to destination that never visits a broken node. Count both endpoints.
Return -1 when no valid path exists. If start equals destination and that node is not broken, return 1. If either endpoint is broken, return -1.

Function
minimumPathNodeCount(graph: int[][], broken: int[], start: int, destination: int) → int

Examples
Example 1
graph = [[1,2],[3],[4],[4],[]]
broken = [1]
start = 0
destination = 4
return = 3
The shorter route uses broken node 1, so the valid path is 0 to 2 to 4 and contains three nodes.
Example 2
graph = [[1],[],[3],[]]
broken = []
start = 0
destination = 3
return = -1
The destination is unreachable in the directed graph.

Constraints
1 <= graph.length <= 200000
Every neighbor is a valid node index; the total edge count is at most 300000.
broken contains unique valid node indices.
0 <= start, destination < graph.length

Put the broken indices into a boolean array or a set. Check the endpoints first: if start or destination is broken, return -1. If start equals destination and it's fine, return 1. Then run BFS from start with a queue, tracking distance as node count, so start begins at 1. Mark nodes visited when you push them, not when you pop them. Skip any neighbor that's broken or already seen. Return the count the moment you pop or push the destination. If the queue empties, return -1. The common pitfall is counting edges instead of nodes, which is off by one. Another is using DFS, which doesn't give the shortest path. With up to 200000 nodes and 300000 edges, you need O(V+E), and a list-based queue with pop(0) will be too slow. Use a deque or an index pointer. StealthCoder is the safety net if the edge cases slip your mind live.

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