将多维列表变成树 Python

Question

我正在尝试编写一些将多维列表转换为字典树的代码。

多维列表可能是这样的。

x = [[0,2,5],[1,1,3],[2,1,1]]

列表将始终表示 NxN 网格。把它想象成这样。

0 2 5
1 1 3
2 1 1

从左上角开始，您只能从一个节点向右或向下从一个节点到另一个节点来查找它的子节点。

So 0 would have children of 2 and 1
    2 would have children of 5 and 1
        5 would have children of ...
        1 would have children of ...
    1 would have children of 1 and 2
        1 would have children of ...
        2 would have children of ...

所以这个树应该是这样的：

                                           0
                                         /    \
                                        /      \
                                       /        \
                                      /          \
                                     /            \
                                    2             1
                                   /\             /\
                                  /  \           /  \
                                 /    \         /    \
                                1      5       2      1
                               /\      |       |      /\
                              /  \     |       |     /  \
                             1   3     3       1    3    1
                             |   |     |       |    |    |
                             1   1     1       1    1    1

这是节点及其子节点的可视化树的样子，它将由以下结构中的代码表示：

 tree = {'value': 0, 'children': [
            {'value': 2, 'children': [
                {'value': 1, 'children': [
                    {'value': 1, 'children': [
                        {'value': 1, 'children': [None, None]}
                    ]},
                    {'value': 3, 'children': [
                        {'value': 1, 'children': [None, None]}
                    ]}
                ]},
                {'value': 5, 'children': [
                    {'value': 3, 'children': [
                        {'value': 1, 'children': [None, None]}
                    ]}
                ]}
            ]},
            {'value': 1, 'children': [
                {'value': 1, 'children': [
                    {'value': 3, 'children': [
                        {'value': 1, 'children': [None, None]}
                    ]},
                    {'value': 1, 'children': [
                        {'value': 1, 'children': [None, None]}
                    ]}
                ]},
                {'value': 2, 'children': [
                    {'value': 1, 'children': [
                        {'value': 1, 'children': [None, None]}
                    ]}
                ]}
            ]}
        ]}

如果有任何有效的方法可以将上述网格转变为正确方向的形状字典指导，那将非常有帮助。我试过这个：http://repl.it/6sU 没有运气，因为递归太深了，但是我想不出另一种方法来做到这一点。谢谢。

Answer 1

我将针对您遇到的实际问题发布一个解决方案，正如您在评论中提到的那样，它是找到最接近给定数字的总和，其中候选总和是通过仅移动遍历 NxN 矩阵来找到的上下左右。

def gridsums(grid, x, y, memo):
    if memo[x][y] is not None:
        return memo[x][y]

    if x == 0 and y == 0:
        sums = [0]
    elif x == 0:
        sums = gridsums(grid, x, y-1, memo)
    elif y == 0:
        sums = gridsums(grid, x-1, y, memo)
    else:
        sums = gridsums(grid, x-1, y, memo) + gridsums(grid, x, y-1, memo)

    sums = [grid[x][y] + s for s in sums]
    memo[x][y] = sums
    return sums

def gridsumsfast(grid):
    memo = []
    for row in grid:
        memo.append([])
        for cell in row:
            memo[-1].append(None)

    return gridsums(grid, len(grid[0]) - 1, len(grid) - 1, memo)

最简单的版本是完全删除“备忘录”的东西，但它实现了“动态编程”来缓存先前计算的结果并避免重复工作。其余的是一个相当简单的递归解决方案，它直接产生所有可能的总和（包括重复项）。

对于您的示例数据，结果为[11, 7, 6, 5, 4, 5]。