Question

这将是我的输入

{1: [2, 3], 2: [1, 7], 3: [1], 7: [1]}

输出：

{1: [2, 3, 1, 7, 1], 2: [1, 7, 2, 3, 1, 7, 1, 1], 3: [1, 2, 3, 1, 7, 1],
 7: [1, 2, 3, 1, 7, 1]}

这里发生的事情是，对于每个key，value，给定values的值列表中的key将自己充当键，并且对应的值新key应附加到原始文件。

现在让我说清楚。以此为例。

simple_dict={1:[2,3],2:[7],3:[1],7:[1]}此处会输入一个密钥1，现在2，3的所有值都将作为密钥本身。因此simple_dict[2]，simple_dict[3]会被添加到原始密钥中，以便我得到1:[2,3,7,1]。对于所有键都应该这样做。

目前我试过了！

my_dict = {1:[2,3],2:[7],3:[1],7:[1]}
print(my_dict)
for k,v in my_dict.items():
    for i in v:
        my_dict[k]=my_dict[k]+my_dict[i]
print(my_dict)

输出：

{1: [2, 3], 2: [7], 3: [1], 7: [1]}
{1: [2, 3, 7, 1], 2: [7, 1], 3: [1, 2, 3, 7, 1], 7: [1, 2, 3, 7, 1]}

这很好用。但时间复杂度似乎 O（n ^ 2）

（我对时间复杂度的理解是正确的，这会是 O（n ^ 2）复杂性？还是会比那个更小？）

我尝试做的事情有更简单的方法吗？任何建议，想法都非常欢迎。

Answer 1

这很好用。但时间复杂度似乎是 O（n ²）

实际上更糟：时间复杂度为 O（n ³），因为将两个列表一起添加将在 O（n）时间，你为每个键（这是另一个 O（n））执行 O（n）时间。

然而此处还有另一个问题更新顺序很重要：因为您写入my_dict[k]这意味着如果您处理新项目，字典将会更新。这可能不预期的行为。

你能做的最好的是构造一个 O（n ²）算法（假设你没有制作函数式编程列表），因为输出可以生成一个对象大小 O（n ²），你没有太多可以做的，它是“理论上限”（除非，如前所述，你工作指向不可变数据结构的指针，但那些不再是列表。）

你可以制作一个优雅的列表理解，它将在 O（n ²）中起作用：

{k:vs+[vi for v in vs for vi in my_dict[v]] for k,vs in my_dict.items()}

这将构建：

>>> { k : vs + [vi for v in vs for vi in my_dict[v]] for k,vs in my_dict.items()}
{1: [2, 3, 1, 7, 1], 2: [1, 7, 2, 3, 1], 3: [1, 2, 3], 7: [1, 2, 3]}

它使假设表示字典列表中的所有索引都是有效的索引：这些索引在字典中。如果 not 总是如此，您可以使用以下表达式使程序更安全：

{k:vs+[vi for v in vs for vi in my_dict.get(v,())] for k,vs in my_dict.items()}

现在我们将()添加为后备值，这样当找不到密钥时，它就不会向列表中添加任何内容。

将值添加到同一字典中的键

1 个答案: