예제 #1
0
def compress(g: MultiGraph, t: set, compressed_node, mutate=False) -> MultiGraph:
	if not t:
		return g
	if mutate:
		gx = g
	else:
		gx = g.copy()

	tx = t
	if compressed_node in tx:
		tx = t.copy()
		tx.remove(compressed_node)
	gx.add_node(compressed_node)

	for node in tx:
		for edge in gx.edges(node):
			if edge[0] == node:
				node_2 = edge[1]
			else:
				node_2 = edge[0]
			if not (node_2 in t or node_2 == compressed_node):
				gx.add_edge(compressed_node, node_2)
		gx.remove_node(node)

	remove = set()
	for node in gx.adj[compressed_node]:
		if len(gx.adj[compressed_node][node]) >= 2:
			# Using a set to remove to avoid messing up iteration of adj
			remove.add(node)

	for node in remove:
		gx.remove_node(node)

	return gx
    def compress(self, g: MultiGraph, t: set, compressed_node, mutate=False) -> MultiGraph:
        if not t:
            return g
        if mutate:
            gx = g
        else:
            gx = g.copy()

        tx = t
        if compressed_node in tx:
            tx = t.copy()
            tx.remove(compressed_node)
        gx.add_node(compressed_node)

        for node in tx:
            for edge in gx.edges(node):
                if edge[0] == node:
                    node_2 = edge[1]
                else:
                    node_2 = edge[0]
                if not (node_2 in t or node_2 == compressed_node):
                    gx.add_edge(compressed_node, node_2)
            gx.remove_node(node)

        remove = set()
        for node in gx.adj[compressed_node]:
            if len(gx.adj[compressed_node][node]) >= 2:
                # Using a set to remove to avoid messing up iteration of adj
                remove.add(node)

        for node in remove:
            gx.remove_node(node)

        return gx
예제 #3
0
 def get_fbvs_max_size(self, g: MultiGraph, k: int) -> set:
     # we will run the algorithm 4^k times
     n = 4 ** k
     for _ in range (1, n):
         # pass a copy of g, since we need a fresh copy of g for every run
         sol = self._get_fbvs_max_size(g.copy(), k)
         if sol is not None:
             # we found a fbvs for (g,k), so we can return it right away
             return sol
     return None
예제 #4
0
 def get_fbvs_max_size(self, g: MultiGraph, k: int) -> set:
     # we will run the algorithm 4^k times
     n = 4**k
     for _ in range(1, n):
         # pass a copy of g, since we need a fresh copy of g for every run
         sol = self._get_fbvs_max_size(g.copy(), k)
         if sol is not None:
             # we found a fbvs for (g,k), so we can return it right away
             return sol
     return None
    def mif_main(self, g: MultiGraph, f: set, t) -> set:
        if f == g.nodes():
            return f
        if not f:
            g_degree = g.degree()
            g_max_degree_node = max(g_degree, key=lambda n: n[1])[0]
            if g_degree[g_max_degree_node] <= 1:
                return set(g.nodes())
            else:
                fx = f.copy()
                fx.add(g_max_degree_node)
                gx = g.copy()
                gx.remove_node(g_max_degree_node)
                mif_set1 = self.preprocess_1(g, fx, t)
                mif_set2 = self.preprocess_1(gx, f, t)
                if not mif_set1:
                    return mif_set2
                elif not mif_set2:
                    return mif_set1
                else:
                    return max(mif_set1, mif_set2, key=len)

        # Set t as active vertex
        if t is None or t not in f:
            t = next(iter(f))

        gd_over_3 = None
        gd_2 = None
        for v in g.neighbors(t):
            (gd_v, gn_v) = self.generalized_degree(g, f, t, v)
            if gd_v <= 1:
                f.add(v)
                return self.preprocess_1(g, f, t)
            elif gd_v >= 3:
                gd_over_3 = v
            else:
                gd_2 = (v, gn_v)
        if gd_over_3 is not None:
            # Cannot simply use "if gd_over_3" because v might be 0
            fx = f.copy()
            fx.add(gd_over_3)
            gx = g.copy()
            gx.remove_node(gd_over_3)
            mif_set1 = self.preprocess_1(g, fx, t)
            mif_set2 = self.preprocess_1(gx, f, t)
            if not mif_set1:
                return mif_set2
            elif not mif_set2:
                return mif_set1
            else:
                return max(mif_set1, mif_set2, key=len)
        elif gd_2 is not None:
            (v, gn) = gd_2
            fx1 = f.copy()
            fx2 = f.copy()
            fx1.add(v)
            for n in gn:
                fx2.add(n)
            gx = g.copy()
            gx.remove_node(v)
            try:
                find_cycle(gx.subgraph(fx2))
                mif_set1 = None
            except:
                mif_set1 = self.preprocess_1(gx, fx2, t)
            mif_set2 = self.preprocess_1(g, fx1, t)
            if not mif_set1:
                return mif_set2
            elif not mif_set2:
                return mif_set1
            else:
                return max(mif_set1, mif_set2, key=len)
        return None
예제 #6
0
def graph_minus_slow(g: MultiGraph, w: set) -> MultiGraph:
	gx = g.copy()
	gx.remove_nodes_from(w)
	return gx
예제 #7
0
def mif_main(g: MultiGraph, f: set, t, k: int) -> set:
	k_set = k != None
	new_k1 = new_k2 = None
	if k_set and k > g.order():
		return None
	if f == g.nodes() or (k_set and k <= 0):
		return f
	if (not f):
		g_degree = g.degree()
		g_max_degree_node = max(g_degree, key=lambda n: g_degree[n])
		if (g_degree[g_max_degree_node] <= 1):
			return set(g.nodes())
		else:
			fx = f.copy()
			fx.add(g_max_degree_node)
			gx = g.copy()
			gx.remove_node(g_max_degree_node)
			if k_set:
				new_k1 = k-1
				new_k2 = k
			mif_set1 = mif_preprocess_1(g, fx, t, new_k1)
			mif_set2 = mif_preprocess_1(gx, f, t, new_k2)
			if not mif_set1:
				return mif_set2
			elif not mif_set2:
				return mif_set1
			else:
				return max(mif_set1, mif_set2, key=len)

	# Set t as active vertex
	if t == None or not t in f:
		t = next(iter(f))

	gd_over_3 = None
	gd_2 = None
	for v in g.neighbors_iter(t):
		(gd_v, gn_v) = generalized_degree(g, f, t, v)
		if gd_v <= 1:
			f.add(v)
			if k_set:
				new_k1 = k-1
			return mif_preprocess_1(g, f, t, new_k1)
		elif gd_v >= 3:
			gd_over_3 = v
		else:
			gd_2 = (v, gn_v)
	if gd_over_3 != None:
		# Cannot simply use "if gd_over_3" because v might be 0
		fx = f.copy()
		fx.add(gd_over_3)
		gx = g.copy()
		gx.remove_node(gd_over_3)
		if k_set:
			new_k1 = k-1
			new_k2 = k
		mif_set1 = mif_preprocess_1(g, fx, t, new_k1)
		mif_set2 = mif_preprocess_1(gx, f, t, new_k2)
		if not mif_set1:
			return mif_set2
		elif not mif_set2:
			return mif_set1
		else:
			return max(mif_set1, mif_set2, key=len)
	elif gd_2 != None:
		(v, gn) = gd_2
		fx1 = f.copy()
		fx2 = f.copy()
		fx1.add(v)
		for n in gn:
			fx2.add(n)
		gx = g.copy()
		gx.remove_node(v)
		if k_set:
			new_k1 = k-2
			new_k2 = k-1
		try:
			cyc.find_cycle(gx.subgraph(fx2))
			mif_set1 = None
		except:
			mif_set1 = mif_preprocess_1(gx, fx2, t, new_k1)
		mif_set2 = mif_preprocess_1(g, fx1, t, new_k2)
		if not mif_set1:
			return mif_set2
		elif not mif_set2:
			return mif_set1
		else:
			return max(mif_set1, mif_set2, key=len)
	return None