Ruby - Max Array Sum from non-adjacent integers in array - arrays

Question

This code walks through the array and returns the largest sum of non-adjacent integers. This is from HackerRank - Can anyone explain why this works? Its a solution I found online but I don't understand it and didn't figure this out myself.
Thanks!
https://www.hackerrank.com/challenges/max-array-sum/problem?h_l=interview&playlist_slugs%5B%5D=interview-preparation-kit&playlist_slugs%5B%5D=dynamic-programming
def maxSubsetSum(arr)
incl = 0
excl = 0
temp = 0
for i in 0...arr.size
temp = incl
incl = [arr[i]+excl, temp].max
excl = temp
end
return [incl, excl].max
end
maxSubsetSum([1,3,5,2,4,6,8])

Answer 1

This is some pretty ugly (by ugly I mean unidiomatic) Ruby code so let's clean it up before we proceed:
def maxSubsetSum(arr)
incl = 0
excl = 0
temp = 0
arr.each do |value|
temp = incl
incl = [value + excl, temp].max
excl = temp
end
[incl, excl].max
end
maxSubsetSum([1,3,5,2,4,6,8])
Now we can start to analyze this code. I've gone through and written the values of each variable at each step in the loop:
value = 1
temp = 0
incl = 1
excl = 0
value = 3
temp = 1
incl = 3
excl = 1
value = 5
temp = 3
incl = 6
excl = 3
value = 2
temp = 6
incl = 6
excl = 6
value = 4
temp = 6
incl = 10
excl = 6
value = 6
temp = 10
incl = 12
excl = 10
value = 8
temp = 12
incl = 18
excl = 12
(return 18)
At any given point, the program is determining whether or not it should "use" a value -- the disadvantage to using a value is that you cannot use the value after it, as that is adjacent. At every step in the process, it's comparing adding the current value to excl (which represents the best sum at the previous step without including that value) with incl (technically temp but temp holds incl at that stage), which represents the value at the previous iteration of including the value.
temp is not remembered across loops; after each iteration of the loop, the only values that matter are incl and excl. To reiterate, at the end of each loop, incl holds the best sum that includes the previous number, and excl holds the best sum that does not include the previous number. At each step in the loop, incl and excl are re-computed to reflect the inclusion or exclusion of the new value.
To show that this process does work, let's consider the above array but with an extra element at the end, 7. So now our array looks like this: [1,3,5,2,4,6,8,7]. We already have most of the work done from the previous listing. We set temp to 18, incl becomes [7 + 12, 18].max which is 19, and excl becomes 18. Now we can see that including this last number means that we get a number larger than the previous result, so we have to use it, and that means that we can't use the 8 we previously used to get our result.
This process is known as dynamic programming, where in order to determine the answer to the overall question, you break the problem down and add complexity to it. In this case, we break the array down and then slowly add back each value, keeping track of what the best results for the previous part are.

Answer 2

Understand the algorithm
The code is fairly straightforward once you understand the algorithm being used. A Google search turned up many hits. See, for example, this article. They all seem to use the same dynamic programming approach.
The general solution produces both the maximum sum and the array of elements from the original array that produce that sum. Here only the sum is needed so the solution is simplified slightly. I will first describe the algorithm for producing the general solution, then will simplify to compute only the maximum sum.
Compute general solution
If the array is a, the nth step computes two values: the maximum sum among the first n elements, a[0], a[1],...,a[n-1], if the nth element is included and the maxium sum if that element is excluded. This is easy because those two results have already been computed for the previous element, a[n-2]. When the last element of the array has been processed the maximum sum equals the larger of the maximum sum when the last element is included and the maximum sum when the last element is excluded. To construct the array that yields the maximum sum a simple walk-back is employed.
Let b be an array of hashes that we will build. Initially,
b[0] = { included: 0, excluded: 0 }
Then for each n = 1,..., m, where m = a.size,
b[n] = { included: a[n-1] + b[n-1][:excluded],
excluded: [b[n-1][:included], b[n-1][:excluded]].max }
After b[m] has been computed, the maximum total equals
[b[m][:included], b[m][:excluded]].max
The walk-back to construct the array that yields the largest sum is outlined in the example below.
Consider the following.
arr = [1, 3, -2, 7, 4, 6, 8, -3, 2]
b = (1..arr.size).each_with_object([{ included: 0, excluded: 0 }]) do |n,b|
b[n] = { included: arr[n-1] + b[n-1][:excluded],
excluded: [b[n-1][:included], b[n-1][:excluded]].max }
end
#=> [{:included=> 0, :excluded=> 0}, n arr[n-1]
# {:included=> 1, :excluded=> 0}, 1 1
# {:included=> 3, :excluded=> 1}, 2 3
# {:included=>-1, :excluded=> 3}, 3 -2
# {:included=>10, :excluded=> 3}, 4 7
# {:included=> 7, :excluded=>10}, 5 4
# {:included=>16, :excluded=>10}, 6 6
# {:included=>18, :excluded=>16}, 7 8
# {:included=>13, :excluded=>18}, 8 -3
# {:included=>20, :excluded=>18}] 9 2
I've included arr[-1] for each value of n above for easy reference. The largest sum is seen to be [20, 18].max #=> 20, which includes the last element, arr[9] #=> 2. Hence, arr[8] could not be included. Note that b[8][:excluded] + arr[8] #=> 18 + 2 => 20, which is b[9][:included].
Since arr[8] is excluded arr[7] could be included or excluded. We see that b[7][:included] == b[8][:excluded] == 18 and b[7][:excluded] == 16 < 18 == b[8][:exclued], which tells us that arr[7] is included. The same reasoning is used to walk back to the beginning of b, demonstrating that the elements that sum to 20 form the array are [3, 7, 8, 2]. In general, multiple optimal solutions are of course possible.
Compute maximum sum only
If, as in this question, only the maximum sum is required, and not the array of elements that produce it, there is no need for b to be an array. We may simply write
b = { included: a[0], excluded: 0 }
Then for each n = 1,..., m-1
b[:included], b[:excluded] =
a[n] + b[:excluded], [b[:included], b[:excluded]].max
We may wrap this in a method as follows.
def max_subset_sum(arr)
arr.size.times.with_object({ included: 0, excluded: 0 }) do |n,h|
h[:included], h[:excluded] =
arr[n] + h[:excluded], [h[:included], h[:excluded]].max
end.values.max
end
max_subset_sum arr
#=> 20 (= 3+7+8+2)
If desired, we can write this with two-element arrays rather than hashes (closer to the code in the question), though I don't think it's as clear.
def optimize(arr)
arr.size.times.with_object([0, 0]) do |n,a|
a[0], a[1] = arr[n] + a[1], [a[0], a[1]].max
end.max
end
optimize arr
#=> 20
Notice that I've used parallel assignment to avoid the create of a temporary variable.