Amount of Time for Binary Tree to Be Infected

Amount of Time for Binary Tree to Be Infected - Problem

Imagine a viral infection spreading through a binary tree! You are given the root of a binary tree where each node has a unique value, and an integer start representing the initial infection point.

At minute 0, the infection begins at the node with value start. Each subsequent minute, the infection spreads to all adjacent uninfected nodes. In a binary tree, adjacent nodes are:

Parent and child nodes
Child and parent nodes

Your task is to determine the total number of minutes needed for the infection to spread to every single node in the tree.

Goal: Return the minimum time required for complete tree infection.

Input & Output

example_1.py — Basic Tree Infection

$ Input: root = [1,5,3,null,4,10,6,9,2], start = 3

› Output: 4

💡 Note: Starting from node 3, infection spreads: Minute 0: {3}, Minute 1: {1,10,6}, Minute 2: {5,2}, Minute 3: {4}, Minute 4: {9}. Total time: 4 minutes.

example_2.py — Simple Chain

$ Input: root = [1], start = 1

› Output: 0

💡 Note: Single node tree - infection starts and completes immediately at minute 0.

example_3.py — Linear Tree

$ Input: root = [1,2,null,3,null,4,null], start = 3

› Output: 2

💡 Note: Linear tree: 1→2→3→4. Starting from 3, it takes 2 minutes to reach nodes 1 and 4 (the furthest nodes).

Visualization

Tap to expand

Understanding the Visualization

Initial State

Infection starts at the specified start node (minute 0)

First Spread

Infection spreads to all directly connected nodes (minute 1)

Continued Spread

Each minute, infection spreads to next level of uninfected neighbors

Complete Infection

All nodes infected - return total minutes elapsed

Key Takeaway

🎯 Key Insight: The problem is essentially finding the longest path from the start node in an undirected version of the tree. Converting the tree to a graph or using clever DFS allows us to handle bidirectional infection spread efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single DFS traversal visits each node exactly once

✓ Linear Growth

Space Complexity

O(h)

Recursion stack space proportional to tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁵
Each node has a unique value
A node with value start exists in the tree

Asked in

f Meta 45 a Amazon 38 G Google 32 ⊞ Microsoft 28

The optimal solution uses a single DFS traversal to find the infection start point and calculate the maximum spread time. By treating the tree as an undirected graph during traversal, we can efficiently compute distances in all directions from the start node in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (DFS from Every Node)	O(n²)	O(h)	Calculate distance from start to every node using repeated DFS traversals
Graph Conversion + BFS	O(n)	O(n)	Convert tree to undirected graph, then use BFS to find maximum distance
DFS with Distance Tracking (Optimal)	O(n)	O(h)	Single DFS pass to find start node and calculate maximum infection time

Brute Force (DFS from Every Node) — Algorithm Steps

Find the start node in the tree using DFS
For each node in the tree, calculate its distance from the start node
Use DFS with parent tracking to handle bidirectional movement
Return the maximum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Start Node

Locate the infection starting point in the tree

Calculate All Distances

For each node, compute distance from start using DFS

Track Maximum

Keep track of the maximum distance found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

int findDistanceFromSource(struct TreeNode* node, int target, struct TreeNode* parent) {
    if (!node) return -1;
    if (node->val == target) return 0;
    
    int leftDist = findDistanceFromSource(node->left, target, node);
    if (leftDist != -1) return leftDist + 1;
    
    int rightDist = findDistanceFromSource(node->right, target, node);
    if (rightDist != -1) return rightDist + 1;
    
    if (parent) {
        int parentDist = findDistanceFromSource(parent, target, node);
        if (parentDist != -1) return parentDist + 1;
    }
    
    return -1;
}

int findDistance(struct TreeNode* node, int source, int target, struct TreeNode* parent) {
    if (!node) return -1;
    if (node->val == source) {
        return findDistanceFromSource(node, target, parent);
    }
    
    int leftDist = findDistance(node->left, source, target, node);
    if (leftDist != -1) return leftDist;
    
    int rightDist = findDistance(node->right, source, target, node);
    if (rightDist != -1) return rightDist;
    
    return -1;
}

void getAllNodes(struct TreeNode* node, int* nodes, int* count) {
    if (!node) return;
    nodes[(*count)++] = node->val;
    getAllNodes(node->left, nodes, count);
    getAllNodes(node->right, nodes, count);
}

int amountOfTime(struct TreeNode* root, int start) {
    int nodes[100000];
    int count = 0;
    getAllNodes(root, nodes, &count);
    
    int maxTime = 0;
    for (int i = 0; i < count; i++) {
        int dist = findDistance(root, start, nodes[i], NULL);
        if (dist > maxTime) {
            maxTime = dist;
        }
    }
    
    return maxTime;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n nodes, we potentially traverse the entire tree to calculate distance

⚠ Quadratic Growth

Space Complexity

O(h)

Recursion stack depth is limited to tree height h

✓ Linear Space

Constraints

The number of nodes in the tree is in the range [1, 10⁵]
1 ≤ Node.val ≤ 10⁵
Each node has a unique value
A node with value start exists in the tree

52.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (DFS from Every Node) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler