DP on Trees Diameter of Tree in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the adjacency list for the tree.

DSA Python

adj = [[] for _ in range([1])]

Drag options to blanks, or click blank then click option'

A2*n

Bn+1

Cn-1

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using n instead of n+1 causes index errors when accessing node n.

Using n-1 is too small and misses the last node.

We use n+1 because nodes are numbered from 1 to n, so we need an extra slot for 1-based indexing.

2fill in blank

medium

Complete the code to add an undirected edge between nodes u and v.

DSA Python

adj[u].[1](v)
adj[v].append(u)

Drag options to blanks, or click blank then click option'

Aappend

Bextend

Cinsert

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using extend adds each character of the string as separate elements.

Using insert requires an index and is not needed here.

We use append to add a single element to the adjacency list for node u.

3fill in blank

hard

Fix the error in the DFS function to avoid revisiting the parent node.

DSA Python

def dfs(node, parent):
    for neighbor in adj[node]:
        if neighbor != [1]:
            dfs(neighbor, node)

Drag options to blanks, or click blank then click option'

Aparent

BNone

Cneighbor

Dnode

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing with node instead of parent causes incorrect skipping.

Using None does not prevent revisiting the parent.

We skip the parent node to avoid going back and causing infinite recursion.

4fill in blank

hard

Fill both blanks to update the diameter and return the longest path length from the current node.

DSA Python

def dfs(node, parent):
    max1 = max2 = 0
    for neighbor in adj[node]:
        if neighbor != parent:
            length = dfs(neighbor, node) + 1
            if length > max1:
                max2 = max1
                max1 = [1]
            elif length > max2:
                max2 = [2]
    global diameter
    diameter = max(diameter, max1 + max2)
    return max1

Drag options to blanks, or click blank then click option'

Alength

Bmax1

Cmax2

Dneighbor

Attempts:

3 left

💡 Hint

Common Mistakes

Using max1 or max2 incorrectly causes wrong diameter calculation.

Returning max2 instead of max1 breaks the recursion logic.

We update max1 and max2 with the new length if it is greater than the current max values.

5fill in blank

hard

Fill all three blanks to compute the diameter of the tree using DFS.

DSA Python

def tree_diameter(n, edges):
    global adj, diameter
    adj = [[] for _ in range([1])]
    for u, v in edges:
        adj[u].append(v)
        adj[v].append(u)
    diameter = 0
    dfs([2], -1)
    return [3]

Drag options to blanks, or click blank then click option'

An+1

B1

Cdiameter

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting DFS from 0 causes index errors if nodes start at 1.

Returning 0 or n instead of diameter gives wrong result.

We create adjacency list with n+1 for 1-based nodes, start DFS from node 1, and return the global 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