如何从无向图上删除一些边缘？

Question

Let say, I have an undirected graph with 7 nodes.

g = {1:[2,3], 2:[1,4], 3:[1,4,6], 4:[2,3,5,7], 5:[4,6], 6:[3,5], 7:[4]}

I want to delete some edges from the graph, specifically, a node with more than degree 2. I have implemented the following code which can explore each node in the graph by DFS manner, checks their degree and remove edges based on the node's degree.

def Remove_edges(graph, start):
stack = [start]
visited = []
while stack:
    vertex = stack.pop()
    if vertex not in visited:
        visited.append(vertex)
        check_node_degree = node_degree(graph,vertex)

        if check_node_degree > 2:
            compute_edges = get_edges(graph, vertex)

            while len(compute_edges)!=2:
                compute_edges.pop()


        for neighbour in graph[vertex]:
            stack.append(neighbour)

graph.update(g.edges())
new_g = graph.copy()
return new_g

I got the result like this, new_g = {1: 3, 2: 4, 3: 6, 4: 7, 5: 6, 6: [3, 5], 7: [4]}.

Can any one help me to solve the problem?

Answer 1

It seems like you want to create a graph with maximum degree of 1 (ie, you are building a matching). If this is not the problem you are trying to solve, then you need to be more clear with your question.

Additionally, you call custom functions which you do not include in the question. I believe that your error is coming from one such function, but I cannot be sure:

graph.update(g.edges())

After the while loop, any nodes that were visited will have one neighbor (its last neighbor); specifically, your graph should be: new_g = {1: 3, 2: 4, 3: 6, 4: 7, 5: 6, 6: 5, 7: 4}.

However, you have an undirected graph, so you call graph.update() to repair broken edges, which restrings 6 to 3 (since 3 has an edge to 6). (Again, you did not include the code for graph.update(), so I am making an assumption that it is repairing broken edges.) You need to call a function that does the opposite: instead of making directed edges undirected, they should be removed.

---

Furthermore, might I suggest that you change your algorithm? I see two problems. First, if the graph is well connected you will visit nodes multiple times, which is why you need to compare against the visited array. On the other hand, if the graph is not one connected component, you will not visit every node. Both of these problems can be solved by looping over the nodes instead of doing a DFS; this will save you time and resources and improve the correctness of your algorithm.

Also, if you are interested in maximizing the number of edges remaining in your graph, I suggest you look at http://en.wikipedia.org/wiki/Matching_%28graph_theory%29