class DsuGraph:
    def __init__(self, n):
        self.n = n
        self.dsu = DSU(n)
        self.edges = dict()

    def refine(self, u, v):
        u, v = (u, v) if u < v else (v, u)
        if (u, v) not in self.edges:
            self.edges[(u, v)] = 0
        return u, v

    def add_edge(self, u, v):
        u, v = self.refine(u, v)
        self.edges[(u, v)] += 1
        
    def remove_edge(self, u, v):
        u, v = self.refine(u, v)
        self.edges[(u, v)] -= 1
        if self.edges[(u, v)] < 0:
            print "Non-existing edge is deleted"
            raise

    def cc(self):
        for edge in self.edges.keys():
            if self.edges[edge] > 0:
                u, v = edge
                self.dsu.union(u - 1, v - 1)
        result = dict()
        for i in xrange(0, self.n):
            p = self.dsu.find(i)
            if p not in result:
                result[p] = []
            result[p].append(i + 1)
        return sorted([sorted(result[v]) for v in result.keys()])
class DsuGraph:
    def __init__(self, n):
        self.n = n
        self.dsu = DSU(n)
        self.edges = dict()

    def refine(self, u, v):
        u, v = (u, v) if u < v else (v, u)
        if (u, v) not in self.edges:
            self.edges[(u, v)] = 0
        return u, v

    def add_edge(self, u, v):
        u, v = self.refine(u, v)
        self.edges[(u, v)] += 1

    def remove_edge(self, u, v):
        u, v = self.refine(u, v)
        self.edges[(u, v)] -= 1
        if self.edges[(u, v)] < 0:
            print "Non-existing edge is deleted"
            raise

    def cc(self):
        for edge in self.edges.keys():
            if self.edges[edge] > 0:
                u, v = edge
                self.dsu.union(u - 1, v - 1)
        result = dict()
        for i in xrange(0, self.n):
            p = self.dsu.find(i)
            if p not in result:
                result[p] = []
            result[p].append(i + 1)
        return sorted([sorted(result[v]) for v in result.keys()])
Ejemplo n.º 3
0
    def cc(self):
        cur_cc = dict([(i, [i]) for i in xrange(self.n)])
        dsu = DSU(self.n)
        for lev in xrange(self.k):
            # computing sketches for level lev
            sketch_sum = dict()
            for key in cur_cc.keys():
                component = cur_cc[key]
                sketch_sum[key] = self.sketch[lev][component[0]]
                for j in xrange(1, len(component)):
                    add_sketch = self.sketch[lev][component[j]]
                    sketch_sum[key] = sketch_sum[key].sum(add_sketch)

            # sampling and union
            for key in sketch_sum.keys():
                edge_num, val = sketch_sum[key].sample()
                if (edge_num, val) != (0, 0):
                    u, v = self.decode_edge(edge_num)
                    print(u, v, edge_num, self.n)
                    dsu.union(u, v)

            # forming new components
            cur_cc = dict()
            for i in xrange(self.n):
                parent = dsu.find(i)
                if parent not in cur_cc:
                    cur_cc[parent] = []
                cur_cc[parent].append(i)

        return sorted(
            [sorted([u + 1 for u in cur_cc[k]]) for k in cur_cc.keys()])
    def cc(self):
        cur_cc = dict([(i, [i]) for i in xrange(self.n)])
        dsu = DSU(self.n)
        for lev in xrange(self.k):
            # computing sketches for level lev
            sketch_sum = dict()
            for key in cur_cc.keys():
                component = cur_cc[key]
                sketch_sum[key] = self.sketch[lev][component[0]]
                for j in xrange(1, len(component)):
                    add_sketch = self.sketch[lev][component[j]]
                    sketch_sum[key] = sketch_sum[key].sum(add_sketch)

            # sampling and union
            for key in sketch_sum.keys():
                edge_num, val = sketch_sum[key].sample()
                if (edge_num, val) != (0, 0):
                    u, v = self.decode_edge(edge_num)
                    print (u, v, edge_num, self.n)
                    dsu.union(u, v)

            # forming new components
            cur_cc = dict()
            for i in xrange(self.n):
                parent = dsu.find(i)
                if parent not in cur_cc:
                    cur_cc[parent] = []
                cur_cc[parent].append(i)

        return sorted([sorted([u + 1 for u in cur_cc[k]]) for k in cur_cc.keys()])
Ejemplo n.º 5
0
def kruskal(graph):
    """
    Use union-find
    """
    all_edges = []
    for start in graph:
        for tail in graph[start]:
            all_edges.append(Edge(graph[start][tail], start, tail))
    sorted_edges = sorted(all_edges)

    dsu = DSU(len(graph) + 1)
    result = []

    for edge in sorted_edges:
        if dsu.find_set(edge.start) != dsu.find_set(edge.end):
            dsu.union_sets(edge.start, edge.end)
            result.append(edge)
    print(result)
Ejemplo n.º 6
0
def clustering(graph, k):
    """
    Use union-find
    """
    all_edges = []
    for start in graph:
        for tail in graph[start]:
            all_edges.append(Edge(graph[start][tail], start, tail))
    sorted_edges = sorted(all_edges)

    dsu = DSU(len(graph) + 1)
    result = []

    num_clusters = len(graph)
    for edge in sorted_edges:
        if dsu.find_set(edge.start) != dsu.find_set(edge.end):
            if num_clusters == k:
                print(edge)
                return
            dsu.union_sets(edge.start, edge.end)
            result.append(edge)
            num_clusters -= 1
 def __init__(self, n):
     self.n = n
     self.dsu = DSU(n)
     self.edges = dict()
Ejemplo n.º 8
0
def eller_optimized(maze_graphics, maze):

    dsu = DSU()
    dsu.set_size(maze.x_size * maze.y_size)

    #processing the rows except the last
    for y in range(1, maze.y_size):

        for x in range(1, maze.x_size):
            #if random > 0.5 delete wall
            if dsu.find(x - 1 + (y - 1) * maze.x_size) != dsu.find(
                    x + (y - 1) * maze.x_size) and random.random() > 0.5:
                dsu.union(x - 1 + (y - 1) * maze.x_size,
                          x + (y - 1) * maze.x_size)
                maze.set_wall(x, y, x + 1, y, ' ')

        classes = {}
        classes_count = {}

        for x in range(1, maze.x_size + 1):
            current_class = dsu.find(x - 1 + (y - 1) * maze.x_size)
            if current_class not in classes:
                classes[current_class] = [x]
                classes_count[current_class] = 0
            else:
                classes[current_class].append(x)
            #maze.set_cell(x, y, current_class)

        if maze_graphics:
            input("press enter to continue")
            maze_graphics.redraw(maze)

        for x in range(1, maze.x_size + 1):
            #if random > 0.5 delete wall
            if random.random() > 0.5:
                dsu.union(x - 1 + (y - 1) * maze.x_size,
                          x - 1 + y * maze.x_size)
                maze.set_wall(x, y, x, y + 1, ' ')
                current_class = dsu.find(x - 1 + (y - 1) * maze.x_size)
                classes_count[current_class] += 1

        for key, val in classes_count.items():
            if val == 0:
                x = random.choice(classes[key])
                dsu.union(x - 1 + (y - 1) * maze.x_size,
                          x - 1 + y * maze.x_size)
                maze.set_wall(x, y, x, y + 1, ' ')
                current_class = maze.get_cell(x, y)
        '''
        for x in range(1, maze.x_size + 1):
            current_class = dsu.find(x-1 + y*maze.x_size)
            maze.set_cell(x, y + 1, current_class)
        '''

        if maze_graphics:
            input("press enter to continue")
            maze_graphics.redraw(maze)

    #the last row processing
    y = maze.y_size
    for x in range(1, maze.x_size):
        if dsu.find(x - 1 +
                    (y - 1) * maze.x_size) != dsu.find(x +
                                                       (y - 1) * maze.x_size):
            maze.set_wall(x, y, x + 1, y, ' ')
            dsu.union(x - 1 + (y - 1) * maze.x_size, x + (y - 1) * maze.x_size)
    '''
    for x in range(1, maze.x_size + 1):
        current_class = dsu.find(x-1 + (y-1)*maze.x_size)
        maze.set_cell(x, y, current_class)
    '''

    if maze_graphics:
        input("press enter to continue")
        maze_graphics.redraw(maze)
 def __init__(self, n):
     self.n = n
     self.dsu = DSU(n)
     self.edges = dict()