给定无向图中的边，在最大化图的度数的同时限制最大图度的算法是什么？

Question

This is for my research in protein folding (So I guess technically a school project)

Summary: I have the edges of an weighted undirected graph. Each vertex of the graph has anywhere from 1 to 20-ish edges. I would like to trim this graph down such that no vertex has more than 6 edges. I would also like the graph to retain as much connectivity as possible (maximize the degree).

Background: I have a Delaunay Tesselation of the atoms (pointcloud essentially) in a protein using the scipy library. I use this to create a list of all pairs of residues that are in contact with each other (I store the distance between them). This list contains every pair (twice), and the distance between the pairs. (The residue contains many atoms so I use the average position of them to get the position of the residue)

pairs
[(ALA 1, GLU 2, 2.7432), (ALA 1, GLU 2, 2.7432), (ALA 4, ASP 27, 4.8938), (ALA 4, ASP 27, 4.8938) ... ]

What I have tried (which works but isn't exactly what I want) is to only store the six closest contacts. (I sort the residue names so I can use collections later)

for contact in residue.contacts[:6]:
    pairs.append( tuple( sorted([residue.name, contact.name], key=lambda r: r.name) + [residue.dist[contact]] ) )

And then remove any contacts that are not reciprocated. (I guess technically add contacts that are)

new_pairs = []
counter=collections.Counter(pairs)
for key, val in counter.items():
    if val == 2:
        new_pairs.append(key)

This works, but I lose some information that I would like to keep. I phrased the question as a graph theory problem because I feel like this problem has already been solved in that field.

I was thinking that greedy algorithm might work:

while run_greedy:
    # find the residue with the maximum number of neighbors
    # find that residues pair with the maximum number of neighbors but only if the pair exists in pairs
    # remove that pair from pairs

    # if maximum_degree <= 6: run_greedy = False

Does the greedy algorithm work? Are there known algorithms that do this well? Is there a library that can do this (I am more than willing to change the format of the data to fit the library)?

I hope this is enough information, Thanks in advance for the help.

Answer 1

EDIT this is an variant of the knapsack problem : you add edges one by one, and want to maximize the number of edges while the graph built doesn't exceed a given degree.

The following solution uses dynamic programming.

Let m[i, d] the maximum subset of edges in e_0, ..., e_{i-1} creating a subgraph of maximium degree <= d .

• m[i, 0] = {}
• m[0, d] = {}
• m[i, d] = m[i-1, d] + {e_i} if the degree of the graph is <= d
• m[i, d] = m[i-1, d-1] + {e_i} if it has more edges than m[i-1][d] , else m[i-1][d] .

Hence the algorithm (not tested):

for i in 0..N:
    m[i][0] = {}
for d in 1..K:
    m[0][d] = {}

for d in 1..K:
    for i in 1..N:
        G1 = m[i-1][d] + {e_i}
        if D(G1) == d: # can add e_i with degree <= k
            m[i][d] = G1
        else:
            m[i][d] = max(m[i-1][d-1] + {e_i}, m[i-1][d]) # key=cardinal

Solution is: m[N-1][K-1] . Time complexity is O(KN^2) (imbricated loops : KN + maximum degre of the graph in N or less)

Previous answer

TLDR; I don't know how to find an optimal solution, but a greedy algorithm might give you acceptable result.

The problem

Let me rephrase the problem, based on your question and your code: you want to remove a minimum number of edges from your graph in order to reduce the maximum degree the graph to 6 . That is to get the maximal subgraph G' from G with D(u) <= 6 for all u in G' .

The closest idea I found is the K-core of a graph , but that's not exactly the same problem.

Your method

Your method is clearly not optimal, since you keep at most 6 edges of every vertex and recreate the graph with those edges. Take the graph ABC :

A -> 1. B, 2. C
B -> 1. C, 2. A
C -> 1. A, 2. B

If you try to reduce the maximum degree of this graph to 1 using your method, the first pass will remove AB ( B is the 2nd neighbor of A ), BA ( A is the 2nd neighbor of B ) and CB ( B is the 2nd neighbor of C ):

A -> 1. B
B -> 1. C
C -> 1. A

The second pass, to insure that the graph is undirected, will remove all the remaining edges (and vertices).

An optimal reduction would be:

A -> 1. B
B -> 1. A

Or any other pair of vertices in A , B , C .

Some strategy

Let:

• k = 6
• D(u) = max(d(u)-k, 0) : the number of neighbors above k , or 0
• w(uv) (resp s(uv) ) = the weak (resp. strong) endpoint of the edge: having the lowest (resp. highest) degree
• m(uv) = min(D(u), D(v))
• M(uv) = max(D(u), D(v))

Let S = sum(D(u) for u in G) . The goal is to make S = 0 while removing a minimum number of edges. If you remove:

(1) a floating edge: m(uv) > 0 , then S is decreased by 2 (both endpoints loose 1 degree)

(2) a sinking edge: m(uv) = 0 and M(uv) > 0 , then S is decreased by 1 (the degree of the weak endpoint is already <= 6 )

(3) a sunk edge: M(uv) = 0 , then S is unchanged

Note that a floating edge may become a sinking edge if: 1. its weak endpoint has a degree of k+1 ; 2. you remove another edge connected to this endpoint. Similarly, a sinking edge can sunk.

You have to remove floating edges while avoid creating sinking edges, because removing a floating edges is more efficient to reduce S . Let K the number of floating edges removed, and L the number of sinking edges removed (we don't remove sunk edges) to make S = 0 . We want 2*K + L >= S . Obviously, the idea is to make L as small a possible, because we want a small number of edges removed ( K + L ).

I doubt you'll find an optimal greedy algorithm, because everything depends on the order of removing and the remote consequences of the current removing are hard to predict.

But you can use a general strategy to limit the creation of sinking edges:

1. do not remove edges with m(uv) = 1 unless you have no choice.
2. if you have to remove an edge with m(uv) = 1 , choose the one whose weak endpoint has the less floating edges (they will become sinking edges).

An algorithm

Here's a greedy algorithm that implements this strategy:

while {u, v in G | m(u-v) > 0} is not empty: // remove floating edges first
    remove the edge u-v with:
        1. the maxmimum m(u-v)
        2. w(u-v) has the minimum of neighbors t with D(t) > 0
        3. s(u-v) has the minimum of neighbors t with D(t) > 0

remove all edges from {u, v in G | M(u-v) > 0} // clean up sinking edges
clean orphan vertices

Termination the algorithm terminates because we remove an edge on each iteration, thus {u in G | D(u) > 0} {u in G | D(u) > 0} will become empty at some point.

Note: you can use a heap and update m(uv) after each removing.