563. The Cheapest Tree Over These Leaves

Build a binary tree whose LEAVES, read left to right, are the given array in order. Every internal node holds the product of the largest leaf in its left subtree and the largest leaf in its right subtree.

Print the smallest possible sum of the internal node values.

6 2 4 -> 32 (6, (2, 4)) gives 2*4 = 8 and 6*4 = 24 4 11 -> 44 7 -> 0 a single leaf has no internal node

## The interval DP

The root splits the leaves into a left run and a right run, so the state is a range:

dp[i][j] = the smallest internal sum for leaves i..j dp[i][i] = 0 dp[i][j] = min over k of dp[i][k] + dp[k+1][j] + max(i..k) * max(k+1..j)

Precompute the range maxima so each candidate split is O(1). That gives O(n^3) and is a complete answer.

## The greedy that also works

There is a linear method, and it is worth knowing because it explains WHAT the cost really is.

Every internal node's value is a product of two leaf maxima, and each leaf except the overall maximum eventually gets "absorbed" by a larger neighbour. The cheapest way to absorb a leaf is to pair it with the SMALLER of its two neighbours.

So: repeatedly take the smallest element, add it times the smaller of its neighbours, and remove it. A monotonic decreasing stack does exactly this in one pass:

for each value x: while the stack top is <= x: mid = pop add mid * min(new top, x) or mid * x if the stack is empty push x then drain the stack, adding each popped value times the one below it

## How much to trust that greedy

The exchange argument above is convincing and it is not a proof.

So it was checked against the interval DP on 3000 random arrays, with no disagreement. That is the right level of care for a rule that replaces an O(n^3) algorithm with an O(n) one: if the rule were subtly wrong it would be wrong on inputs nobody looked at, and the DP would still be there to contradict it.

State the DP first in an interview, then offer the greedy. Offering only the greedy invites the question of why it works, and the honest answer is an exchange argument.

## Boundaries

A single leaf answers 0: there are no internal nodes at all. 7 answers 0, and a solution that always charges for at least one node gets it wrong.

4 11 answers 44, the only tree.

5 4 3 2 answers 38 and 1 2 3 4 answers 20, the same values in opposite orders giving different answers. That pair confirms the order of the leaves is fixed and cannot be sorted.

## Cost

Time O(n^3) with the table, O(n) with the stack. Space O(n^2) or O(n).

Constraints - `1 ≤ n ≤ 100` - `1 ≤ value ≤ 1000`