使用遞歸從大型dict構建子dict

Question

我有一本字典，將親子衰變鏈中的各種物種聯系在一起。 例如：

d = {
    'A':{'daughter':['B']},
    'B':{'daughter':['C']},
    'C':{'daughter':['D']},
    'D':{'daughter':['None']},
    'E':{'daughter':['F']},
    'F':{'daughter':['G']},
    'G':{'daughter':['H']},
    'H':{'daughter':[None]}
}

在此詞典中，頂級鍵是“父級”，“子級”（即父級在鏈中的衰變）被定義為附加到父級鍵的詞典中的key：value項。 如果None為女兒提供任何禮物，則視為鏈的末端。

我想要一個函數根據用戶輸入的起始父級返回一個子詞典，該子詞典包含鏈中的項目。 我還想知道每個項目在鏈中的位置。 在子詞典中，這可以是第二字段（ 'position' ）。

例如，如果用戶想從“ A”開始鏈，我希望函數返回：

{'A':{'position':1, 'daughter':['B']},
 'B':{'position':2, 'daughter':['C']},
 'C':{'position':3, 'daughter':['D']},
 'D':{'position':4, 'daughter':['None']}}

同樣，如果起始值為'E'，我希望它返回：

{'F':{'position':1, 'daughter':['G']},
 'G':{'position':3, 'daughter':['H']},
 'H':{'position':4, 'daughter':['None']}}

當鏈接是一對一的鏈接時，這相對容易，即一個項目分解為另一個，然后分解為另一個，等等。

如果我現在使用一個更復雜的示例，如下所示，您可以看到“ B”實際上衰減為“ C”和“ D”，並且從那里開始，鏈條是分開的。

A => B => C => E => G和A => B => D => F => H

d = {
    'A':{'daughter':['B']},
    'B':{'daughter':['C', 'D']},
    'C':{'daughter':['E']},
    'D':{'daughter':['F']},
    'E':{'daughter':['G']},
    'F':{'daughter':['H']},
    'G':{'daughter':[None]},
    'H':{'daughter':[None]}
}

在這種情況下，我想要一個函數返回以下輸出。 您會注意到，由於兩條鏈的轉移，位置值接近水平曲線中的水平，例如C = 3和D = 4，但並不完全相同。 我不想一直遵循C鏈，然后再重復D鏈。

{'A':{'position':1, 'daughter':['B']},
 'B':{'position':2, 'daughter':['C']},
 'C':{'position':3, 'daughter':['E']},
 'D':{'position':4, 'daughter':['F']}
 'E':{'position':5, 'daughter':['G']}
 'F':{'position':6, 'daughter':['H']}
 'G':{'position':8, 'daughter':['None']}
 'H':{'position':9, 'daughter':['None']}
}

有什么想法嗎？ 該功能應能夠應對鏈中多個轉移。

標記

Answer 1

如果您不想從C一直走下去，那么廣度優先搜索可能會有所幫助。

def bfs(d, start):
    answer = {}
    queue = [start]
    head = 0

    while head < len(queue):
        # Fetch the first element from queue
        now = queue[head]
        answer[now] = {
            'position': head+1,
            'daughter': d[now]['daughter']
        }

        # Add daughters to the queue
        for nxt in d[now]['daughter']:
            if nxt == None:
                continue
            queue.append(nxt)

        head += 1

    return answer

d = {
    'A': {'daughter': ['B']},
    'B': {'daughter': ['C', 'D']},
    'C': {'daughter': ['E']},
    'D': {'daughter': ['F']},
    'E': {'daughter': ['G']},
    'F': {'daughter': ['H']},
    'G': {'daughter': [None]},
    'H': {'daughter': [None]}
}

print(bfs(d, 'A'))