Algorithmic puzzle: Ball Stacking Problem - algorithm

Question

I am trying to solve this problem: https://www.urionlinejudge.com.br/judge/en/problems/view/1312
The XYZ TV channel is developing a new game show, where a contestant
has to make some choices in order to get a prize. The game consists of
a triangular stack of balls, each of them having an integer value, as
the following example shows.
The contestant must choose which balls he is going to take and his
prize is the sum of the values of those balls. However, the contestant
can take any given ball only if he also takes the balls directly on
top of it. This may require taking additional balls using the same
rule. Notice that the contestant may choose not to take any ball, in
which case the prize is zero.
The TV show director is concerned about
the maximum prize a contestant can make for a given stack. Since he is
your boss and he does not know how to answer this question, he
assigned this task to you.
Input
Each test case is described using several lines. The first line
contains an integer N representing the number of rows of the stack (1
≤ N ≤ 1000). The i th of the next N lines contains i integers Bij
(−105 ≤ Bij ≤ 105 for 1 ≤ j ≤ i ≤ N); the number Bij is the value of
the j th ball in the i th row of the stack (the first row is the
topmost one, and within each row the first ball if the leftmost one).
The last test case is followed by a line containing one zero.
Output
Sample Input | Sample Output
4 | 7
3 | 0
-5 3 | 6
-8 2 -8 |
3 9 -2 7 |
2 |
-2 |
1 -10 |
3 |
1 |
-5 3 |
6 -4 1 |
0 |
I'd love a pointer or two on how to solve this problem.
It seems like it is solvable using a DP approach, but I can't quite formulate the recurrence. The fact that two adjacent balls could have overlapping children is making things a bit difficult.

Answer 1

This is DP, but we're going sideways instead of top-down. Let's tilt the ball stack a little to the left, so we can look at the whole stack as a sequence of columns.
3 3 -8 7
-5 2 -2
-8 9
3
From this viewpoint the rule of the game becomes: if we want to take a ball, we also need to take the ball above, and the ball directly to its left.
Now, solving the problem. We'll calculate a quantity S[i, j] for each ball
-- this represents the best sum we could achieve if the ball at position [i, j] is taken (the `jth ball from the top of the ith column), while considering only the first i columns.
I claim that the following recurrence holds (with some sensible initial conditions):
S[i, j] = MAX(S[i-1, j] + C[i, j], S[i, j+1])
where C[i, j] is the sum of the first j balls in the ith column.
Let's break that down a bit. We want to calculate S[i, j].
We have to take the ball at [i, j]. And let's suppose for now that this is the bottom-most ball we take from this column.
This requires all the balls in this column above it to be taken, with the sum (including [i, j] itself) being C[i, j].
It also requires the ball at [i-1, j] to be taken (unless we're at the leftmost column, of course). We know that the best sum from taking this ball is S[i-1, j], by definition.
So the best possible total sum is: S[i-1, j] + C[i, j], or just C[i, j] for the leftmost column.
But we can choose differently and take more balls from this column (if we have more balls). We need to calculate and take the maximum value out of S[i-1, j] + C[i, j], S[i-1, j+1] + C[i, j+1], and so on, all the way down to the bottom of the pile.
With a little induction it's easy to see this is equal to MAX(S[i-1, j] + C[i, j], S[i, j+1]).
The implementation should be obvious now. We process the stack column-by-column, in each column calculate the partial sum C[i, j] from the top down, then work out S[i, j] from bottom up.
Finally, just take the maximum value of S[i, j] we've encountered (or 0) as the answer.
This runs in linear time to the number of balls, so O(N^2).
To illustrate, here's (C[i, j], S[i, j]) pairs for the given example.
( 3, 3) ( 3,7) ( -8,-1) (7,6)
( -2,-2) ( 5,7) (-10,-3)
(-10,-7) (14,7)
( -7,-7)

Answer 2

(Updated with better understanding from Worakarn Isaratham's answer.)
We can have a naive recurrence with O(N^2) search space (note that there are O(N^2) total balls so to do any better we could not examine all entries) by iterating over the diagonals. Let's say southwest.
\ jth NW diagonal
x
x o
A o x
x o x o
x o x B x / ...etc
C o x o x o / 3rd iteration
x o D o E F x / 2nd iteration
x o x o x o x o / 1st iteration (ith SW diagonal)
x o x o x o x G x
/ / / \
Each choice along a southwest diagonal, would restrict all the rest of the choices and sums below a northwest diagonal (e.g., being able to choose E means we've only chosen as far as the FG diagonal on previous iterations and choosing it would restrict all subsequent choices below the AE diagonal.
Say we label southwest diagonals as i and our northwest bound as j, and have a function sum_northwest that calculates in O(1) (using prefix sums) and takes as parameters one northwest diagonal and a southwest bound. Then, if f(i, j) represents the optimal choice up to the ith southwest column with nothwest bound j:
f(i, j) = max(
// Skip choosing from
// this southwest diagonal
f(i - 1, j),
// Choose this northwest diagonal
// on this southwest diagonal
sum_northwest(j - 1, i) + f(i - 1, j - 1),
// Choose an earlier northwest diagonal,
// but then we are obliged to also
// include this northwest diagonal
sum_northwest(j - 1, i) + f(i, j - 1)
)
Time complexity is O(|I| * |J|), assuming we are tabling results.
JavaScript code (not optimised):
function sum_northwest(M, j, i){
return M[j].slice(0, i + 1)
.reduce((a, b) => a + b, 0)
}
function f(M, i, j){
if (i < 0 || j < 1 || i >= M[M.length-j].length)
return 0
let this_northwest =
sum_northwest(M, M.length - j, i)
return Math.max(
f(M, i - 1, j),
this_northwest + f(M, i - 1, j - 1),
this_northwest + f(M, i, j - 1)
)
}
var M = [
[ 3, 3,-8, 7],
[-5, 2,-2],
[-8, 9],
[ 3]
]
console.log(f(M, 3, 4))
M = [
[-2,-10],
[ 1]
]
console.log(f(M, 1, 2))
M = [
[ 1, 3, 1],
[-5,-4],
[ 6]
]
console.log(f(M, 2, 3))

Answer 3

O
/\
/ \
A/ \B
/ \ / \
/ \/ \
C M D
Suppose we take a ball at M, then we also need to take all the balls from the region MAOB. We are left with 2 triangles: CAM and MBD, and we need to select balls from these two triangles to maximize the points. This is the same problem, but with a smaller input.
So we define the value function over the sets of all sub-triangles in the stack
Let C[i,j,h] = maximum points from a sub-triangle with the top at (i,j) and with height = h (I use right-angled triangles to illustrate here because it is easier to draw)
|\
| \
| \
| \
| A \
| |\ \
| | \ \
| | \ \
| |D \E \
| |\ |\ \
| | \ | \ \
| |__\|__\ \
| B M C \
|_____________\
A = (i,j)
B = (i+h, j)
C = (i+h, j+h)
M = (i+h, j+k)
D = (i, j+h-k)
E = (i+k, j+k)
Recursive formula:
C[i,j,h] = max(
C[i,j,h-1] // pick no ball at line i+h
C[i,j+h-k,k] + C[i+k,j+k,h-k] + sum(ADME) for k from 0 to h // if pick a ball at (i+h, j+k)
)

Answer 4

I will show a solution in O(N log N) time complexity and O(N) memory complexity.
First of all, you are correct we will use a Dynamic Programing approach. The data structure we will use will be a triangle of the same size. Each ball in the new triangle will be the value of the competitor if it took that ball. We can build it in O(N) time - top to bottom.
Now we need to notice some interesting claim: The ball with the highest value in the new triangle will be taken (unless it's negative in which case we will not take any thing).
Proof: (Quite straightforward) If not taken, than we can take it and necessarily get the total value higher.
Another interesting claim: All the balls below (that will take it if they were taken) the the ball with highest score in the data structure - will not be taken.
Proof: If they were taken it mean that the value of them is positive without the ball with the highest value and that means that their value is higher which is impossible.
Now to the algorithm:
Build the data structure.
Set of all taken items = {}
while there are positive elements in the structure:
Take highest one - put in the set.
make all below it 0, and put then in the set.
make all above it negative infinity.
Rebuild the data structure for the rest.
Return the set
This will always be optimal - we take the ball with highest value, we will never miss a ball that ban help us, and we will never miss other balls since we rebuild the data structure.
Memory complexity is simple: O(N) for the data structure.
Time complexity is tricky: Creating the data structure is O(N), each time in the loop we remove at least half of the elements and we will not recompute for them, therefore number of iterations will be logarithmic in N so O(N log N).