Implemented the rest and optimized the search for a maximal 2-3-subgraph

Author: SebVde

bar_yehuda_fvs.py

@@ -2,34 +2,43 @@
 from collections import deque
 
 
-def dfs_remove_below_2(H, v):
-    # Supprime récursivement les sommets de degré inférieur à 2
-    # Pas de visited car vu qu'on supprime des noeuds, certains noeuds peuvent changer de degré
-    if (v in H) and (H.degree(v) < 2):
-        nb = set(H.neighbors(v))
-        H.remove_node(v)
+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:
+            continue
 
-        for u in nb:
-            dfs_remove_below_2(H, u)
+        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
+
+        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)
 
 
 def find_maximal_2_3_subgraph(G):
-    # Sous-graphe maximal de G avec que des degrés entre 2 et 3 dans ce sous-graphe
-    H = G.copy()
-
-    while any(H.degree(node) > 3 for node in H.nodes):
-        node = next(n for n in H.nodes if H.degree(n) > 3)
-        node_deg = H.degree(node)
-        if node_deg > 3:
-            m = node_deg - 3
-            nb = sorted(
-                list(H.neighbors(node)), key=lambda x: H.degree(x), reverse=True
-            )
-            for i in range(m):
-                H.remove_edge(node, nb[i])
-
-    for node in set(H.nodes):
-        dfs_remove_below_2(H, node)
+    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)
+
     return H
 
 
@@ -67,44 +76,33 @@ def get_critical_linkpoints(G, H):
     return critical_linkpoints
 
 
+def is_cycle(G):
+    return all(G.degree(n) == 2 for n in G.nodes)
+
+
+def get_set_covering_cycles(H, X, Y):
+    sg = nx.subgraph(H, set(H.nodes) - X - Y)
+    cover_set = set()
+
+    for comp in nx.connected_components(sg):
+        comp_sg = nx.subgraph(sg, comp)
+        if is_cycle(comp_sg):
+            cover_set.add(next(iter(comp)))
+
+    return cover_set
+
+
 def subG_2_3(G):
+    # Complexité pas linéaire à cause de get_critical_linkpoints
     if nx.is_forest(G):
         return set()
 
     H = find_maximal_2_3_subgraph(G)
     X = get_critical_linkpoints(G, H)
-    Y = {n for n in H.nodes if H.degree(n) > 2}
-    pass
+    Y = {n for n in H.nodes if H.degree(n) >= 3}
+    W = get_set_covering_cycles(H, X, Y)
+    return X | Y | W
 
 
 def get_decycling_number_bar_yehuda(G):
     return len(subG_2_3(G))
-
-
-if __name__ == "__main__":
-    G = nx.Graph()
-    edges = [
-        (1, 2),
-        (2, 3),
-        (3, 4),
-        (2, 4),
-        (3, 5),
-        (5, 6),
-        (6, 7),
-        (7, 5),
-    ]
-    G.add_edges_from(edges)
-
-    # ajouter des sommets de degré 1 (feuilles) au graphe G existant
-    G.add_edge(1, 8)  # 8 devient un sommet de degré 1
-    G.add_edge(6, 9)  # 9 devient un sommet de degré 1
-    G.add_edge(7, 10)  # 10 devient un sommet de degré 1
-
-    print("Graph G:")
-    print("Nodes:", G.nodes())
-    print("Edges:", G.edges())
-    #
-    # decycling_number = get_decycling_number_bar_yehuda(G)
-    # print("Decycling number (Bar-Yehuda method):", decycling_number)
-    H = find_maximal_2_3_subgraph(G)
-    print(H)