DP on Trees Diameter of Tree in DSA Python - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the diameter of a tree?

The diameter of a tree is the longest path between any two nodes in the tree. This path may or may not pass through the root.

intermediate

Why do we use dynamic programming (DP) on trees to find the diameter?

DP on trees helps us efficiently compute values like the longest path from each node by storing intermediate results, avoiding repeated calculations and reducing time complexity.

beginner

In the DP approach for tree diameter, what does the 'height' of a node represent?

The height of a node is the length of the longest path from that node down to any leaf node in its subtree.

intermediate

How do you update the diameter while doing a DFS traversal in the DP approach?

At each node, consider the two longest heights among its children. The sum of these two heights plus 2 (edges connecting them through the node) can update the diameter if it is larger than the current maximum.

beginner

What is the time complexity of finding the diameter of a tree using DP and DFS?

The time complexity is O(N), where N is the number of nodes, because each node and edge is visited once during the DFS traversal.

What does the diameter of a tree represent?

A Height of the root node

B Number of nodes in the tree

C Longest path between any two nodes

D Number of leaves in the tree

The diameter is the longest path between any two nodes in the tree.

In DP on trees, what is the 'height' of a node?

A Longest path from the node to a leaf

B Number of edges in the tree

C Distance from the root

D Number of children of the node

Height is the longest path from the node down to any leaf node.

How do you update the diameter during DFS?

A Maximum child height only

B Sum of the two longest child heights plus 2

C Number of children

D Height of the root node

At each node, the diameter can be updated by summing the two longest heights from its children plus 2 edges connecting them.

What is the time complexity of the DP approach to find tree diameter?

A O(N^2)

B O(N log N)

C O(log N)

D O(N)

Each node and edge is visited once, so the time complexity is linear, O(N).

Does the diameter path always pass through the root node?

A No, not necessarily

B Yes, always

C Only if the tree is balanced

D Only if the tree is a binary tree

The diameter path can be anywhere in the tree and does not have to pass through the root.

Explain how dynamic programming helps in finding the diameter of a tree.

Think about how you can use results from child nodes to build the answer for the parent.

Describe the steps to compute the diameter of a tree using DFS and DP.

Focus on what you calculate at each node and how you use it to update the diameter.

Practice

1. What is the diameter of a tree in terms of its nodes?

easy

A. The total number of nodes in the tree

B. The number of leaf nodes in the tree

C. The longest path between any two nodes in the tree

D. The height of the tree from the root node

Solution

1. Step 1: Understand the definition of tree diameter

   The diameter is the longest path between any two nodes, not just from the root or leaf count.

2. Step 2: Compare options with definition

   Only The longest path between any two nodes in the tree correctly describes the longest path between any two nodes.

3. Final Answer:

   The longest path between any two nodes in the tree -> Option C

4. Quick Check:

   Diameter = longest path [OK]

Hint: Diameter = longest path between any two nodes [OK]

Common Mistakes:

• Confusing diameter with tree height
• Thinking diameter is number of leaves
• Assuming diameter is total nodes count

2. Which of the following is the correct Python syntax to declare a recursive function to find the diameter of a tree?

easy

A. def diameter(node):

B. function diameter(node) {

C. def diameter[node]:

D. diameter = lambda node:

Solution

1. Step 1: Identify correct Python function syntax

   Python functions use 'def' keyword followed by function name and parentheses with parameters.

2. Step 2: Check each option

   def diameter(node): uses correct Python syntax. function diameter(node) { is JavaScript style. def diameter[node]: uses wrong brackets. diameter = lambda node: is incomplete lambda syntax.

3. Final Answer:

   def diameter(node): -> Option A

4. Quick Check:

   Python function syntax = def name(params): [OK]

Hint: Python functions start with def and parentheses [OK]

Common Mistakes:

• Using curly braces instead of colon
• Using square brackets for parameters
• Incorrect lambda syntax for recursion

3. Given the following tree edges and code snippet, what is the diameter of the tree?

edges = [(1,2), (2,3), (2,4), (4,5)]

# Code snippet
from collections import defaultdict

tree = defaultdict(list)
for u,v in edges:
    tree[u].append(v)
    tree[v].append(u)

max_diameter = 0
def dfs(node, parent):
    global max_diameter
    max1 = max2 = 0
    for child in tree[node]:
        if child == parent:
            continue
        depth = dfs(child, node)
        if depth > max1:
            max2 = max1
            max1 = depth
        elif depth > max2:
            max2 = depth
    max_diameter = max(max_diameter, max1 + max2)
    return max1 + 1

dfs(1, -1)
print(max_diameter)

medium

A. 3

B. 4

C. 5

D. 2

Solution

1. Step 1: Build the tree and understand structure

   The tree edges form: 1-2-3, 2-4-5. The longest path is from node 3 to node 5 via 2 and 4.

2. Step 2: Calculate longest path length

   Path 3->2->4->5 has 3 edges, so diameter is 3 edges = 4 nodes in path length. The code counts edges, so max_diameter = 3 edges.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   Longest path edges = 3 [OK]

Hint: Diameter = max sum of two largest depths at any node [OK]

Common Mistakes:

• Counting nodes instead of edges for diameter
• Ignoring parent check in DFS
• Mixing up max1 and max2 updates

4. The following code attempts to find the diameter of a tree but produces incorrect output. What is the bug?

def dfs(node, parent):
    max_depth = 0
    for child in tree[node]:
        if child != parent:
            depth = dfs(child, node)
            if depth > max_depth:
                max_depth = depth
    return max_depth + 1

max_diameter = 0
def find_diameter(node, parent):
    global max_diameter
    depths = []
    for child in tree[node]:
        if child != parent:
            depths.append(dfs(child, node))
    if len(depths) >= 2:
        depths.sort(reverse=True)
        max_diameter = max(max_diameter, depths[0] + depths[1])
    for child in tree[node]:
        if child != parent:
            find_diameter(child, node)

find_diameter(1, -1)
print(max_diameter)

medium

A. The recursive call to find_diameter is missing

B. max_diameter is not updated globally

C. Sorting depths in descending order is incorrect

D. Only updates max_diameter when len(depths) >= 2, missing updates for nodes with fewer than 2 children

Solution

1. Step 1: Identify the conditional update bug

   The code only updates max_diameter if len(depths) >= 2, but to mimic standard algorithm, it should always update using the two largest depths (with second as 0 if fewer children).

2. Step 2: Understand impact on chain trees

   In chain trees, nodes often have at most 1 child (excluding parent), so the condition skips updates, leaving max_diameter = 0 incorrectly.

3. Final Answer:

   Only updates max_diameter when len(depths) >= 2, missing updates for nodes with fewer than 2 children -> Option D

4. Quick Check:

   Pad missing depths with 0 for diameter update [OK]

Hint: Always update diameter with top two downward depths (pad 0 if needed) [OK]

Common Mistakes:

• Not updating global max_diameter
• Incorrect sorting order of depths
• Missing recursive calls in diameter function

5. You want to find the diameter of a weighted tree where edges have different lengths. Which modification to the standard DP on trees diameter algorithm is correct? A weighted tree is represented as adjacency list with tuples (neighbor, weight).

tree = {
  1: [(2, 3), (3, 2)],
  2: [(1, 3), (4, 4)],
  3: [(1, 2)],
  4: [(2, 4)]
}

# Which code snippet correctly computes diameter?

hard

A. Use BFS twice ignoring weights to find diameter

B. Use dfs to return max weighted depth, update diameter by sum of top two weighted depths

C. Ignore weights and count edges only for diameter

D. Sum all weights in the tree and divide by 2

Solution

1. Step 1: Understand weighted tree diameter

   Diameter is longest weighted path, so weights must be included in depth calculations.

2. Step 2: Modify DFS to return max weighted depth and update diameter

   DFS returns max weighted depth from node; diameter updated by sum of two largest weighted depths.

3. Final Answer:

   Use dfs to return max weighted depth, update diameter by sum of top two weighted depths -> Option B

4. Quick Check:

   Weighted diameter = sum of max weighted depths [OK]

Hint: Include edge weights in depth sums for weighted diameter [OK]

Common Mistakes:

• Ignoring weights and treating as unweighted
• Using BFS without weights for weighted diameter
• Summing all weights instead of longest path