DP on Trees Diameter of Tree in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of diameter calculation on a simple tree

What is the output of the following Python code that calculates the diameter of a tree represented as an adjacency list?

DSA Python

def tree_diameter(adj):
    n = len(adj)
    def dfs(node, parent):
        max1 = max2 = 0
        for nei in adj[node]:
            if nei == parent:
                continue
            length = dfs(nei, node) + 1
            if length > max1:
                max2 = max1
                max1 = length
            elif length > max2:
                max2 = length
        tree_diameter.max_diameter = max(tree_diameter.max_diameter, max1 + max2)
        return max1
    tree_diameter.max_diameter = 0
    dfs(0, -1)
    return tree_diameter.max_diameter

adjacency = [[1,2],[0,3,4],[0],[1],[1]]
print(tree_diameter(adjacency))

A 3

B 5

C 2

D 4

💡 Hint

Trace the longest path between any two nodes in the tree.

The longest path (diameter) in the tree is between node 3 and node 2 or node 4 and node 2, which has length 3 edges.

🧠 Conceptual

intermediate

Understanding the role of two longest paths in diameter calculation

In the DP approach to find the diameter of a tree, why do we keep track of the two longest paths from a node to its children?

A Because the diameter may pass through the current node combining two longest child paths

B Because the diameter is always the longest single path from the root to a leaf

C Because we need to find the shortest path between two leaves

D Because the two longest paths help in counting the total number of nodes

💡 Hint

Think about how the diameter can pass through a node connecting two subtrees.

The diameter can be the sum of the two longest downward paths from a node, passing through that node, so tracking both helps find the maximum diameter.

🔧 Debug

advanced

Identify the error in diameter calculation code

What error will the following code produce when calculating the diameter of a tree?

DSA Python

def diameter(adj):
    def dfs(u, p):
        max_len = 0
        for v in adj[u]:
            if v == p:
                continue
            length = dfs(v, u) + 1
            max_len = max(max_len, length)
        diameter.max_d = max(diameter.max_d, max_len)
        return max_len
    diameter.max_d = 0
    dfs(0, -1)
    return diameter.max_d

adj = [[1],[0,2],[1]]
print(diameter(adj))

A Outputs 3

B Outputs 1

C Outputs 0

D Outputs 2

💡 Hint

Check how the diameter is updated inside the DFS.

The code only tracks the longest single path from a node, missing the sum of two longest paths needed for diameter, so it outputs 1 instead of 2.

❓ Predict Output

advanced

Output of diameter on a star-shaped tree

What is the output of the diameter function on this star-shaped tree adjacency list?

DSA Python

def diameter(adj):
    def dfs(u, p):
        max1 = max2 = 0
        for v in adj[u]:
            if v == p:
                continue
            length = dfs(v, u) + 1
            if length > max1:
                max2 = max1
                max1 = length
            elif length > max2:
                max2 = length
        diameter.max_d = max(diameter.max_d, max1 + max2)
        return max1
    diameter.max_d = 0
    dfs(0, -1)
    return diameter.max_d

adjacency = [[1,2,3,4],[0],[0],[0],[0]]
print(diameter(adjacency))

A 1

B 3

C 2

D 4

💡 Hint

The diameter in a star tree is the longest path between two leaves through the center.

The longest path is between any two leaves through the center node, which has length 2 edges.

🚀 Application

expert

Calculate diameter after adding an edge

Given a tree with adjacency list below, what will be the diameter after adding an edge between nodes 3 and 5?

DSA Python

def diameter(adj):
    def dfs(u, p):
        max1 = max2 = 0
        for v in adj[u]:
            if v == p:
                continue
            length = dfs(v, u) + 1
            if length > max1:
                max2 = max1
                max1 = length
            elif length > max2:
                max2 = length
        diameter.max_d = max(diameter.max_d, max1 + max2)
        return max1
    diameter.max_d = 0
    dfs(0, -1)
    return diameter.max_d

adjacency = [[1,2],[0,3],[0,4],[1],[2,5],[4]]
# Edge between 3 and 5 is added
adjacency[3].append(5)
adjacency[5].append(3)
print(diameter(adjacency))

A 6

B 3

C 4

D 5

💡 Hint

Adding the edge creates a cycle, but diameter is still longest simple path.

The added edge creates a cycle, but the longest simple path (diameter) increases to 5 edges.

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