Burn the binary tree starting from the target node

Taking into account a binary tree and a target node. The fire starts to spread throughout the entire tree when it is supplied to the target node. The goal at hand is to print the burning node sequence of the binary tree.

Guidelines for burning the nodes:

Fire will only ever spread to the nodes that are connected.
Each node burns at the same rate.
A node only ever burns once.

Burn the binary tree starting from the target node

Example

Input :

                       12
                     /     \
                   13      10
                   /         \
                 14           15
                / \          /  \
              21   24      22    23
target node = 14

Output:

Explanation: Node 14 burns first, then nodes 21, 24, 10, and so on catch fire from it. Until the tree completely burns, this process is repeated.

Approach 1

First, in a binary tree, perform a recursive search on the target node. Once the target node has been located, print it and place its left and right children (if any) in a queue. then come back. Obtain the queue's size now, and execute the while loop. Print the queued components.

Below is the implementation of the approach

# Python3 implementation to print the sequence
# of the burning of nodes of a binary tree
class Node:
    def __init__(self, key):
        self.key = key
        self.left = None
        self.right = None

def new_node(key):
    return Node(key)

def burn_tree_util(root, target, q):
    # Base condition
    if root is None:
        return 0

    # Condition to check whether target
    # node is found or not in a tree
    if root.key == target:
        print(root.key)
        if root.left is not None:
            q.append(root.left)
        if root.right is not None:
            q.append(root.right)

        # Return statements to prevent
        # further function calls
        return 1

    a = burn_tree_util(root.left, target, q)

    if a == 1:
        q_size = len(q)

        # Run while loop until size of queue
        # becomes zero
        while q_size:
            temp = q[0]

            # Printing of burning nodes
            print(temp.key, end=", ")
            del q[0]

            # Check if condition for left subtree
            if temp.left is not None:
                q.append(temp.left)

            # Check if condition for right subtree
            if temp.right is not None:
                q.append(temp.right)

            q_size -= 1

        if root.right is not None:
            q.append(root.right)

        print(root.key)

        # Return statement it prevents further
        # further function call
        return 1

    b = burn_tree_util(root.right, target, q)

    if b == 1:
        q_size = len(q)
        # Run while loop until size of queue
        # becomes zero

        while q_size:
            temp = q[0]

            # Printing of burning nodes
            print(temp.key, end=", ")
            del q[0]

            # Check if condition for left subtree
            if temp.left is not None:
                q.append(temp.left)

            # Check if condition for left subtree
            if temp.right is not None:
                q.append(temp.right)

            q_size -= 1

        if root.left is not None:
            q.append(root.left)

        print(root.key)

        # Return statement it prevents further
        # further function call
        return 1

# Function will print the sequence of burning nodes
def burn_tree(root, target):
    q = []

    # Function call
    burn_tree_util(root, target, q)

    # While loop runs unless queue becomes empty
    while q:
        q_size = len(q)
        while q_size:
            temp = q[0]

            # Printing of burning nodes
            print(temp.key, end="")
            # Insert left child in a queue, if exist
            if temp.left is not None:
                q.append(temp.left)
            # Insert right child in a queue, if exist
            if temp.right is not None:
                q.append(temp.right)

            if len(q) != 1:
                print(", ", end="")

            del q[0]
            q_size -= 1
        print()

# Driver Code
if __name__ == "__main__":
    """
        10
       / \
      12  13
         / \
        14  15
       / \ / \
      21 22 23 24
    """
    root = new_node(10)
    root.left = new_node(12)
    root.right = new_node(13)
    root.right.left = new_node(14)
    root.right.right = new_node(15)
    root.right.left.left = new_node(21)
    root.right.left.right = new_node(22)
    root.right.right.left = new_node(23)
    root.right.right.right = new_node(24)

    burn_tree(root, 14)

Output:

Time Complexity:

O(n), Since there are n nodes in the binary tree, the temporal complexity of the suggested method is O(n). Because each node is only accessed once in the worst scenario, this is the case. Every node, which has n nodes in total, is processed once by the while loop of the burn_tree_util function.

Space Complexity:

Even in the worst scenario, the space complexity is O(n). For the worst-case scenario, the queue (q), where n is the number of nodes at the last level of the binary tree, can only store n/2 nodes. The final level of a complete binary tree has about n/2 nodes. Consequently, the queue causes the space complexity to be O(n).

Approach 2

Transform the tree into an undirected graph, then display the level order traversal of that graph.

Use the parent-child relationship as the edges and Treenodes as the vertices to construct an undirected graph.
As the target, perform BFS using the source vertex.

#Python program for the above approach

from collections import defaultdict

# A Tree node
class TreeNode:
	def __init__(self, val=0, left=None, right=None):
		self.val = val
		self.left = left
		self.right = right

# Function to build the undirected graph
def build_map(node, parent, graph):
	if node is None:
		return
	if node not in graph:
		graph[node] = []
		if parent is not None:
			graph[node].append(parent)
			graph[parent].append(node)
		build_map(node.left, node, graph)
		build_map(node.right, node, graph)

# Function to burn the tree
def burn_tree(root, target):
	# Map to store the nodes of the tree
	graph = defaultdict(list)
	build_map(root, None, graph)
	if target not in graph:
		print("Target Not found")
		return
	visited = set()
	queue = []
	queue.append(target)
	visited.add(target)
	while queue:
		size = len(queue)
		for i in range(size):
			node = queue.pop(0)
			print(node.val, end = " ")
			for next in graph[node]:
				if next in visited:
					continue
				visited.add(next)
				queue.append(next)
		print()
#Driver code
root = TreeNode(12)
root.left = TreeNode(13)
root.right = TreeNode(10)
root.right.left = TreeNode(14)
root.right.right = TreeNode(15)
left = root.right.left
right = root.right.right
left.left = TreeNode(21)
left.right = TreeNode(24)
right.left = TreeNode(22)
right.right = TreeNode(23)

# target Node value is 14
burn_tree(root, left)
#This code is contributed by Potta Lokesh

Output:

Time Complexity: O(n) is the time complexity, where n is the binary tree's node count. To construct the map and carry out BFS traversal, we must traverse every node in the binary tree.

Space Complexity: O(n) is the space complexity, where n is the binary tree's node count. All of the nodes in the unordered map and the queue that is utilized for BFS traversal must be stored.

Approach 3

The aim is to traverse the tree in reverse order and return a measure of the current node's distance from the target node. To do this, we examine whether the target was located during each recursive iteration.

Follow the steps below to implement the above idea:

Finding the target node lets us know that for every child of the sub-tree rooted at this node, we must start at 1. Furthermore, we return 1, indicating that the target value was located.
The left and right subtree algorithms are then called recursively from the current node after condition 1 has been verified. Since the target node can only exist in the left or right subtree of the current node, only one of these recursive calls can, by definition, return 1.
The greatest value for the left subtree is handled in step 1, therefore if we receive 1 from the left subtree, it indicates that the target node is present in the left subtree.
At this point, we recursively run the procedure for the right subtree. On the other hand, we call the left subtree algorithm recursively if we receive 1 from the right subtree.
We keep an answer variable's maximum value at each stage of the process, and we return the result at the conclusion.

Below is the implementation of the code

from typing import List, Dict

# Define a Node class
class Node:
	def __init__(self, data):
		self.data = data
		self.left = None
		self.right = None

# Define a function to create a new Node
def newNode(key: int) -> Node:
	temp = Node(key)
	temp.left = temp.right = None
	return temp

# Define a recursive function to find minimum time required to burn the binary tree
def findMinTime(root: Node, target: int, level: int,
				ans: Dict[int, List[int]], consider: int) -> int:
	# Base case: If the node is None, return -1
	if root is None:
		return -1
	
	# If the current node is the target node or we need to consider it,
	# add it to the corresponding level of the answer dictionary
	if consider == 1:
		ans[level].append(root.data)

	# If the current node is the target node, start burning the left and right subtrees
	if root.data == target:
		ans[0].append(root.data)
		findMinTime(root.left, target, 1, ans, 1)
		findMinTime(root.right, target, 1, ans, 1)
		return 1
	
	# Recursively find the minimum time required to burn the left and right subtrees
	left = findMinTime(root.left, target, level + 1, ans, consider)
	right = findMinTime(root.right, target, level + 1, ans, consider)

	# If the left subtree is not burnt yet, burn it and add the current node to the answer dictionary
	if left != -1:
		ans[left].append(root.data)
		findMinTime(root.right, target, left + 1, ans, 1)
		return left + 1
	
	# If the right subtree is not burnt yet, burn it and add the current node to the answer dictionary
	if right != -1:
		ans[right].append(root.data)
		findMinTime(root.left, target, right + 1, ans, 1)
		return right + 1
	
	# If both subtrees are already burnt, return -1
	return -1

# Define a function to find the minimum time required to burn the binary tree
def minTime(root: Node, target: int) -> Dict[int, List[int]]:
	# Initialize an empty dictionary to store the answer
	ans = {i: [] for i in range(100)}
	# Call the recursive function to find the minimum time
	findMinTime(root, target, 0, ans, 0)
	# Return the answer dictionary
	return ans

# Driver code
if __name__ == '__main__':
	# Create the binary tree
	root = newNode(10)
	root.left = newNode(12)
	root.right = newNode(13)

	root.right.left = newNode(14)
	root.right.right = newNode(15)

	root.right.left.left = newNode(21)
	root.right.left.right = newNode(22)
	root.right.right.left = newNode(23)
	root.right.right.right = newNode(24)
	
	# Set the target node
	targetNode = 14

	# Call the function to find the minimum time required to burn the binary tree
	answer = minTime(root, targetNode)

	# Print the answer
	for key, value in answer.items():
		if not value:
			break
		print(f"Nodes burnt at stage {key} are {value}")

Output:

Time Complexity: O(n), Because the mentioned code only conducts a single tree traverse, its time complexity is O(n). Updating the unordered_map and making the recursive calls require constant time at each node. As a result, the temporal complexity of the tree is linear in the number of nodes.

Space Complexity: O(n), where n is the number of nodes in the tree, is the Auxiliary Space for the code shown above. This is a result of the code using an unordered_map, whose size grows linearly with the number of nodes in the tree, to store the nodes burned at each stage.

Next TopicCheck for possible paths in the 2D Matrix

← prev next →