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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of diameter calculation on a simple tree

What is the output of the following TypeScript code that calculates the diameter of a tree using DP on trees?

DSA Typescript

type Tree = { [key: number]: number[] };

function treeDiameter(tree: Tree): number {
  let diameter = 0;

  function dfs(node: number, parent: number): number {
    let max1 = 0, max2 = 0;
    for (const child of tree[node] || []) {
      if (child === parent) continue;
      const depth = dfs(child, node);
      if (depth > max1) {
        max2 = max1;
        max1 = depth;
      } else if (depth > max2) {
        max2 = depth;
      }
    }
    diameter = Math.max(diameter, max1 + max2);
    return max1 + 1;
  }

  dfs(0, -1);
  return diameter;
}

const tree = {
  0: [1, 2],
  1: [0, 3, 4],
  2: [0],
  3: [1],
  4: [1]
};

console.log(treeDiameter(tree));

A 2

B 4

C 3

D 5

💡 Hint

Think about the longest path between any two nodes in the tree.

The diameter is the longest path between two nodes. Here, the longest path is from node 3 to node 2 or node 4 to node 2, which has length 3 edges.

🧠 Conceptual

intermediate

Understanding the role of DP in tree diameter calculation

Which statement best describes how dynamic programming (DP) is used in calculating the diameter of a tree?

A DP is used to count the total number of nodes in the tree.

B DP stores the longest path from each node to its descendants to avoid recomputation.

C DP helps in converting the tree into a binary tree for easier diameter calculation.

D DP is used to sort the nodes in the tree before calculating the diameter.

💡 Hint

Think about how repeated calculations are avoided in DFS.

DP stores the longest depths from each node to its children so that these values are reused, avoiding repeated DFS calls.

🔧 Debug

advanced

Identify the error in this diameter calculation code

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

DSA Typescript

type Tree = { [key: number]: number[] };

function treeDiameter(tree: Tree): number {
  let diameter = 0;

  function dfs(node: number, parent: number): number {
    let max1 = 0, max2 = 0;
    for (const child of tree[node] || []) {
      if (child === parent) continue;
      const depth = dfs(child, node);
      if (depth > max1) {
        max2 = max1;
        max1 = depth;
      } else if (depth > max2) {
        max2 = depth;
      }
    }
    diameter = Math.max(diameter, max1 + max2);
    return max1 + 1;
  }

  dfs(0, -1);
  return diameter;
}

const tree = {
  0: [1, 2],
  1: [0, 3, 4]
};

console.log(treeDiameter(tree));

A TypeError because tree[node] can be undefined

B SyntaxError due to missing semicolon

C Runtime error due to infinite recursion

D No error, outputs correct diameter

💡 Hint

Check if all nodes have entries in the tree object.

If a node has no children, tree[node] is undefined, so for-of loop throws TypeError.

🚀 Application

advanced

Calculate diameter for a star-shaped tree

Given a star-shaped tree with 1 center node connected to 5 leaf nodes, what is the diameter of this tree?

A 6

B 5

C 1

D 2

💡 Hint

The diameter is the longest path between two leaves through the center.

The longest path goes from one leaf to another through the center node, which is 2 edges.

❓ Predict Output

expert

Output of diameter calculation on a complex tree

What is the output of this TypeScript code that calculates the diameter of a more complex tree?

DSA Typescript

type Tree = { [key: number]: number[] };

function treeDiameter(tree: Tree): number {
  let diameter = 0;

  function dfs(node: number, parent: number): number {
    let max1 = 0, max2 = 0;
    for (const child of tree[node] || []) {
      if (child === parent) continue;
      const depth = dfs(child, node);
      if (depth > max1) {
        max2 = max1;
        max1 = depth;
      } else if (depth > max2) {
        max2 = depth;
      }
    }
    diameter = Math.max(diameter, max1 + max2);
    return max1 + 1;
  }

  dfs(0, -1);
  return diameter;
}

const tree = {
  0: [1, 2],
  1: [0, 3, 4],
  2: [0, 5],
  3: [1, 6],
  4: [1],
  5: [2, 7, 8],
  6: [3],
  7: [5],
  8: [5]
};

console.log(treeDiameter(tree));

A 6

B 7

C 5

D 8

💡 Hint

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

The longest path is from node 6 to node 7 or 8, passing through nodes 3,1,0,2,5, length 6 edges.

Practice

1. What does the diameter of a tree represent in graph theory?

easy

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

B. The number of nodes in the tree

C. The height of the tree from the root

D. The number of leaf nodes in the tree

Solution

1. Step 1: Understand the definition of diameter

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

2. Step 2: Differentiate from other tree properties

   Height is the longest path from root to leaf, number of nodes and leaves are counts, not paths.

3. Final Answer:

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

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 counts nodes instead of path length
• Assuming diameter is from root only

2. Which TypeScript data structure is best to represent a tree for diameter calculation?

easy

A. Boolean flag

B. String array

C. Number variable

D. Array of edges (adjacency list)

Solution

1. Step 1: Identify tree representation needs

   We need to store connections between nodes, so adjacency list (array of edges) is suitable.

2. Step 2: Eliminate unsuitable types

   String array, number variable, or boolean flag cannot represent node connections effectively.

3. Final Answer:

   Array of edges (adjacency list) -> Option D

4. Quick Check:

   Adjacency list = Array of edges [OK]

Hint: Use adjacency list (array of edges) for tree representation [OK]

Common Mistakes:

• Using simple variables instead of lists
• Confusing data types with tree structure
• Using string arrays for numeric node connections

3. What is the output of the following TypeScript code that calculates the diameter of a tree?

const tree = {
  0: [1, 2],
  1: [0, 3],
  2: [0],
  3: [1]
};

function dfs(node: number, parent: number): number {
  let max1 = 0, max2 = 0;
  for (const child of tree[node]) {
    if (child === parent) continue;
    const dist = dfs(child, node) + 1;
    if (dist > max1) {
      max2 = max1;
      max1 = dist;
    } else if (dist > max2) {
      max2 = dist;
    }
  }
  diameter = Math.max(diameter, max1 + max2);
  return max1;
}

let diameter = 0;
dfs(0, -1);
console.log(diameter);

medium

A. 2

B. 3

C. 4

D. 1

Solution

1. Step 1: Trace DFS from node 0

   From node 0, children are 1 and 2. DFS(1) returns 2 (path 1->3), DFS(2) returns 1. dist from 1: 3, from 2: 2.

2. Step 2: Calculate diameter updates

   At node 0, max1=2, max2=1, diameter updated to 3 (2+1). No larger path found elsewhere.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Longest path length = 3 [OK]

Hint: Sum two longest child paths at each node for diameter [OK]

Common Mistakes:

• Ignoring parent to avoid cycles
• Not updating diameter with sum of two longest paths
• Returning wrong distance from DFS

4. Find the bug in this TypeScript code snippet that tries to compute the diameter of a tree:

const tree = {
  0: [1],
  1: [0, 2],
  2: [1]
};

let diameter = 0;
function dfs(node: number): number {
  let max1 = 0, max2 = 0;
  for (const child of tree[node]) {
    const dist = dfs(child) + 1;
    if (dist > max1) {
      max2 = max1;
      max1 = dist;
    } else if (dist > max2) {
      max2 = dist;
    }
  }
  diameter = Math.max(diameter, max1 + max2);
  return max1;
}
dfs(0);
console.log(diameter);

medium

A. Missing parent parameter to avoid revisiting nodes

B. Diameter variable is not initialized

C. DFS function should return diameter instead of max1

D. Tree is not defined as an array

Solution

1. Step 1: Identify infinite recursion cause

   DFS revisits parent node because no parent check, causing infinite recursion.

2. Step 2: Fix by adding parent parameter

   Pass parent node to DFS and skip it in children loop to avoid cycles.

3. Final Answer:

   Missing parent parameter to avoid revisiting nodes -> Option A

4. Quick Check:

   Parent check prevents infinite recursion [OK]

Hint: Pass parent node in DFS to avoid cycles [OK]

Common Mistakes:

• Not skipping parent node in DFS
• Confusing diameter initialization
• Returning wrong values from DFS

5. Given a weighted tree represented as an adjacency list with edges and weights, how would you modify the diameter calculation to find the longest weighted path?

const tree = {
  0: [{node:1, weight:3}, {node:2, weight:2}],
  1: [{node:0, weight:3}, {node:3, weight:4}],
  2: [{node:0, weight:2}],
  3: [{node:1, weight:4}]
};

hard

A. Ignore weights and count edges only

B. Use BFS instead of DFS without weight consideration

C. Add edge weights to distances during DFS and update diameter accordingly

D. Calculate diameter by counting number of nodes only

Solution

1. Step 1: Incorporate weights in DFS distance calculation

   Instead of adding 1 for each edge, add the edge's weight to the distance.

2. Step 2: Update diameter with sum of two longest weighted paths

   Keep track of two longest weighted distances from children and update diameter with their sum.

3. Final Answer:

   Add edge weights to distances during DFS and update diameter accordingly -> Option C

4. Quick Check:

   Weighted distances sum = diameter [OK]

Hint: Sum edge weights in DFS for weighted diameter [OK]

Common Mistakes:

• Ignoring weights and counting edges only
• Using BFS without weights
• Counting nodes instead of path weights