问在字典列表中对值进行分组，以便使用Python为每个值创建具有组号的新字典？

EN

d = {1: [4], 2: [3, 5], 3: [2, 5], 4: [1, 6], 5: [2, 3], 6: [4, 8], 7: [9, 10], 8: [6, 11], 9: [7, 10], 10: [7, 9], 11: [8]}


class MSet(object):
    def __init__(self, p):
        self.val = p
        self.p = self
        self.rank = 0

def parent_of(x): # recursively find the parents of x
    if x.p == x:
        return x.val
    else:
        return parent_of(x.p)

def make_set(x):
    return MSet(x)

def find_set(x):
    if x != x.p:
        x.p = find_set(x.p)
    return x.p

def link(x,y):
    if x.rank > y.rank:
        y.p = x
    else:
        x.p = y
        if x.rank == y.rank:
            y.rank += 1

def union(x,y):
    link(find_set(x), find_set(y))

vertices = {k: make_set(k) for k in d.keys()}
edges = []

for k,u in vertices.items():
    for v in d[k]:
        edges.append((u,vertices[v]))

# do disjoint set union find similar to kruskal's algorithm
for u,v in edges:
    if find_set(u) != find_set(v):
        union(u,v)

# resolve the root of each disjoint set
parents = {}

# generate set of parents

set_parents = set() 

for u,v in edges:
    set_parents |= {parent_of(u)}
    set_parents |= {parent_of(v)}

# make a mapping from only parents to A-Z, to allow up to 26 disjoint sets
letters = {k : chr(v) for k,v in zip(set_parents, list(range(65,91)))}

for u,v in edges:
    parents[u.val] = letters[parent_of(u)]
    parents[v.val] = letters[parent_of(v)]

print(parents)

rpg711$ python disjoint_set_union_find 
{1: 'C', 2: 'B', 3: 'B', 4: 'C', 5: 'B', 6: 'C', 7: 'A', 8: 'C', 9: 'A', 10: 'A', 11: 'C'}

sorted(d.items(), key=lambda k: k[0])
[(1, 'B'), (2, 'C'), (3, 'C'), (4, 'B'), (5, 'C'), (6, 'B'), (7, 'A'), (8, 'B'), (9, 'A'), (10, 'A'), (11, 'B')]

dict22 = {1: [4], 2: [3, 5], 3: [2, 5], 4: [1, 6], 5: [2, 3], 6: [4, 8], 7: [9, 10], 8: [6, 11], 9: [7, 10], 10: [7, 9], 11: [8]}



def connected_nodes(dict34):
    final=[]
    for i,j in dict34.items():
        def recursive_approach(dict1, tem, data,check=[], dict_9={}):
            if data!=None:
                dict_9.update({data:dict22[data]})

            dict_9.update({tem: dict1[tem]})


            check.append(tem)
            final.append(dict_9)
            if check.count(tem) > 1:
                return 0

            for i, j in dict1.items():
                if tem in dict1:
                    return recursive_approach(dict1, tem=dict1[tem][-1],data=None)


        recursive_approach(dict22, tem=j[-1],data=i)
    return final


bew=[]
for i in connected_nodes(dict22):
    bew.append(list(i.keys()))


new_bew=bew[:]
final_result=[]
for j,i in enumerate(bew):
    for m in new_bew:

        if set(i).issubset(set(m)) or set(m).issubset(set(i)):
            if len(i)>len(m):
                final_result.append(tuple(i))
                new_bew.remove(m)

            else:
                final_result.append(tuple(m))


        else:
            pass
print(set(final_result))

{(2, 3, 5), (9, 10, 7), (1, 4, 6, 8, 11)}

from string import ascii_uppercase as uppercase

import networkx as nx
import matplotlib.pyplot as plt


%matplotlib inline


d = {
    1: [4], 2: [3, 5], 3: [2, 5], 4: [1, 6], 5: [2, 3], 6: [4, 8], 
    7: [9, 10], 8: [6, 11], 9: [7, 10], 10: [7, 9], 11: [8]
}

G = nx.from_dict_of_lists(d)

# Label sub-groups
sub_graphs = list(nx.connected_component_subgraphs(G))
{val: label for label, sg in zip(uppercase, sub_graphs) for val in sg.nodes()}
# {1: 'A', 2: 'B', 3: 'B', 4: 'A', 5: 'B', 6: 'A', 7: 'C', 8: 'A', 9: 'C', 10: 'C', 11: 'A'}

# Printed subgroups
for label, sg in zip(uppercase, sub_graphs):
    print("Subgraph {}: contains {}".format(label, sg.nodes()))

# Subgraph A: contains [8, 1, 11, 4, 6]
# Subgraph B: contains [2, 3, 5]
# Subgraph C: contains [9, 10, 7]

{label: sg.nodes() for label, sg in zip(uppercase, sub_graphs)}
# {'A': [8, 1, 11, 4, 6], 'B': [2, 3, 5], 'C': [9, 10, 7]}

# Plot graphs in networkx (optional)
nx.draw(G, with_labels=True)