试图了解我在 python 中找到的三角形最大路径总和的代码是如何工作的

Question

So take a triangle formatted as a nested list. eg

t =  [[5],[3, 6],[8, 14, 7],[4, 9, 2, 0],[9, 11, 5, 2, 9],[1, 3, 8, 5, 3, 2]]

and define a path to be the sum of elements from each row of the triangle, moving 1 to the left or right as you go down rows. Or in python the second index either stays the same or we add 1 to it.

a_path = [t[0][0],[t[1][1]],t[2][1],t[3][1],t[4][2],t[5][3]] = [5, 6, 14, 9, 5,5] is valid
not_a_path = [t[0][0],[t[1][0]],t[2][2],t[3][1],t[4][0],t[5][4]] = [5, 3, 7, 9, 9, 3] is not valid

For a triangle as small as this example this can obviously be done via brute force. I wrote a function like that, for a 20 row triangle it takes about 1 minuite. I need a function that can do this for a 100 row triangle. I found this code on https://rosettacode.org/wiki/Maximum_triangle_path_sum#zkl and it agrees with all the results my terrible function outputs for small triangles I've tried, and using %time in the console it can do the 100 line triangle in 0 ns so relatively quick.

def maxPathSum(rows):
    return reduce(
        lambda xs, ys: [
            a + max(b, c) for (a, b, c) in zip(ys, xs, xs[1:])
        ],
        reversed(rows[:-1]), rows[-1]
    )

So I started taking bits of this, and using print statements and the console to work out what it was doing. I get that reversed(rows[:-1]), rows[-1] is reversing the triangle so that we can iterate from all possible final values on the last row through the sums of their possible paths to get to that value, and that as a,b,c iterate: a is a number from the bottom row, b is the second from bottom row, c is the third from bottom row. And as they iterate I think a + max(b,c) seems to sum a with the greatest number on b or c, but when I try to find the max of either two lists or a nested list in the console the list returned seems completely arbitrary.

ys = t[-1]
xs = list(reversed(t[:-1]))
for (a, b, c) in zip(ys, xs, xs[1:]):
    print(b)
    print(c)
    print(max(b,c))
    print("")

prints

[9, 11, 5, 2, 9]
[4, 9, 2, 0]
[9, 11, 5, 2, 9]

[4, 9, 2, 0]
[8, 14, 7]
[8, 14, 7]

[8, 14, 7]
[3, 6]
[8, 14, 7]

[3, 6]
[5]
[5]

If max(b,c) returned the list containing max(max(b),max(c)) then b = [3, 6], c = [5] would return b, so not that. If max(b,c) returned the list with the greatest sum, max(sum(b),sum(c)), then the same example contradicts it. It doesn't return the list containg minimum value or the one with the greatest mean, so my only guess is that the fact that I set xs = list(reversed(t[:-1])) is the problem and that it works fine if its an iterator inside the lambda function but not in console.

Also trying to find a + max (b,c) gives me this error, which makes sense.

TypeError: unsupported operand type(s) for +: 'int' and 'list'

My best guess is again that the different definition of xs as a list is the problem. If true I would like to know how this all works in the context of being iterators in the lambda function. I think I get what reduce() and zip() are doing, so mostly just the lambda function is what's confusing me.

Thanks in advance for any help

Answer 1

We can simplify the expression a bit by including all the rows in the second argument to reduce - there's no reason to pass the last row as third parameter (the starting value) of reduce .

Then, it really helps to give your variables meaningful names, which the original code badly fails to do.

So, this becomes:

from functools import reduce

def maxPathSum(rows):
    return reduce(
        lambda sums, upper_row: [cell + max(sum_left, sum_right) 
                                 for (cell, sum_left, sum_right) 
                                 in zip(upper_row, sums, sums[1:])],
        reversed(rows)
    )

On the first iteration, sums will be the last row, and upper_row the one over it.

The lambda will calculate the best possible sums by adding each value of the upper row with the largest value of sums to its left or right.

It zips the upper row with the sums (the last sum won't be used, as there is one too much), and the sums shifted by one value. So, zip will provide us with a triplet (value from upper row ( cell ), sum underneath to its left ( sum_left ), sum underneath to its right ( sum_right ). The best possible sum at this point is our current cell + the largest of theses sums.

The lambda returns this new row of sums, which will be used as the first parameter of reduce ( sums ) on the next iteration, while upper_row becomes the next row in reversed(rows) .

In the end, reduce returns the last row of sums, which contains only one value, our best possible total:

[53]

Answer 2

you can spell out the lambda function so it can print. does this help you understand?

t =  [[5],[3, 6],[8, 14, 7],[4, 9, 2, 0],[9, 11, 5, 2, 9],[1, 3, 8, 5, 3, 2]]
def g( xs, ys):
    ans=[a + max(b, c) for (a, b, c) in zip(ys, xs, xs[1:])]
    print(ans)
    return ans
def maxPathSum(rows):
    return reduce(
        g,
        reversed(rows[:-1]), rows[-1]
    )
maxPathSum(t)