Maximum Path Sum in Binary Tree in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Maximum Path Sum Calculation

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 tree = new TreeNode(-10,
  new TreeNode(9),
  new TreeNode(20, new TreeNode(15), new TreeNode(7))
);
console.log(maxPathSum(tree));

A 27

B 35

C 42

D 20

💡 Hint

Consider the path that includes the root's right subtree and its children.

The maximum path sum is 42, coming from the path 15 -> 20 -> 7. The root's value -10 is not included because it reduces the sum. The path 15 + 20 + 7 = 42 is the highest sum path in the tree.

🧠 Conceptual

intermediate

Understanding Maximum Path Sum Concept

Which statement best describes the maximum path sum in a binary tree?

A It is the largest sum of values from any path between two nodes, which may or may not include the root.

B It is the sum of all node values in the tree.

C It is the largest sum of values from any path starting at the root and ending at a leaf.

D It is the largest sum of values from any path that must include the root node.

💡 Hint

Think about paths that can start and end anywhere in the tree.

The maximum path sum is the largest sum of values from any path between two nodes in the tree. The path can start and end at any nodes and does not have to include the root or a leaf.

🔧 Debug

advanced

Identify the Error in Maximum Path Sum Code

What error will the following TypeScript code produce when calculating maximum path sum?

DSA Typescript

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 tree = new TreeNode(1, new TreeNode(-2), new TreeNode(3));
console.log(maxPathSum(tree));

A Returns 0

B Returns 4

C Returns 1

D Returns 3

💡 Hint

Check how negative values affect the path sums.

The code does not ignore negative sums from children, so it includes negative values in the path sum. The maximum path sum is 4 from path 3 + 1, ignoring the negative left child.

❓ Predict Output

advanced

Output of Maximum Path Sum with Negative Nodes

What is the output of this TypeScript code calculating maximum path sum in a tree with 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 tree = new TreeNode(-3);
console.log(maxPathSum(tree));

A -Infinity

B 0

C 3

D -3

💡 Hint

Consider that the tree has only one node with a negative value.

The maximum path sum is -3 because the only node has value -3. The code returns the node value since no positive gains from children exist.

🧠 Conceptual

expert

Why Use Math.max with 0 in Maximum Path Sum DFS?

Why does the maximum path sum algorithm use Math.max(dfs(child), 0) when calculating left and right gains?

A To ignore negative path sums from children that would reduce the total sum.

B To ensure the path always includes both children.

C To convert all negative values to zero permanently in the tree.

D To count only leaf nodes in the path sum calculation.

💡 Hint

Think about how negative values affect the sum of a path.

Using Math.max with 0 ignores negative sums from children, preventing them from decreasing the total path sum. This ensures the path sum only includes positive contributions.