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)