Corrected find_max_2_3_subgraph

Author: SebVde

bar_yehuda_fvs.py

@@ -2,43 +2,135 @@
 from collections import deque
 
 
-def dfs_construct(G, H, v, visited, edges_visited):
-    visited.add(v)
-    for u in G.neighbors(v):
-        edge = (min(v, u), max(v, u))
-        if edge in edges_visited:
+def find_maximal_2_3_subgraph(og_G):
+    G = og_G.copy()
+    H = nx.Graph()
+    H.add_nodes_from(G.nodes())
+    nodes_to_visit = list(G.nodes())
+
+    # Chemin actuel
+    stack = []
+    in_stack = set()
+
+    # stack[0] est connecté à un noeud de H de degré 2?
+    start_connected = False
+
+    while True:
+        if len(stack) == 0:
+            start_node = None
+            while len(nodes_to_visit) > 0:
+                n = nodes_to_visit.pop(0)
+                if G.degree(n) > 0:
+                    start_node = n
+                    break
+
+            if start_node is None:
+                # Plus de noeuds à visiter
+                break
+
+            stack = [start_node]
+            in_stack = {start_node}
+            if H.degree(start_node) == 2:
+                start_connected = True
+            else:
+                start_connected = False
+
+        # Extrémité du chemin actuel
+        u = stack[-1]
+        parent = stack[-2] if len(stack) > 1 else None
+        nb = list(G.neighbors(u))
+
+        # Si pas de voisins du tout ou seul voisin est le parent -> cul de sac
+        if len(nb) == 0 or (len(nb) == 1 and nb[0] == parent):
+            if parent is not None:
+                if G.has_edge(parent, u):
+                    G.remove_edge(parent, u)
+            in_stack.remove(stack.pop())
+
+            # Reset si la stack est vide
+            if len(stack) == 0:
+                start_connected = False
             continue
 
-        edges_visited.add(edge)
-        deg_u = H.degree[u] if u in H else 0
-        deg_v = H.degree[v] if v in H else 0
+        v = None
+        for neighbor in nb:
+            if neighbor != parent:
+                v = neighbor
+                break
 
-        if deg_u < 3 and deg_v < 3:
-            H.add_edge(u, v)
-        if u not in visited:
-            dfs_construct(G, H, u, visited, edges_visited)
+        if H.degree(v) == 3:
+            G.remove_edge(u, v)
+            continue
 
+        # Si v est dans la stack, alors on a un cycle
+        elif v in in_stack:
+            idx = stack.index(v)
+            cycle_nodes = stack[idx:]
+            edges_to_add = []
+            for i in range(len(cycle_nodes) - 1):
+                edges_to_add.append((cycle_nodes[i], cycle_nodes[i + 1]))
+            edges_to_add.append((u, v))
+            H.add_edges_from(edges_to_add)
+            G.remove_edges_from(edges_to_add)
+
+            # Si idx == 0, cycle formé par tous les sommets de la stack
+            if idx == 0:
+                stack = []
+                in_stack = set()
+                start_connected = False
+
+            else:
+                stack = stack[: idx + 1]
+                in_stack = set(stack)
+                # Le bout de la pile (v) est connecté à H
+                # Si le début est connecté, alors c'est un chemin valide à ajouter
+                if start_connected:
+                    path_edges = []
+                    for i in range(len(stack) - 1):
+                        path_edges.append((stack[i], stack[i + 1]))
+                    H.add_edges_from(path_edges)
+                    G.remove_edges_from(path_edges)
+                    stack = []
+                    in_stack = set()
+                    start_connected = False
+
+                else:
+                    # La pile est inversée pour essayer d'attacher le début du chemin à H ou un autre cycle
+                    stack.reverse()
+                    # v était à la fin de la stack, maintenant au début donc le début est connecté à H
+                    start_connected = True
 
-def find_maximal_2_3_subgraph(G):
-    H = nx.Graph()
-    visited = set()
-    edges_visited = set()
-    for node in G.nodes:
-        if node not in visited:
-            dfs_construct(G, H, node, visited, edges_visited)
-
-    to_remove = {n for n in H.nodes if H.degree(n) < 2}
-    while len(to_remove) > 0:
-        v = to_remove.pop()
-        if v not in H:
             continue
 
-        nb = set(H.neighbors(v))
-        H.remove_node(v)
-        for u in nb:
-            if u in H and H.degree[u] < 2:
-                to_remove.add(u)
+        elif H.degree(v) == 2:
+            # v est déjà dans H et à un degré 2 donc la connexion du chemin dans stack est possible à v
+            # Si le début est connecté, alors c'est un chemin valide à ajouter
+            if start_connected:
+                path_edges = []
+                for i in range(len(stack) - 1):
+                    path_edges.append((stack[i], stack[i + 1]))
+                path_edges.append((u, v))
+                H.add_edges_from(path_edges)
+                G.remove_edges_from(path_edges)
+                stack = []
+                in_stack = set()
+                start_connected = False
+
+            else:
+                stack.append(v)
+                in_stack.add(v)
+                stack.reverse()
+                start_connected = True
+            continue
+
+        # v est degré 0 ou 1 dans H, on peut l'ajouter au chemin
+        else:
+            stack.append(v)
+            in_stack.add(v)
+            continue
 
+    to_remove = [n for n in H.nodes() if H.degree(n) == 0]
+    H.remove_nodes_from(to_remove)
     return H
 
 
@@ -104,5 +196,5 @@ def subG_2_3(G):
     return X | Y | W
 
 
-def get_decycling_number_bar_yehuda(G):
+def approx_decycling_number_bar_yehuda(G):
     return len(subG_2_3(G))