def select(data, epsilon, measurement_log, cliques=[]):
engine = FactoredInference(data.domain, iters=1000)
est = engine.estimate(measurement_log)
weights = {}
candidates = list(itertools.combinations(data.domain.attrs, 2))
for a, b in candidates:
xhat = est.project([a, b]).datavector()
x = data.project([a, b]).datavector()
weights[a, b] = np.linalg.norm(x - xhat, 1)
T = nx.Graph()
T.add_nodes_from(data.domain.attrs)
ds = DisjointSet()
for e in cliques:
T.add_edge(*e)
ds.union(*e)
r = len(list(nx.connected_components(T)))
for i in range(r - 1):
candidates = [e for e in candidates if not ds.connected(*e)]
wgts = np.array([weights[e] for e in candidates])
idx = permute_and_flip(wgts, epsilon / (r - 1), sensitivity=1.0)
e = candidates[idx]
T.add_edge(*e)
ds.union(*e)
return list(T.edges)
def kruskal(self) -> Set[Tuple[int]]:
edge_queue = []
for e, cost in self.edges.items():
heapq.heappush(edge_queue, (cost, e))
vertex_set = DisjointSet()
for v in self.vertexes:
vertex_set.find(v)
known_edges = set()
while len(list(vertex_set.itersets())) > 1:
cost, edge = heapq.heappop(edge_queue)
if not vertex_set.connected(*edge):
known_edges.add(tuple(sorted(list(edge))))
vertex_set.union(*edge)
return known_edges
def compute_must_alias(self):
pointsto_map = self.table.pointsto_map()
variables = pointsto_map.keys()
alias_sets = DisjointSet()
print(f"\t\t#Variables= {len(variables)}")
"""A O(N logN) algorithm to unify variables. Brute-force approach matches (u,v) and unifies them if pt(u) = pt(v).
This approach maintains a list of visited_heap_objects which maps the integer representation of set of heap
objects. If a matching heap objects is found in the visited_heap_objects then the variables are unified,
otherwise it updates the visited_heap_objects."""
visited_heap_objects = defaultdict()
for v_i in variables:
heap_objs = int(pointsto_map[v_i])
if heap_objs in visited_heap_objects.keys():
v_j = visited_heap_objects[heap_objs]
if not alias_sets.connected(v_i, v_j):
alias_sets.union(v_i, v_j)
else:
alias_sets.find(v_i)
visited_heap_objects[heap_objs] = v_i
return alias_sets.itersets()
def minimum_distance(n, x, y):
'''
Implements the Kruskal's algorithm and builds a minimum spanning tree (MST) that spans all n vertices represented by coordinates x, y
Calculates and returns the length of the MST
Input: n = number of vertices, a list of x coordinates (x) and y coordinates (y) with each pair (x,y) represents a vertex
Output: length of the MST
'''
result = 0
v, heap = build_edges(n, x, y)
ds = DisjointSet()
while heap:
min_edge = heappop(heap)
w = min_edge[0]
u = min_edge[1]
v = min_edge[2]
if not ds.connected(min_edge[1], min_edge[2]):
ds.union(u, v)
result += w
return result
def connect(points_dict):
points = list(points_dict.values())
pdict = {}
for i, p in enumerate(points):
pdict[p.id_word] = i
cur_cluster = 0
q = LifoQueue()
clusters = [-1] * len(points)
for i, sp in enumerate(points):
if clusters[i] == -1:
q.put(i)
while not q.empty():
cur = q.get()
clusters[cur] = cur_cluster
nxts = [conn.to_op for conn in \
points[cur].connections_outbound] \
+ [conn.from_op for conn in \
points[cur].connections_inbound]
for nxt in nxts:
if nxt not in pdict:
continue
ni = pdict[nxt]
if clusters[ni] != -1:
continue
q.put(ni)
cur_cluster += 1
clst = [[] for i in range(cur_cluster)]
for i in range(len(points)):
clst[clusters[i]].append(i)
#print(f"clust: {len(clst)}")
#print(f"{len(points)} ? {sum([len(c) for c in clst])}")
ds = DisjointSet()
for c1 in range(len(clst)):
min_dist = np.inf
best_i1 = 0
best_i2 = 0
best_c2 = 0
for i1 in clst[c1]:
for c2 in range(len(clst)):
if not ds.connected(c1, c2):
for i2 in clst[c2]:
dist = norm(np.array(points[i1].gps) \
- np.array(points[i2].gps))
if (dist < min_dist):
min_dist = dist
best_i1 = i1
best_i2 = i2
best_c2 = c2
#print(min_dist)
if min_dist <= 8000:
ds.union(c1, best_c2)
conn = Connection(points[best_i1].id_word, points[best_i2].id_word,
0, 0, "dummy")
points[best_i1].connections_outbound.append(conn)
points[best_i2].connections_inbound.append(conn)
else:
pass
# -*- coding: utf-8 -*-
"""
Created on Fri Jan 17 17:05:21 2020
@author: wyue
"""
from disjoint_set import DisjointSet
class A():
def __init__(self, a):
A.v = a
ds = DisjointSet()
ds.find(1)
ds.find(2)
ds.find(3)
ds.find(4)
print(ds.connected(1, 2))
ds.union(1, 2)
print(ds.connected(1, 2))
####print all unique sets
allsets = list(ds.itersets())
print(allsets)
print("Num of sets:", len(allsets))
class Hex():
def __init__(self, boardsize):
self.boardsize = boardsize
self.board = np.zeros(boardsize**2)
self.start_player = 1
self.legal_moves = [
-1, 1, -boardsize, boardsize, -(boardsize - 1), boardsize - 1
]
self.executedMoves = []
self.disjoint_set1 = DisjointSet()
self.disjoint_set2 = DisjointSet()
def get_moves(self):
return np.where(self.board == 0)[0]
def get_current_player(self):
if (len(self.executedMoves) % 2) == 0:
return self.start_player
else:
return self.opposite_player(self.start_player)
def opposite_player(self, player):
return 2 if player == 1 else 1
def get_winner(self):
if (len(self.executedMoves) % 2) == 0:
return self.opposite_player(self.start_player)
else:
return self.start_player
def get_result(self):
winner = self.get_winner()
if self.is_finished():
if self.start_player == winner:
return 1
else:
return -1
print("The game is not finished, somethings wrong")
def get_neighbors(self, position, player):
neighbors = set()
for move in self.legal_moves:
if self.check_bounds(position, move):
value = self.get_edge(position, move, player)
if value != None:
neighbors.add(value)
continue
if (position + move) < 0 and player == 1:
value = self.get_edge(position, move, player)
neighbors.add(value)
continue
try:
if self.has_neighbor(position, move,
player) and position + move >= 0:
neighbors.add(position + move)
except IndexError:
value = self.get_edge(position, move, player)
if value != None:
neighbors.add(value)
return neighbors
def has_neighbor(self, position, move, player):
return self.board[position + move] == player
def check_bounds(self, position, move):
diff = abs(((position + move) % self.boardsize) -
position % self.boardsize) < 2
return not diff
def get_edge(self, position, move, player):
if (position + move) < 0 and player == 1:
return self.boardsize**2 + 1
if position + move > self.boardsize**2 - 1 and player == 1:
return self.boardsize**2 + 2
if self.leftedge(position, move) and player == 2:
return self.boardsize**2 + 3
if self.rightedge(position, move) and player == 2:
return self.boardsize**2 + 4
else:
return None
def leftedge(self, position, move):
diff = (((position + move) % self.boardsize) -
position % self.boardsize)
return not diff < 2
def rightedge(self, position, move):
diff = (((position + move) % self.boardsize) -
position % self.boardsize)
return not diff > -2
def execute_move(self, move):
player = self.get_current_player()
neighbors = self.get_neighbors(move, player)
ds = self.disjoint_set1 if player == 1 else self.disjoint_set2
for neighbor in neighbors:
ds.union(neighbor, move)
self.executedMoves.append(move)
np.put(self.board, move, player)
def is_finished(self):
if self.disjoint_set1.connected((self.boardsize**2 + 1),
(self.boardsize**2 + 2)):
return True
if self.disjoint_set2.connected((self.boardsize**2 + 3),
(self.boardsize**2 + 4)):
return True
else:
return False
def __deepcopy__(self, memo):
new = Hex(self.boardsize)
for move in self.executedMoves:
new.execute_move(move)
return new
def test_play(self):
while not self.is_finished():
possibleMoves = self.get_moves()
if len(possibleMoves) == 0:
print(self.board)
print(np.reshape(self.board, (4, 4)))
print(self.executedMoves)
print(self.disjoint_set1)
print(self.disjoint_set2)
move = random.choice(possibleMoves)
print("Move: ", move)
self.execute_move(move)
winner = self.get_winner()
print("Finished: ", self.is_finished())
print("The winner is {}".format(winner))
print(self.disjoint_set1)
print(self.disjoint_set2)
from disjoint_set import DisjointSet
ds = DisjointSet()
n = int(input())
for i in range(n):
buf = input()
cmd, a, b = buf.split()
if cmd == 'union':
ds.union(a, b)
elif cmd == 'compare':
str_n = len(a) // 4
same = True
for i in range(str_n):
if not ds.connected(a[4 * i:4 * (i + 1)], b[4 * i:4 * (i + 1)]):
same = False
break
print(same)
