• The number of nodes is in the range [1, 10⁵]
• 1 <= Node.val <= 10⁵, and all values are unique
• start is guaranteed to be the value of a node in the tree
• Infection spreads to parents as well as to children

Strip away the story and this is a question about distance. A node becomes infected at minute d exactly when its shortest path from the start node is d edges long — the infection advances one edge per minute in every direction at once, so nothing can arrive faster than the shortest path and nothing arrives later. The whole tree is infected when the furthest node falls, so the answer is:

answer = max over all nodes v of  distance(start, v)

Since edges are travelled in both directions, this is the same setting as All Nodes Distance K: the tree's pointers give only downward links, so the parent edges have to be reconstructed before any of this can be computed. Build a map from each node to its parent in one walk, and every node then has up to three neighbours.

Distance K expanded outward in rings and returned ring number k. Here we expand in exactly the same way and simply keep going until nothing is left, then report how many rings we completed. That count is the largest distance from the start to anything, which is the answer.

The only real difficulty is the off-by-one, so pin it down precisely. Ring 0 is the start node alone, and it is infected at minute 0 — no time has passed. Ring 1 is infected at minute 1. So the answer equals the index of the last non-empty ring, which is one less than the number of rings processed.

parent, start_node = {}, None
def map_parents(node, par):
    global start_node
    if node is None: return
    parent[node] = par
    if node.val == start: start_node = node    # locate the start while mapping
    map_parents(node.left, node)
    map_parents(node.right, node)
map_parents(root, None)

queue, seen, minutes = deque([start_node]), {start_node}, -1
while queue:
    minutes += 1                               # ring 0 costs 0 minutes
    for _ in range(len(queue)):                # frozen ring size
        node = queue.popleft()
        for nxt in (node.left, node.right, parent[node]):
            if nxt and nxt not in seen:
                seen.add(nxt)
                queue.append(nxt)
return minutes

The visited set carries the same weight as before. Once parent edges exist the structure is an undirected graph, so without it the infection would bounce back and forth across a single edge forever, and nodes would be counted at the wrong distances.

Notice that the infection travelled up through 1 and then down a completely different branch to reach 9 and 2. Measuring depth from the root would have given a different — and wrong — number.

Mapping parents visits every node once, and the search admits every node once, so the total is O(N) time and O(N) space for the map, the visited set and the queue. At the 10⁵-node limit the recursive parent mapping could go 10⁵ frames deep on a chain, so an iterative walk with an explicit stack — the technique from Iterative Traversals — is worth mentioning.

Step back and notice how little was new here. Once the parent edges exist, the tree is a graph, and this is the classic "how long does something spread through a network" question, answered by counting breadth-first layers. The same shape solves rotting oranges in a grid, minimum steps in a maze, and the spread of a rumour through a social graph. Build the neighbour relation the question implies, expand outward in layers, and read off either the layer you were asked about or the last one reached — and the tree becomes just one more graph.