23

I am working on a problem which could be reduced to a graph optimization problem as below.

  • A set of colored nodes is given. They are all unconnected i.e. there is no edge in the graph.

  • The edges are to be inserted between the nodes.

  • A node can have only 4 edges at max.

  • A table provides rules for profit contribution from the edges.

    Eg.,

    • An edge connecting red to red: profit is 10

    • An edge connecting red to blue: profit is 20

  • The total number of nodes is around 100.

  • The total number of colors is typically around 20 to 30, but it can go as high as 50. Correspondingly the table for profit(edge) would be a long list but it won't list all possible combinations. The profit for edges not specified in the table is assumed zero.

The problem is to optimize the connections (edges) such that the total profit is maximized.

I am wondering if this problem, maybe in some other way, is known. If so, please provide any pointers that might be of help. Thanks.

Suresh
  • 925
  • 1
  • 9
  • 23
  • Is your graph bipartite? – Peter de Rivaz Apr 24 '17 at 12:15
  • Initially, only the nodes are provided. They are all unconnected. There is no edge in the graph. – Suresh Apr 24 '17 at 12:22
  • 1
    Could you post some sample input, especially cases where the naive solution (create the most profitable connections first, then work down) isn't optimal? – m69's been on strike for years Apr 29 '17 at 02:52
  • I would suggest to collapse all k nodes of the same color, to a single node which is now allowed to have 4*k edges and every node can be labled by the color it represents. – Beginner May 03 '17 at 14:48
  • 1
    Cross-posted: https://cs.stackexchange.com/q/74442/755, http://stackoverflow.com/q/43587648/781723, http://stackoverflow.com/q/43581690/781723. Please [do not post the same question on multiple sites](https://meta.stackexchange.com/q/64068). Each community should have an honest shot at answering without anybody's time being wasted. – D.W. May 19 '17 at 16:02

5 Answers5

14

You can convert this to a problem of finding a perfect matching of maximum cost, which can be solved in polynomial time (e.g. using a variant of the Blossom algorithm )

The conversion is to split each node of degree d into d left nodes and d-4 right nodes.

For each pair of vertices u,v in the original graph, add an edge between an unconnected vertex u left node and an unconnected vertex v left node of weight equivalent to the profit of joining u and v.

Next add extra edges (of weight 0) between every pair of left and right nodes (for the same vertex).

Now construct the max weight perfect matching in this new graph.

The point is that the extra edges use up all but 4 of the left nodes. This means that each vertex can only make profit from 4 of the profitable edges.

Example

Suppose we have a problem with 7 coloured nodes. I have drawn the section of the expanded graph that corresponds to the part for a single green node and a single red node.

Note that there are 6 left green nodes, one less than the total number of coloured nodes. There are 2 right green nodes, four less than the number of left nodes. There is a single curved edge joining a greenleft node and a red left node. If this curved edge is chosen in the perfect matching it means that the red node should be joined to the green node.

enter image description here

Peter de Rivaz
  • 33,126
  • 4
  • 46
  • 75
  • Thanks for your time. Initially, the graph has no edges, the degree of all nodes is zero. So, I am a bit confused about this: "split each node of degree d into d left nodes and d-4 right nodes" – Suresh Apr 24 '17 at 16:55
  • 1
    I am thinking of a more general case where only some edges are allowed. In your case, every node can be connected to any other, so if you have n vertices, then each node has an effective degree of n-1. So you need to split each node into n-1 left nodes, and n-5 right nodes. This will make quite a large intermediate graph with O(n^2) nodes so I suspect there should be a more efficient approach than this one. – Peter de Rivaz Apr 24 '17 at 17:01
  • Ok. Got it. Thanks for the pointer. I am still reading and understanding the matching problem. – Suresh Apr 24 '17 at 17:18
  • Good reduction to another problem. But in this approach, how would you prevent multiple edges between the same (original) pair of nodes? Say node A is split into the left nodes LA1, LA2, LA3, LA4, and LA5, (and one right node RA1) and node B is split into the right nodes RB1 and RB2 (and 6 left nodes). How would you prevent the matching of both LA1-RB1 and LA2-RB2? Because then this would translate to multiple edges between the same pair of nodes A-B in the original graph, which I believe is not allowed (unless the original problem allows multigraphs) – justhalf Apr 25 '17 at 03:18
  • @justhalf I've added a picture. Note that there is only a single connection between LA and RB. In the diagram this is LG4-LR5. Therefore you cannot get multiple edges between the same two nodes. – Peter de Rivaz Apr 25 '17 at 07:23
  • 1
    Ah, I see. So the purpose of having `d` split nodes is that each split node will connect to a unique other node. Good one. What is the complexity of the whole algorithm? – justhalf Apr 25 '17 at 07:39
  • 3
    BlossomV claims worst case complexity O(V^3E). We have V=O(n^2) and E=O(n^3), so overall this is worst case complexity O(n^9)! I think this answer is mainly useful in showing that the problem is not NP-hard - but I feel there must be a more efficient solution to be found. – Peter de Rivaz Apr 25 '17 at 08:10
3

Here is linear programming formulation for this problem: assign a variable for each color pair present in "profit" table (up to c*(c+1)/2 variables needed, where c is the number of colors), use c constraints determined by "4 edges per node" limitation and one constraint for each variable to limit the number of possible edges (except when there are at least 4 nodes for each of edge's color or 5 nodes for single-color edges), and maximize the sum of variable*profit terms.

LP solver might find all-integer variables for this problem (if we are lucky). Or there may be solutions with fractional variables, see counterexample below.

When we get an LP solution (where each variable represents number of edges for some color combination), we should actually add edges to the graph. Use some strategy to avoid loops and duplicate edges (like "choose least connected node" from nodes of same color).

Counterexample: 5 red, 4 green, several blue nodes, profit 100 for red-green edges, 10 for red-red, 1 for red-blue. LP solution gives 20 red-green edges (correct), 2.5 red-red edges (should be 2), and zero red-blue edges (should be 1).

Fix: Integer linear programming is a correct approach to this problem. For up to 50 colors we'll need up to 1275 variables. This should be relatively simple task for a decent ILP solver.

Evgeny Kluev
  • 24,287
  • 7
  • 55
  • 98
3

This sounds similar to the 0-1 Knapsack problem where the maximum is calculated if an item is either placed into the knapsack or is not placed into the knapsack. Here is an example:

def knapsack(numItems, capacity, sizes, values):
  # if no more items left to put in knapsack or knapsack is full
  if (numItems == 0 or capacity == 0):
    return 0

  # if can't fit item into knapsack, try the next item
  if (sizes[numItems-1] > capacity):
    knapsack(numItems-1, capacity, sizes, values)

  # find the max of including or not including item in knapsack
  return max(
    values[values-1] + knapsack(numItems-1,capacity - weights[numitems-1], sizes, values),
    knapsack(numItems-1, capacity, sizes, values))

Here you are seeking the maximum when a node is either connected with another node or not. When a node is connected, the value that results depends on the node's color. The code would look something like:

def ConnectNodes(numItems, capacity, sizes, values, nodeColor):
  # if no more items left to connect or capacity is full
  if (numItems == 0 or capacity == 0):
    return 0

  # if can't fit item into knapsack, try the next item
  if (sizes[numItems-1] > capacity):
    ConnectNodes(numItems-1, capacity, sizes, values, nodeColor)

  # find the max of connecting or not connecting node
  return max(
    RulesForProfit(numItems-1, nodeColor) + ConnectNodes(numItems-1,capacity - weights[numitems-1], sizes, values, nodeColor),
    ConnectNodes(numItems-1, capacity, sizes, values, nodeColor))
J. Michael Wuerth
  • 272
  • 1
  • 6
2

Did you think maybe about greedy approach ? For all colors and corresponding colorA->colorB values, if for each colored edge you will do

edge_color  :  sort_in_descending_order(edge_color_To_color_Prices)
example:
    red: red->black  30
         red->white  20
         red->yellow 10
    black: black->green 15
           black->grey 10

iterate until there is room for new edge (4 per node) and take biggest possible edge value(mark it as visited as well it will help you latter) (I assume you can link nodeA with nodeB only once). We can assume that edge is not directed from what you have said. In each node you have to store those chosen values, so when you are iterating over next edge that you already used you have to be aware of the chosen edges (black node has to be aware of red->black 30 chosen by red)

red: 1st edge: red->black 30 -> stores that in black node list as 
[red,30]
     2nd edge: ...........20 ->...
     3rd edge: ...........10
     4th edge: ...........5
     ---------------------------
     5th edge: ...........4   (after update from black it will be 4th 
edge)
black: 1st edge: black->white   50  > [red,30] 
       2nd edge: .............. 40
       3rd edge: .............. 35
       4th edge: .............. 34
       ---------------------------
       5th edge  .............. 30 (this is our red->black edge)

replace by (black->white 50) and go to red node to update it with the next max (because we just removed red->black 30 by black->white 50 - we will replace it only if we reached the limit of edges in Black node following the min value criteria - we are removing/replacing lowest priced edge from Black node)

That should work

Tomasz Andel
  • 173
  • 4
  • Simple test: 4 red nodes, 2 blue, 2 green. red-red 10, red-blue 7, red-green 6, green-green 0, green-blue 1, blue-blue 0. Answer is 26. – DAle Apr 28 '17 at 06:03
  • `Simple test: 4 … Answer is 26` 6*10+2*7+2*6+2*1?! – greybeard Apr 28 '17 at 06:08
  • Oh, sorry, I forgot about degree 4. Answer is 104. 8*7+8*6 – DAle Apr 28 '17 at 06:15
  • well not really, not that kind of greedy i was talking about, its a node LOCAL greedy algorithm, choose the best that you can choose now, update connected nodes, and go to next node. Each update updates also local choice. So its not a typical greedy algorithm, it just start with greedy approach. – Tomasz Andel Apr 28 '17 at 09:18
  • 6*10+4*7+4*1 = 92 (10,10,10,7)(10,10,10,7)(10,10,10,7)(10,10,10,7)(7,7,1,1)(7,7,1,1)(1,1)(1,1) – Tomasz Andel Apr 28 '17 at 14:12
  • 1
    This greedy algorithm does not give a optimal solution. Without loss of generality we'll look at the same problem, where the limit of edges per node is 1. Suppose there are 4 nodes with colours a,b,c,d and the profit values are {a,b}=30 {b,c}=50 {c,d}=30. Your algorithm would choose only the b,c-edge with overall profit 50. While the optimal solution would be to choose the a,b-edge and the c,d-edge with overall profit 60. – Gastmon May 03 '17 at 17:39
2

Just an idea, didn't have much time to verify it.
How about starting with a weighted graph G=(V,E) where V is your set of nodes and the weight E is the profit from your table. Let O be a empty set that will be our output.

Then use a matching algorithm(Blossom algorithm) on G. Add these edges to O.

Repeat the algorithm with input G'=(V,E\O). Again add these edges to O.

Repeat another two times. Return O.

Running time:
Blossom algorithm's running time is O(E*V^(1/2)) according to wikipedia. Since the algorithm is used 4 times the overall running time would also be O(E*V^(1/2)).

Gastmon
  • 83
  • 6