如何从字典中的键值对跳转以创建循环列表

Question

在我的作业中，一个循环被定义为一组从键 -> 值 -> 键跳转到返回其原始起始值的键。 例如：

d1 = {1:6, 3:1, 6:3}
cycles = [[1, 6, 3]]

因为 1:6 -> 6:3 -> 3:1，并且起始键 == 最后一个值

对于以下字典也是如此：

d1 = {1: 5, 2: 14, 3: 15, 4: 3, 5: 5, 6: 5, 
      7: 15, 8: 6, 9: 10, 10: 15, 11: 12, 
      12: 15, 13: 14, 14: 8, 15: 9}

正确排序，映射给出的周期为： [[5], [9, 10, 15]] （也因为5:5是一个完整的周期，而9:10 -> 10:15 -> 15:9）有没有办法创建一个循环来跟踪字典中的这些循环？ 我希望创建一条适用于任何随机键值字典映射的行。

cycle=[]
For k,v in d1.items():
    if k == v:
        cycle.append([k])

For k,v in mapping2.items
    if k!=v:
        if v in keys:
            start_k = k

If mapping[k] in keys:

Answer 1

这个答案解释了一种潜在的算法，但没有实现它。 如果您想自己找到算法，请停止阅读。

可能有更聪明的方法，但一种方法是。 如果您有一个带有 n 个键的 dict，那么您将需要 n 次迭代来检测所有潜在的循环。

让我们调用初始 dict d 并假设它有 N（大写 N）键/值对

1.) 复制 d cpy = dict(d)

循环长度 n=1 的初始迭代：查找 cpy 中的所有键，其中 cpy[key] == key

将这些添加到解决方案列表中并从复制的字典中删除这些条目

循环长度 n=2 的第一次迭代：通过以下方式创建一个新的 dict cpy2：为 cp 的每个键创建一个 val，即计算d[cp[key]]现在将 cpy2 分配给 cpy cpy = cpy2

现在查找 cpy 中的所有键，其中 cpy[key] == key 您知道对于这些值，您有长度为 n 的循环，如果您愿意，可以通过从 d 中的键开始并迭代 n 次来重建它们

周期长度 n=3 的第二次迭代：遵循第一次迭代的指令。

迭代直到循环长度 n == N

使用这种方法，您应该能够识别所有循环。 但是，如果您有一个长度为 n 的循环，那么您对于同一循环有 n 个解决方案。

例如，如果您有循环 [9, 10, 15] 那么您会发现： [10, 15, 9] 以及 [15, 10, 9] 因此您应该可能消除甚至永远不会存储任何解决方案，其中第一个值在循环不是值列表中的最小值

Answer 2

这应该有效。

#!/usr/bin/env python3

def get_cycles(d):
    cycles = []

    while d:
        # Keep track of keys we've iterated through in this loop
        tracked = []

        # Take the next available key
        k = next(iter(d))

        while True:
            tracked.append(k)

            # This key (the value of the previous key) must have already 
            # been deleted, meaning it was part of a cycle or lead to 
            # repetitions of an already discovered cycle
            try:
                v = d[k]
            except KeyError:
                # Always delete keys leading up to the current key too, as this
                # same loop will happen every time we land on one of these keys
                # otherwise
                for t in tracked:
                    if t in d:
                        del d[t]
                break

            # If the value of the current key was one of the keys leading up to
            # the current key, we've discovered a cycle starting from the value
            # of the current key and ending at the current key
            if v in tracked:
                cycle = tracked[tracked.index(v):]
                cycles.append(cycle)
                for c in cycle:
                    del d[c]
                break

            # If the value of the current key is a key in any of the
            # previously discovered cycles, we want to delete this sequence,
            # as we've already discovered the cycle it leads to
            if any(v in cycle for cycle in cycles):
                for t in tracked:
                    del d[t]
                break

            # Set the next key
            k = v

    return cycles


d1 = {1: 5, 2: 14, 3: 15, 4: 3, 5: 5, 6: 5, 7: 15, 8: 6, 9: 10, 10: 15, 11: 12, 12: 15, 13: 14, 14: 8, 15: 9}
d2 = {1:6, 3:1, 6:3}

print(get_cycles(d1))
print(get_cycles(d2))

Output：

[[5], [15, 9, 10]]
[[1, 6, 3]]

算法跟踪它迭代的每个键，通过将键设置为等于它自己的值来进行迭代。

如果一个key的值已经在迭代key列表中，则从迭代key列表中的那个position到最后发现了一个循环。 然后必须从字典中删除导致发现此循环的跟踪键，因为此循环已被遍历。

如果键的值是先前发现的循环之一中的键，则必须从字典中删除当前遍历的键序列，因为该序列所引导的循环已经被发现。

如果键的值不再是键本身（当键的值被测试为键时引发 KeyError），则循环中断，因为该键必须已被删除，这意味着它是循环的一部分或序列的一部分导致进入一个循环。