Python DP问题 数塔问题

问题描述：

在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的：
有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和 最大是多少？

解决方法：

# -*- coding: utf-8 -*-

# [9]
# [12, 15]
# [10, 6, 8]
# [2, 18, 9, 5]
# [19, 7, 10, 4, 16]

# DP matrix Record
def get_max_num(num_tree):
    row = len(num_tree)

    DP_tree = list()

    for row_count, row_item in enumerate(num_tree):
        DP_tree.append(list())
        for column_count in row_item:
            DP_tree[row_count].append(0)

    print "DP tree is {}".format(DP_tree)


    DP_tree[0][0] = num_tree[0][0]

    for row_index in range(1, row):

        if len(DP_tree[row_index]) == 1:
            DP_tree[row_index][0] = DP_tree[row_index - 1][0] + num_tree[row_index][0]

        elif len(DP_tree[row_index]) >= 2:
            DP_tree[row_index][0] = DP_tree[row_index - 1][0] + num_tree[row_index][0]
            DP_tree[row_index][-1] = DP_tree[row_index - 1][-1] + num_tree[row_index][-1]

        print ("-------------------------")
        for row_item in DP_tree:
            print row_item

    for row_index in range(row):

        if len(DP_tree[row_index]) < 3:
            continue

        else:
            for column_index in range(1, len(DP_tree[row_index])-1):

                left = DP_tree[row_index - 1][column_index - 1] + num_tree[row_index][column_index]
                right = DP_tree[row_index - 1][column_index] + num_tree[row_index][column_index]

                DP_tree[row_index][column_index] = max(left, right)

                print ("-------------------------")
                for row_item in DP_tree:
                    print row_item

    # get max value
    max_value = 0

    for item in DP_tree[-1]:

        if item > max_value:
            max_value = item

    print "max value is {}".format(max_value)
    return max_value


if __name__ == '__main__':

    test_tree = [[1],
                 [5],
                 [7],
                 [3, 8],
                 [8, 1, 0],
                 [2, 7, 4, 4],
                 [4, 5, 2, 6, 5]]

    get_max_num(test_tree)