DP on Trees Maximum Path Sum in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Maximum Path Sum in a Simple Binary Tree

What is the output of the following TypeScript code that calculates the maximum path sum in a binary tree?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function maxPathSum(root: TreeNode | null): number {
  let maxSum = -Infinity;
  function dfs(node: TreeNode | null): number {
    if (!node) return 0;
    const left = Math.max(dfs(node.left), 0);
    const right = Math.max(dfs(node.right), 0);
    maxSum = Math.max(maxSum, node.val + left + right);
    return node.val + Math.max(left, right);
  }
  dfs(root);
  return maxSum;
}

const root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(maxPathSum(root));

A 6

B 5

C 3

D 1

💡 Hint

Think about the path that includes both left and right children plus the root.

The maximum path sum is 2 + 1 + 3 = 6. The function calculates the max sum including left and right subtrees and updates the global max.

❓ Predict Output

intermediate

Maximum Path Sum with Negative Values

What is the output of this code when the tree contains negative values?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function maxPathSum(root: TreeNode | null): number {
  let maxSum = -Infinity;
  function dfs(node: TreeNode | null): number {
    if (!node) return 0;
    const left = Math.max(dfs(node.left), 0);
    const right = Math.max(dfs(node.right), 0);
    maxSum = Math.max(maxSum, node.val + left + right);
    return node.val + Math.max(left, right);
  }
  dfs(root);
  return maxSum;
}

const root = new TreeNode(-10, new TreeNode(9), new TreeNode(20, new TreeNode(15), new TreeNode(7)));
console.log(maxPathSum(root));

A -10

B 35

C 20

D 42

💡 Hint

Consider the path that includes nodes 15, 20, and 7.

The maximum path sum is 15 + 20 + 7 = 42. The function ignores negative paths by using Math.max with 0.

🔧 Debug

advanced

Identify the Error in Maximum Path Sum Implementation

What error will this code produce when run?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

function maxPathSum(root: TreeNode | null): number {
  let maxSum = -Infinity;
  function dfs(node: TreeNode | null): number {
    if (!node) return 0;
    const left = dfs(node.left);
    const right = dfs(node.right);
    maxSum = Math.max(maxSum, node.val + left + right);
    return node.val + Math.max(left, right);
  }
  dfs(root);
  return maxSum;
}

const root = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(maxPathSum(root));

A Stack overflow error due to infinite recursion

B Output is 3 (only root value)

C No error, output is 6

D Output is 7 (incorrect max sum)

💡 Hint

Check how negative values are handled in recursion.

No runtime error and output is 6 (correct for this positive tree). However, the code has a logical bug: it does not ignore negative subtree sums (missing Math.max(..., 0)), which would cause incorrect results on trees with negatives.

🧠 Conceptual

advanced

Understanding the Role of Math.max in DP on Trees

Why do we use Math.max(dfs(node.left), 0) in the maximum path sum calculation?

A To ignore negative path sums and only add positive contributions

B To ensure the recursion terminates properly

C To count the number of nodes in the path

D To double the value of the node if positive

💡 Hint

Think about how negative values affect sums.

Using Math.max with 0 ignores negative sums, preventing them from reducing the total path sum.

🚀 Application

expert

Maximum Path Sum in a Tree with Multiple Branches

Given the following tree structure, what is the maximum path sum?

DSA Typescript

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
    this.val = val === undefined ? 0 : val;
    this.left = left === undefined ? null : left;
    this.right = right === undefined ? null : right;
  }
}

const root = new TreeNode(10,
  new TreeNode(2,
    new TreeNode(20),
    new TreeNode(1)
  ),
  new TreeNode(10,
    null,
    new TreeNode(-25,
      new TreeNode(3),
      new TreeNode(4)
    )
  )
);

function maxPathSum(root: TreeNode | null): number {
  let maxSum = -Infinity;
  function dfs(node: TreeNode | null): number {
    if (!node) return 0;
    const left = Math.max(dfs(node.left), 0);
    const right = Math.max(dfs(node.right), 0);
    maxSum = Math.max(maxSum, node.val + left + right);
    return node.val + Math.max(left, right);
  }
  dfs(root);
  return maxSum;
}

console.log(maxPathSum(root));

A 55

B 42

C 48

D 60

💡 Hint

Focus on the path that includes nodes 20, 2, 10, and 10.

The maximum path sum is 42 from the path 20 -> 2 -> 10 -> 10. The negative branch (-25) is ignored due to Math.max with 0.

Practice

1. What does the "maximum path sum" in a tree represent in the context of dynamic programming on trees?

easy

A. The sum of all node values in the tree

B. The largest sum of node values along any path between two nodes in the tree

C. The maximum value of a single node in the tree

D. The longest path length in the tree

Solution

1. Step 1: Understand the problem definition

   The maximum path sum is about finding the path between any two nodes that yields the highest sum of node values.

2. Step 2: Differentiate from other sums

   It is not the sum of all nodes or just the max node value, but the max sum along a connected path.

3. Final Answer:

   The largest sum of node values along any path between two nodes in the tree -> Option B

4. Quick Check:

   Maximum path sum = max sum on any path [OK]

Hint: Maximum path sum is about any path, not whole tree sum [OK]

Common Mistakes:

• Confusing maximum path sum with sum of all nodes
• Thinking it is just the max node value
• Assuming path must start at root

2. Which of the following TypeScript function signatures correctly represents a recursive function to find maximum path sum in a binary tree node?

easy

A. function maxPathSum(node: TreeNode): void

B. function maxPathSum(node: number): number

C. function maxPathSum(): number

D. function maxPathSum(node: TreeNode | null): number

Solution

1. Step 1: Check parameter type

   The function must accept a TreeNode or null to handle empty nodes.

2. Step 2: Check return type

   It should return a number representing the max path sum from that node.

3. Final Answer:

   function maxPathSum(node: TreeNode | null): number -> Option D

4. Quick Check:

   Correct parameter and return type [OK]

Hint: Function must accept node or null and return number [OK]

Common Mistakes:

• Using wrong parameter type (e.g., number instead of TreeNode)
• Returning void instead of number
• Not allowing null for leaf children

3. Consider the following TypeScript code snippet for maximum path sum in a binary tree:

class TreeNode {
  val: number;
  left: TreeNode | null;
  right: TreeNode | null;
  constructor(val = 0, left: TreeNode | null = null, right: TreeNode | null = null) {
    this.val = val;
    this.left = left;
    this.right = right;
  }
}

function maxPathSum(root: TreeNode | null): number {
  let maxSum = -Infinity;
  function dfs(node: TreeNode | null): number {
    if (!node) return 0;
    const left = Math.max(dfs(node.left), 0);
    const right = Math.max(dfs(node.right), 0);
    maxSum = Math.max(maxSum, node.val + left + right);
    return node.val + Math.max(left, right);
  }
  dfs(root);
  return maxSum;
}

const tree = new TreeNode(1, new TreeNode(2), new TreeNode(3));
console.log(maxPathSum(tree));

What is the output of this code?

medium

A. 3

B. 5

C. 6

D. 1

Solution

1. Step 1: Trace DFS on tree nodes

   For node 2 and 3, max path sums are 2 and 3 respectively. For root 1, left=2, right=3.

2. Step 2: Calculate maxSum updates

   maxSum updates to max(-Infinity, 1+2+3) = 6. Return value for root is 1 + max(2,3) = 4 but maxSum remains 6.

3. Final Answer:

   6 -> Option C

4. Quick Check:

   Sum of path 2->1->3 = 6 [OK]

Hint: Sum left + node + right for max path sum [OK]

Common Mistakes:

• Returning max path from root only, ignoring subtrees
• Not using Math.max with 0 to ignore negative sums
• Confusing return value with maxSum global

4. The following TypeScript code attempts to find the maximum path sum in a binary tree but has a bug:

function maxPathSum(root: TreeNode | null): number {
  let maxSum = -Infinity;
  function dfs(node: TreeNode | null): number {
    if (!node) return 0;
    const left = dfs(node.left);
    const right = dfs(node.right);
    maxSum = Math.max(maxSum, node.val + left + right);
    return node.val + Math.max(left, right);
  }
  dfs(root);
  return maxSum;
}

What is the bug in this code?

medium

A. It does not ignore negative sums from left or right subtree

B. It returns void instead of number

C. It does not handle null root

D. It uses global variable incorrectly

Solution

1. Step 1: Analyze subtree sums usage

   The code uses left and right sums directly without ignoring negative values.

2. Step 2: Identify impact on maxSum

   Negative sums can reduce maxSum, so we must use Math.max(dfs(...), 0) to ignore negatives.

3. Final Answer:

   It does not ignore negative sums from left or right subtree -> Option A

4. Quick Check:

   Negative subtree sums must be ignored [OK]

Hint: Use Math.max(dfs(...), 0) to ignore negatives [OK]

Common Mistakes:

• Not checking for negative subtree sums
• Assuming dfs returns void
• Ignoring null root case

5. Given a binary tree where some nodes have negative values, how would you modify the dynamic programming approach to find the maximum path sum that can start and end at any node, but the path must go downwards (only from parent to child)?

hard

A. Use DFS to compute max downward path sum at each node ignoring negative sums by max(0, childSum)

B. Use BFS to find the longest path ignoring node values

C. Sum all node values and subtract minimum node value

D. Only consider paths that include the root node

Solution

1. Step 1: Understand downward path constraint

   The path must go downwards from parent to child, so use DFS to explore children.

2. Step 2: Handle negative values

   Ignore negative sums by taking max(0, childSum) to avoid reducing path sum.

3. Step 3: Calculate max path sum

   At each node, max downward path sum = node.val + max(leftChildSum, rightChildSum, 0).

4. Final Answer:

   Use DFS to compute max downward path sum at each node ignoring negative sums by max(0, childSum) -> Option A

5. Quick Check:

   Downward path + ignore negatives = DFS with max(0, childSum) [OK]

Hint: Downward path max sum uses DFS and max(0, childSum) [OK]

Common Mistakes:

• Using BFS instead of DFS
• Ignoring negative values incorrectly
• Forcing path through root only