Question

我有以下图形：

graph = {0 : {5:6, 4:8},
1 : {4:11},
2 : {3: 9, 0:12},
3 : {},
4 : {5:3},
5 : {2: 7, 3:4}}

我正在尝试返回此图中具有最高值的键。在这种情况下，由于键2的最大值为12，因此预期输出为2。

对于我如何实现这一目标的任何帮助，将不胜感激。

Answer 1

找到最大值为最大值的键：

max((k for k in graph), key=lambda k: max(graph[k].values(), default=float("-inf")))

空元素被可笑的最大值取消资格。另外，您也可以预先过滤这些键：

max((k for k in graph if graph[k]), key=lambda k: max(graph[k].values()))

Answer 2

假设它们都是正数

graph = {0 : {5:6, 4:8},
         1 : {4:11},
         2 : {3: 9, 0:12},
         3 : {},
         4 : {5:3},
         5 : {2: 7, 3:4}}

highestKey = 0
max = 0

for key, value in graph.items():
    for key2, value2 in value.items():
        if (max < value2):
            max = value2
            highestKey = key

print(highestKey)

Answer 3

您还可以为每个键创建(max_weight, key)元组，并获取其中的最大值：

max_val = max((max(e.values()), k) for k, e in graph.items() if e)
# (12, 2)

print(max_val[1])
# 2

请注意，此处key不需要自定义max函数，因为元组中的第一个值是我们希望max考虑的值。

Answer 4

递归解决方案如下。不对树的深度做出假设。仅假定数据类型为int，float或dict

import type 

def getLargest(d):
    def getLargestRecursive(d):    
        if type(d) == “dict”:
            getLargestRecursive(d)
        elif not largest or d > largest:
              largest = d
    largest = None
    getLargestRecursive(d)
    return largest


largestValues = [getLargest(k) for k in graph.keys]

answer = largestValues.index(max(largestValues))

Answer 5

您还可以使用dict理解来平整字典，然后打印最大key，

graph = {0 : {5:6, 4:8},
         1 : {4:11},
         2 : {3: 9, 0:12},
         3 : {},
         4 : {5:3},
         5 : {2: 7, 3:4}}

flat_dcit = {k:a for k, v in graph.items() for a in v.values()}
print(max(flat_dcit.keys(), key=(lambda k: flat_dcit[k])))

# output,
2

Answer 6

您还可以尝试将字典拼合为元组列表，然后取第二个值最高的元组的最大值：

from operator import itemgetter

graph = {
    0: {5: 6, 4: 8},
    1: {4: 11},
    2: {3: 9, 0: 12},
    3: {},
    4: {5: 3},
    5: {2: 7, 3: 4},
}

result = max(((k, v) for k in graph for v in graph[k].values()), key=itemgetter(1))

print(result)
# (2, 12)

print(result[0])
# 2

最高返回键

6 个答案: