Question

这个问题是我在math.stackoverflow上发布的query的扩展。现在，我了解了算法的工作原理，我正在尝试在Python中实现它。

我将NetworkX用于图形表示。我在假设输入图已连接的情况下，尝试通过将第二种情况和第三种情况下的肢体组合在一起来缩短算法。

我计划使用min和max来检索每个组件的最大树深度的最小值。这是我的代码：

def td(G):                                  # G is an input connected graph
    G_copy = G.copy()
    nodesList = list(G.nodes)

    if (len(G_copy.nodes) == 1):
        depth = 1                           # Base case for the recursion
    else:
#        G_copy.remove_node(next(iter(nodesList), None))
#        depth = 1 + min(max([iter], key), key)  # Recursive step

    return depth

我的问题是：

能否以上述方式嵌套min和max来缩短算法？
无论哪种方式，如何实现？

Answer 1

这是解决方案，您将最小值和最大值作为参数传递给递归函数，如下所示：

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


def get_min_max(my_list, min_val=False, max_val=False):
    for num in my_list:
        if isinstance(num, list):
            min_val, max_val = get_min_max(num, min_val, max_val)
        else:
            if min_val is False or num < min_val:
                min_val = num
            if max_val is False or num > max_val:
                max_val = num
    return min_val, max_val


min_num, max_num = get_min_max(my_array)

print(min_num, max_num)

输出

0 9

Answer 2

如果有人感兴趣，这是该算法的有效实现。它没有嵌套的min和max，但是由于O（2 ^ n）的复杂性，它可以工作并且花费很长时间。

def td(G):

    copG = G.copy()
    depth = 0

    if (len(copG.nodes) == 1):
        depth = 1

    elif (len(copG.nodes) > 1 and nx.is_connected(copG)):
        someList = []

        for v in list(copG.nodes)[:-1]:
            edges = list(copG.edges(v))
            copG.remove_node(v)            
            someList.append(td(copG))
            copG.add_node(v)
            copG.add_edges_from(edges)

        depth = 1 + min(someList)

    elif(len(copG.nodes) > 1 and not nx.is_connected(copG)):
        someList2 = []
        for i in (copG.subgraph(c) for c in nx.connected_components(copG)):
            someList2.append(td(i))

        depth = max(someList2)


    return depth

Python：如何使用嵌套的min和max函数在Python中进行递归？

2 个答案: