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

Practice - 5 Tasks

1fill in blank

easy

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

DSA C

int adj[[1]][100]; // adjacency list for tree
int size[[1]]; // size of adjacency for each node

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

A1000

B10000

C100

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing too small an array size causing out-of-bounds errors.

Choosing unnecessarily large arrays wasting memory.

The adjacency list size is set to 10000 to handle up to 10000 nodes, which is common for tree problems.

2fill in blank

medium

Complete the code to add an edge from node u to node v in the adjacency list.

DSA C

adj[u][size[u]++] = [1];

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

Av

Bu

Csize[u]

Dsize[v]

Attempts:

3 left

💡 Hint

Common Mistakes

Adding u instead of v causing incorrect adjacency.

Using size[v] which is unrelated here.

We add node v to the adjacency list of node u, so the correct value is v.

3fill in blank

hard

Fix the error in the DFS function header to correctly pass the parent node.

DSA C

void dfs(int u, int [1]) {

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

Aparent

Bpar

Cprev

Dp

Attempts:

3 left

💡 Hint

Common Mistakes

Using unclear or inconsistent parameter names.

Omitting the parent parameter causing infinite recursion.

Using 'parent' as the parameter name is clear and consistent with common tree DFS implementations.

4fill in blank

hard

Fill both blanks to update the diameter and height during DFS.

DSA C

if (height[v] + height[u] + 1 > diameter) {
    diameter = height[v] + height[u] + [1];
}
height[u] = 1 + [2];

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

A1

B0

Cheight[v]

Ddiameter

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to add 1 to diameter update.

Assigning height[u] without adding 1.

Add 1 for the edge between u and v to update diameter; height[u] is 1 plus the max height of child v.

5fill in blank

hard

Fill all three blanks to complete the DFS loop over children and update heights.

DSA C

for (int i = 0; i < size[u]; i++) {
    int v = adj[u][[1]];
    if (v != [2]) {
        dfs(v, u);
        if (height[v] > height[u]) {
            height[u] = height[v];
        }
    }
}
height[u] = height[u] + [3];

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

Ai

Bparent

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong index variable for adjacency.

Not skipping the parent node causing infinite recursion.

Forgetting to add 1 to height[u].

Loop index i is used to access adjacency; skip parent node; height[u] is incremented by 1 for edge.

Practice

1. What is the diameter of a tree in the context of dynamic programming on trees?

easy

A. The height of the tree from the root

B. The number of nodes in the tree

C. The sum of all edge weights in the tree

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

Solution

1. Step 1: Understand the definition of tree diameter

   The diameter is the longest path between any two nodes in the tree, not just from the root.

2. Step 2: Differentiate from other tree properties

   Height is from root to leaf, sum of edges is total weight, and node count is size, none represent longest path.

3. Final Answer:

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

4. Quick Check:

   Diameter = Longest path [OK]

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

Common Mistakes:

• Confusing diameter with height
• Thinking diameter is number of nodes
• Assuming diameter is sum of all edges

2. Which of the following is the correct way to declare an adjacency list for a tree with n nodes in C?

easy

A. int adj[n][n];

B. int* adj[n];

C. int adj[n];

D. int adjList[n][2];

Solution

1. Step 1: Understand adjacency list structure

   An adjacency list uses an array of pointers to lists (or arrays) of neighbors, so int* adj[n]; is correct.

2. Step 2: Differentiate from other declarations

   int adj[n][n]; is adjacency matrix, int adj[n]; is a simple array, int adjList[n][2]; is edge list, not adjacency list.

3. Final Answer:

   int* adj[n]; -> Option B

4. Quick Check:

   Adjacency list uses array of pointers [OK]

Hint: Adjacency list uses array of pointers to neighbors [OK]

Common Mistakes:

• Using 2D array as adjacency list
• Using simple array for adjacency
• Confusing edge list with adjacency list

3. Consider the following C code snippet to find the diameter of a tree. What will be the output if the tree has edges: 1-2, 2-3, 2-4?

int diameter = 0;
int dfs(int node, int parent, vector<int> adj[]) {
    int max1 = 0, max2 = 0;
    for (int child : adj[node]) {
        if (child == parent) continue;
        int height = dfs(child, node, adj) + 1;
        if (height > max1) {
            max2 = max1;
            max1 = height;
        } else if (height > max2) {
            max2 = height;
        }
    }
    diameter = max(diameter, max1 + max2);
    return max1;
}
// Call dfs(1, -1, adj) and then print diameter;

medium

A. 2

B. 3

C. 1

D. 4

Solution

1. Step 1: Trace DFS from node 1

   From node 1, child is 2. DFS(2) explores children 3 and 4. Heights from 3 and 4 are 1 each.

2. Step 2: Calculate diameter updates

   At node 2, max1=1, max2=1, diameter updated to 2. At node 1, max1=2, max2=0, diameter remains 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Longest path length = 2 edges [OK]

Hint: Diameter = sum of two longest child heights [OK]

Common Mistakes:

• Counting nodes instead of edges
• Not updating diameter correctly
• Ignoring parent to avoid cycles

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

int diameter = 0;
int dfs(int node, int parent, vector<int> adj[]) {
    int max1 = 0, max2 = 0;
    for (int child : adj[node]) {
        int height = dfs(child, node, adj) + 1;
        if (height > max1) {
            max2 = max1;
            max1 = height;
        } else if (height > max2) {
            max2 = height;
        }
    }
    diameter = max(diameter, max1 + max2);
    return max1;
}
// Called with dfs(1, -1, adj);

medium

A. Incorrect initialization of diameter variable

B. Returning max2 instead of max1 from DFS

C. Missing check to skip parent node in DFS

D. Not adding 1 to height in DFS call

Solution

1. Step 1: Identify missing parent check in DFS loop

   The code does not skip the parent node, causing infinite recursion or wrong heights.

2. Step 2: Explain impact of missing check

   Without skipping parent, DFS revisits parent, causing incorrect diameter calculation or stack overflow.

3. Final Answer:

   Missing check to skip parent node in DFS -> Option C

4. Quick Check:

   Skip parent to avoid cycles [OK]

Hint: Always skip parent node in DFS to prevent cycles [OK]

Common Mistakes:

• Forgetting to skip parent node
• Returning wrong height value
• Incorrect diameter initialization

5. Given a weighted tree with edges: (1-2, 3), (2-3, 4), (2-4, 2), how would you modify the diameter calculation to find the longest weighted path? Choose the correct approach.

hard

A. Add edge weights to height calculations and update diameter with weighted sums

B. Ignore weights and use number of edges as diameter

C. Multiply edge weights instead of adding

D. Use BFS twice without considering weights

Solution

1. Step 1: Incorporate edge weights in DFS height calculation

   Instead of adding 1 for each edge, add the actual edge weight to the height returned by DFS.

2. Step 2: Update diameter with sum of two largest weighted heights

   Keep track of two largest weighted heights from children and update diameter with their sum.

3. Final Answer:

   Add edge weights to height calculations and update diameter with weighted sums -> Option A

4. Quick Check:

   Weighted diameter sums edge weights [OK]

Hint: Add weights to heights, sum two largest for diameter [OK]

Common Mistakes:

• Ignoring weights in diameter calculation
• Multiplying weights instead of adding
• Using unweighted BFS for weighted tree