def clustering(graph, n_clusters=4):
"""
args: graph
graph = {
u: [(v_1, w_1), (v_2, w_2), ...]
}
"""
uf = UF(len(graph))
t = set()
cost = 0
edges = []
for u in graph.keys():
for v, w in graph[u]:
edges.append((u, v, w))
edges = sorted(edges, key=lambda x: x[2])
edges_index = 0
#while len(set(uf.parent)) > n_clusters and edges_index < len(edges):
while len(t) != len(graph.keys()) - n_clusters:
# print(uf.parent)
u, v, w = edges[edges_index]
if uf.find(u - 1) != uf.find(v - 1):
t = t.union([tuple(sorted([u, v]))])
uf.union(u - 1, v - 1)
edges_index += 1
max_space = calculate_max_distance(edges, uf)
return max_space
def clustering(n, input_data):
"""
args: input_data
input_data = {'0000100110': [1,2], '0110101100': [3,4] ,
'1000100110' : [5], ... }
"""
uf = UF(n)
input_dict = {k: v for k, v in input_data.items()}
# Merge all 0 distance
for bin_str, u_vertices in input_dict.items():
try:
input_dict[bin_str]
except KeyError:
continue
else:
v_vertices = input_dict[bin_str]
for u in u_vertices:
for v in v_vertices:
if (uf.find(u - 1) != uf.find(v - 1)):
uf.union(u - 1, v - 1)
# Merge all 1 distance
for bin_str, u_vertices in input_dict.items():
one_comb = compute_one_distance(bin_str)
for node in one_comb:
try:
input_dict[node]
except KeyError:
continue
else:
v_vertices = input_dict[node]
for u in u_vertices:
for v in v_vertices:
if (uf.find(u - 1) != uf.find(v - 1)):
uf.union(u - 1, v - 1)
# Merge all 2 distances
for bin_str, u_vertices in input_dict.items():
two_comb = compute_two_distance(bin_str)
for node in two_comb:
try:
input_dict[node]
except KeyError:
continue
else:
v_vertices = input_dict[node]
for u in u_vertices:
for v in v_vertices:
if uf.find(u - 1) != uf.find(v - 1):
uf.union(u - 1, v - 1)
return len(uf.get_clusters())
def kruskal_uf(graph):
uf = UF(len(graph))
t = set()
cost = 0
edges = []
for u in graph.keys():
for v, w in graph[u]:
edges.append((u, v, w))
edges = sorted(edges, key=lambda x: x[2])
for u, v, w in edges:
if uf.find(u - 1) != uf.find(v - 1):
t = t.union([tuple(sorted([u, v]))])
uf.union(u - 1, v - 1)
cost += w
return cost
def heap_clustering(graph):
"""
args: graph
graph = {
u: [(v_1, w_1), (v_2, w_2), ...]
}
"""
uf = UF(len(graph))
edges = []
for u in graph.keys():
for v, w in graph[u]:
heapq.heappush(edges, (w, u, v))
edges_union = []
while len(edges) > 0:
w, u, v = heapq.heappop(edges)
if uf.find(u - 1) != uf.find(v - 1) and w <= 2:
uf.union(u - 1, v - 1)
edges_union.append((u, v))
return len(set(uf.parent))
def __init__(self, eqs):
# TODO use eqs
# NOTE we're following nelson-oppen figure 1
self.v1 = ENode('f')
self.v2 = ENode('f')
self.v3 = ENode('a')
self.v4 = ENode('b')
self.nodes = [self.v1, self.v2, self.v3, self.v4]
self.R = UF(len(self.nodes))
self.v1.preds = []
self.v1.succs = [self.v2, self.v4]
self.v2.preds = [self.v1]
self.v2.succs = [self.v3, self.v4]
self.v3.preds = [self.v2]
self.v3.succs = []
self.v4.preds = [self.v2, self.v1]
self.v4.succs = []
def setupUF():
yield UF(10)
