题目简介：

这个问题描述了一个情景：给定一棵二叉树和一个起始节点值，起始节点被感染后，感染将从该节点开始向其相邻节点传播。每分钟，如果一个节点此前还没有感染，并且它与一个已感染节点相邻，那么它将被感染。问感染整棵树需要的分钟数。
示例 1：

输入：root = [1,5,3,null,4,10,6,9,2], start = 3
输出：4
解释：节点按以下过程被感染：

• 第 0 分钟：节点 3
• 第 1 分钟：节点 1、10、6
• 第 2 分钟：节点5
• 第 3 分钟：节点 4
• 第 4 分钟：节点 9 和 2
  感染整棵树需要 4 分钟，所以返回 4 。
  示例 2：
  
  输入：root = [1], start = 1
  输出：0
  解释：第 0 分钟，树中唯一一个节点处于感染状态，返回 0 。

解题思路：

首先，我们需要找到起始节点，并建立节点与其父节点的映射关系。然后，我们使用广度优先搜索（BFS）来模拟感染过程。从起始节点开始，每分钟检查已感染节点的相邻节点是否满足感染条件，如果满足条件，则将其感染，并将其加入队列中。重复这个过程，直到所有节点都被感染为止。

算法步骤：

1. 找到起始节点，并建立节点与其父节点的映射关系。
2. 使用BFS进行感染过程的模拟：
   • 将起始节点加入感染集合中。
   • 每分钟检查已感染节点的相邻节点是否满足感染条件，如果满足，则将其感染，并将其加入队列中。
   • 持续重复这个过程，直到所有节点都被感染为止。

代码实现：

import java.util.*;

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

class Solution {
    public int amountOfTime(TreeNode root, int start) {
        // 建立节点与父节点的映射关系
        Map<TreeNode, TreeNode> parentMap = new HashMap<>();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode startNode = null;
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.val == start) {
                startNode = node;
            }
            if (node.left != null) {
                parentMap.put(node.left, node);
                queue.offer(node.left);
            }
            if (node.right != null) {
                parentMap.put(node.right, node);
                queue.offer(node.right);
            }
        }

        // 使用BFS进行感染过程的模拟
        Set<TreeNode> infected = new HashSet<>();
        queue.clear();
        queue.offer(findNode(startNode, start, infected, parentMap)); // 将起始节点加入感染集合中
        infected.add(findNode(startNode, start, infected, parentMap));
        int minutes = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                // 检查当前节点的邻居是否未感染，并进行感染
                if (node.left != null && !infected.contains(node.left)) {
                    infected.add(node.left);
                    queue.offer(findNode(node.left, node.left.val, infected, parentMap));
                }
                if (node.right != null && !infected.contains(node.right)) {
                    infected.add(node.right);
                    queue.offer(findNode(node.right, node.right.val, infected, parentMap));
                }
                TreeNode parent = parentMap.get(node);
                if (parent != null && !infected.contains(parent)) {
                    infected.add(parent);
                    queue.offer(findNode(parent, parent.val, infected, parentMap));
                }
            }
            if (!queue.isEmpty()) {
                minutes++;
            }
        }

        return minutes;
    }

    // 辅助函数，根据值查找节点
    private TreeNode findNode(TreeNode root, int target, Set<TreeNode> visited, Map<TreeNode, TreeNode> parentMap) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.val == target) {
                return node;
            }
            visited.add(node);
            if (node.left != null && !visited.contains(node.left)) {
                queue.offer(node.left);
            }
            if (node.right != null && !visited.contains(node.right)) {
                queue.offer(node.right);
            }
            TreeNode parent = parentMap.get(node);
            if (parent != null && !visited.contains(parent)) {
                queue.offer(parent);
            }
        }
        return null;
    }
}

复杂度分析：

• 时间复杂度：该算法在最坏情况下需要遍历整棵树，因此时间复杂度为 O(n)，其中 n 是二叉树的节点数。
• 空间复杂度：使用了辅助数据结构来存储节点之间的关系和感染状态，因此空间复杂度取决于节点数量和树的高度，为 O(n)。