Next Article in Journal
Review of Recent Type-2 Fuzzy Controller Applications
Previous Article in Journal
A New Multi-Step Iterative Algorithm for Approximating Common Fixed Points of a Finite Family of Multi-Valued Bregman Relatively Nonexpansive Mappings
Article Menu

Export Article

Algorithms 2016, 9(2), 38; doi:10.3390/a9020038

Article
A 3/2-Approximation Algorithm for the Graph Balancing Problem with Two Weights
Daniel R. Page * and Roberto Solis-Oba
Department of Computer Science, Western University, London, ON N6A5B7, Canada
*
Correspondence: Tel.: +1-226-448-1966
Academic Editor: Jesper Jansson
Received: 29 April 2016 / Accepted: 2 June 2016 / Published: 8 June 2016

Abstract

:
In the pursuit of finding subclasses of the makespan minimization problem on unrelated parallel machines that have approximation algorithms with approximation ratio better than 2, the graph balancing problem has been of current interest. In the graph balancing problem each job can be non-preemptively scheduled on one of at most two machines with the same processing time on either machine. Recently, Ebenlendr, Krčál, and Sgall (Algorithmica 2014, 68, 62–80.) presented a 7 / 4 -approximation algorithm for the graph balancing problem. Let r , s Z + . In this paper we consider the graph balancing problem with two weights, where a job either takes r time units or s time units. We present a 3 / 2 -approximation algorithm for this problem. This is an improvement over the previously best-known approximation algorithm for the problem with approximation ratio 1.652 and it matches the best known inapproximability bound for it.
Keywords:
approximation algorithms; scheduling; graph balancing problem; restricted assignment problem; makespan minimization

1. Introduction

Let G = ( V , E , p , q ) be a weighted multigraph, where V is the set of vertices, E is the set of edges, p = ( p 1 , , p | E | ) are non-negative edge weights, and q = ( q 1 , , q | V | ) are the dedicated loads. A dedicated load q v of vertex v is the sum of the weights of self-loops incident on v in the multigraph; we assume the self-loops are removed from G. An orientation γ : E V orients each edge e E towards one of its endpoints. Given a weighted multigraph G, the graph balancing problem is to find an orientation γ where the maximum load of the vertices is minimized, where the load of a vertex v is defined as q v + e | γ ( e ) = v p e .
Let r , s Z + , where r < s . We focus on a special case of this problem we call the graph balancing problem with two weights (GBP2W), where the edges have either weight r or s and each dedicated load is of the form a r + b s for a , b Z + { 0 } .
The graph balancing problem is a special case of the makespan minimization problem on unrelated parallel machines ( R | | C m a x in Graham notation, see [1]). Presently, the best-known approximation algorithms for R | | C m a x have approximation ratio 2. The first 2-approximation algorithm for R | | C m a x was presented by Lenstra et al. [2], and in 2005 a ( 2 1 / m ) -approximation algorithm was given by Shchepin and Vakhania [3], where m is the number of machines. These 2-approximation algorithms utilize linear programming, but it is worth noting that there is a combinatorial 2-approximation algorithm by Gairing et al. [4] that employs generalized flow networks. Finding an approximation algorithm with approximation ratio better than 2 for R | | C m a x is an important open problem in scheduling theory, and trying to get any further insight into the problem through the study of subclasses of R | | C m a x has been of attention lately [5,6,7,8,9,10,11,12,13].
Recently, Ebenlendr et al. [7] gave a 7 / 4 -approximation algorithm for the graph balancing problem. In addition, Ebenlendr et al. [14] showed that for p < 3 / 2 , there is no p-approximation algorithm for the graph balancing problem when the edges of the multigraph have weight 1 / 2 or 1, unless P=NP. Note that this hardness result was also independently proven by Asahiro et al. [5,15]. This matches the inapproximability bound for the makespan minimization problem on unrelated parallel machines given by Lenstra et al. [2], so, GBP2W is worth investigating due to being one of the simplest scheduling problems presently known to share inapproximability properties with R | | C m a x .
3 / 2 -approximation algorithms have been presented for some special cases of GBP2W. The graph orientation problem with two weights is a NP-hard special case of GBP2W where G is simple, and every dedicated load q v = 0 . In [5,15], Asahiro et al. gave two approximation algorithms that achieve the bound 3 / 2 for variants of the graph orientation problem with two weights: one called Cycle-Canceling when r = 1 and s = 2 ; and another called Refined Cycle-Canceling when r = 1 and s = 3 . Later, Kolliopoulos and Moysoglou [9] gave a 3 / 2 -approximation algorithm for GBP2W when r = 1 and s = k , where k is a positive integer (Theorem 4.1).
Most recently, Kolliopoulos and Moysoglou [9] presented a 1.652-approximation algorithm for GBP2W. Their approximation algorithm employs binary search, and for a given estimation of the optimal load T different approximation algorithms are used based on the values of the weights with respect to T. A core component of this approximation algorithm is a flow-network based approximation algorithm for the two-valued case of the restricted assignment problem introduced in the same paper. In this paper we present a 3 / 2 -approximation algorithm for GBP2W. We adopt a technique of considering particular intervals for the weights during a binary search similar to that of by Kolliopoulos and Moysoglou to derive our 3 / 2 -approximation algorithm.
To conclude this section, we outline the remainder of this paper. In Section 2, we present our contribution—a 3 / 2 -approximation algorithm for GBP2W. After describing our algorithm, we give subroutines used by the algorithm and their correctness in Section 2.1, Section 2.2, Section 2.3 and Section 2.4, then prove our algorithm is indeed a 3 / 2 -approximation algorithm for GBP2W in Section 2.5. In Section 3, we conclude our paper.

2. Algorithm

Similar to the algorithm by Lenstra et al. [2], our approximation algorithm uses an estimation T of the maximum load of a vertex in an optimal orientation as a parameter. The algorithm GB2W presented below as Algorithm 1 finds a solution of value at most 3 T / 2 if a solution of value at most T exists. We combine this algorithm with a binary search procedure to find the smallest value for T for which an orientation with load at most 3 T / 2 for the graph balancing problem with two weights is found: if for a given T the algorithm does not find a solution of value at most 3 T / 2 then the value of T is increased in the binary search; otherwise it is decreased. By the above property of our algorithm this smallest value of T must be less than or equal to the value of an optimum solution, hence our algorithm has approximation ratio 3 / 2 .
The remainder of this section gives Lemmas 1–4 which provide the subroutines used by our algorithm, then in Theorem 5 we prove our algorithm is a 3 / 2 -approximation algorithm for GBP2W. First, we present Lemma 1 which covers Step 4 of our algorithm. Note that in Step 1 the algorithm scales the weights so the estimation for the optimum load is T = 1 . We define a big edge e to be an edge with weight p e > 1 / 2 ; otherwise, we call an edge small. Let the value for an optimum solution for the problem be denoted as O P T . From this point forward, we assume that as edges are oriented in Steps 4–5.3, they are removed from G.
Algorithm 1: GB2W ( G = ( V , E , p , q ) , T )
Input: 
Multigraph G, value T.
Output: 
An orientation γ for the edges in E with maximum vertex load at most 3 T / 2 or FAIL. If FAIL is returned there is no orientation for E with maximum vertex load T.
  • Divide edge weights and vertex dedicated loads by T; set T = 1 .
  • If s > 1 or q v > 1 for any v V then return FAIL.
  • If r , s ( 0 , 1 / 2 ] then apply the algorithm by Lenstra et al. [2].
  • If r , s ( 1 / 2 , 1 ] then apply the algorithm given in Lemma 1.
  • If r ( 0 , 1 / 2 ] and s ( 1 / 2 , 1 ] we consider three subcases. Let k = 1 / r , so 1 / ( k + 1 ) < r 1 / k .
    5.1.
    If k / ( k + 1 ) s 1 then apply the algorithm in Lemma 2.
    5.2.
    If ( k 1 ) / k s < k / ( k + 1 ) then apply the algorithm in Lemma 3.
    5.3.
    If 1 / 2 < s < ( k 1 ) / k then apply the algorithm in Lemma 4.
  • If any of the algorithms used in Steps 3–5 reports FAIL or if the solution computed by them has value larger than 3 / 2 then return FAIL; otherwise return the solution computed in the above steps.

2.1. Step 4

Lemma 1. 
There is a polynomial-time algorithm for the graph balancing problem with two rational weights r , s ( 1 / 2 , 1 ] that either finds a solution of value at most 1 or proves that O P T > 1 .
Proof. 
Since r , s ( 1 / 2 , 1 ] , each edge of G is a big edge. If there is an orientation for the edges with maximal load at most 1, then at most one edge can be oriented towards a given vertex. Therefore, if any connected component C = ( V C , E C ) of G has | E C | > | V C | then there is no solution for the graph balancing problem of value at most 1. The algorithm is as follows (Big_ r s , Algorithm 2).
Algorithm 2: Big_ r s   ( G = ( V , E , p , q ) )
Input: 
Multigraph G.
Output: 
An orientation γ for the edges in E with maximum vertex load at most 1 or FAIL. If FAIL is returned there is no orientation for E with maximum vertex load 1.
  • If any connected component C = ( V C , E C ) of G has | E C | > | V C | , then return FAIL.
  • While G has cycles do
    2.1.
    Find a cycle C of G.
    2.2.
    Mark the vertices in C and orient the cycle in an arbitrary direction. Remove the edges in C from G.
  • For every maximal tree T in G do
    3.1.
    If there is a vertex v in T with q v > 0 or that is marked, then set v as the root of T
    3.2.
    else choose any vertex v in T as the root.
    3.3.
    Orient all the edges in T away from its root.
    3.4.
    If any edge in T is oriented towards a vertex u with q u > 0 or that is marked then return FAIL.
  • Return orientation for the edges of G.
Multigraph G must have at most | V | edges, and an optimal orientation matches each edge to a unique vertex with no dedicated load. If a solution of value at most 1 exists, it must be found in Steps 2 and 3. The above algorithm runs in O ( | V | + | E | ) time.  ☐

2.2. Step 5.1

Next, we consider the case handled in Step 5.1 of the algorithm, namely when k / ( k + 1 ) s 1 and k = 1 / r so 1 / ( k + 1 ) < r 1 / k . In Lemma 2, we utilize the property that r + s > 1 , which means that if O P T 1 , then no small edge can be oriented with a big edge towards a given vertex without causing the maximal load to be greater than 1.
Lemma 2. 
For any k 2 , there is a polynomial-time algorithm for the graph balancing problem with two rational weights r , s , where 1 / ( k + 1 ) < r 1 / k and k / ( k + 1 ) s 1 that either finds a solution of value at most 3 / 2 or proves that O P T > 1 .
Proof. 
If O P T 1 , since r + s > 1 , for any optimal orientation either at most a big edge is oriented towards a vertex, or at most k small edges are oriented towards a vertex. This property is natural to encode into a flow network. To find an orientation for the edges of the weighted multigraph G = ( V , E , p , q ) , we use a multi-level flow network similar to that in [9].
We build a flow network N as follows. First, we consider the dedicated loads of the vertices. For each vertex v V , define a value β v 0 as follows: if q v s , set β v = k ; otherwise there is a non-negative integer p v so that q v = p v r , assign β v = p v . The flow network will have a source α 1 and sink α 2 . We will describe the network level by level. First, we have a level of nodes in the network called edge nodes. These are nodes corresponding to the edges in the multigraph. There are two types of edge nodes: big edge nodes for edges with weight s; and small edge nodes for those with weight r. From source α 1 , add an arc from α 1 to each edge node, and set its capacity to k if it is to a big edge node, and 1 otherwise. The next level consists of buffer nodes, one for each vertex. The buffer nodes are added to prevent excess flow from being contributed by the big edge nodes. While this part of the network is not important for proving this lemma, it will be vital for how we later use this network in Lemma 3. For each big edge { u , v } E , add arcs with capacity k from its big edge node to buffer nodes u and v. For the next level of the network, create a vertex node that will correspond to each vertex in the multigraph. For each buffer node for v V , add an arc from its buffer node to its vertex node with capacity k. Next, for each small edge { u , v } E , include arcs with capacity 1 from its small edge node to vertex nodes u and v. Finally, for each vertex v V , add an arc from vertex node v to sink α 2 with capacity k β v . The resulting flow network is shown in Figure 1.
Before we proceed to describe the algorithm, we show that this network has the following property: if O P T 1 , an integral maximum flow on this network saturates all the arcs leaving source α 1 . Consider any optimal orientation γ * . Using γ * we construct a flow function in which every small edge node receives 1 unit of flow, and each big edge node receives k units of flow from the source α 1 . For each big edge { u 1 , u 2 } of G with γ * ( u 1 , u 2 ) = u i , if u is the big edge node for { u 1 , u 2 } send k units of flow from α 1 to u, k units of flow from u to buffer node u i , k units of flow from buffer node u i to vertex node u i , and k units of flow from u i to the sink α 2 . Similarly, for each edge { u 1 , u 2 } represented by small edge node u and γ * ( u 1 , u 2 ) = u i , send 1 unit of flow from α 1 to u, from u to vertex node u i , and from u i to α 2 . It is not hard to see that this flow function is feasible and that no additional flow can be sent through the network.
Algorithm 3: BigSmall_rs ( G = ( V , E , p , q ) )
Input: 
Multigraph G. Note that k = 1 / r .
Output: 
An orientation γ for the edges in E with maximum vertex load at most 3 / 2 or FAIL. If FAIL is returned there is no orientation for E with maximum vertex load 1.
  • Build the flow network N.
  • Compute an integral maximum flow f of N.
  • If all the arcs leaving the source are not saturated in f, then return FAIL.
  • Construct bipartite graph G = ( V b i g V r e c , E ) , where V b i g is the set of big edge nodes, V r e c is the set of buffer nodes that receive at least k / 2 units of flow from a big edge node, and
    E = { ( u , v ) | u V b i g , v V r e c , f ( u , v ) k / 2 } .
  • Compute a matching on G that matches each node in V b i g with a unique vertex in V r e c .
  • For each arc ( u , u i ) in the matching of Step 5, orient big edge u towards vertex u i .
  • For each small edge node u and vertex node u i with f ( u , u i ) = 1 , orient u towards u i .
  • Return orientation for the edges of G.
The time complexity of algorithm BigSmall_ r s (Algorithm 3) is polynomial. Now we prove that this algorithm finds an orientation with maximal load at most 3 / 2 if O P T 1 . If O P T 1 , then as shown above, every small edge node receives 1 unit of flow from α 1 . By flow conservation, each small edge node u sends its one unit of flow to a vertex node u i , and the algorithm orients small edge u towards vertex u i . As a result, every small edge is oriented by the algorithm. What remains to be shown is that all the big edges are oriented. The orientation of each big edge is determined by the matching computed by the algorithm. We must show this matching exists. Consider any subset V b i g V b i g , and denote the neighbourhood in G of this subset of nodes as N G ( V b i g ) . Note that N G ( V b i g ) V r e c . To show the above matching exists, we prove | V b i g | | N G ( V b i g ) | . Two key observations are that the outdegree of every edge node is 2, and every big edge node is sent at most k units of flow. Furthermore, by flow conservation every big edge node must send at most k units of flow to the buffer nodes. We have two cases:
  • If k is odd, a buffer node in N G ( V b i g ) can receive at least k / 2 units of flow from only one big edge node in V b i g because k < 2 · k / 2 . Furthermore, since k k / 2 = k / 2 < k / 2 , each big edge node in G has degree 1. Hence, | V b i g | = | N G ( V b i g ) | .
  • If k is even, k / 2 = k / 2 , and a buffer node can receive k / 2 units of flow from at most two big edge nodes. Partition N G ( V b i g ) into two disjoint sets N 1 and N 2 , where N 1 contains the buffer nodes that receive more than k / 2 units of flow from a big edge node, and N 2 has the buffer nodes that receive k / 2 units of flow from a big edge node. Similar to when k is odd, each big edge node in V b i g is adjacent to only one buffer node in N 1 , and so each buffer node in N 1 has degree 1 in G . This leaves | V b i g | | N 1 | vertices adjacent to buffer nodes in N 2 . The indegree of each buffer node in N 2 is at least one (and no more than 2), but the outdegree of every big edge node adjacent to the buffer nodes in N 2 is exactly 2. This implies that the | V b i g | | N 1 | | N 2 | . Putting this together, | V b i g | | N 1 | + | N 2 | = | N G ( V b i g ) | .
Since | V b i g | | N G ( V b i g ) | , by Hall’s Theorem [16], a matching covering V b i g exists. Hence, the algorithm computes an orientation if O P T 1 and reports FAIL otherwise.
Consider the orientation produced by the algorithm. If vertex v has β v = k , then the edge from v to α 2 in N has capacity zero which implies that no edge is oriented towards v, so the load of v is q v 1 . Next we check when v has β v = p v < k .
  • First, let v be a vertex with a big edge oriented towards it. Since a big edge oriented towards v implies a big edge node sends at least k / 2 units of flow to the vertex node for v, at most ( k p v ) k / 2 units of flow can be additionally sent to this vertex node by small edge nodes; hence at most ( k p v ) k / 2 additional small edges are oriented towards v.
  • Second, the capacity from any vertex node v to α 2 is k p v , so any vertex that is not assigned a big edge has at most k p v small edges oriented towards it.
Hence, the load of a vertex v is at most
p v r + m a x { r ( k p v ) , s + r ( ( k p v ) k / 2 ) } m a x { r k , s + r ( k k / 2 ) } m a x { k / k , s + k / ( 2 k ) } 1 + 1 / 2 = 3 / 2  ☐

2.3. Step 5.2

Next, we cover the case when 1 / ( k + 1 ) < r 1 / k and ( k 1 ) / k s < k / ( k + 1 ) . In this case, it is possible that r + s 1 . If O P T 1 , at most one big edge can be oriented along with one small edge toward the same vertex; we exploit this property below.
Lemma 3. 
For any k 2 , there is a polynomial-time algorithm for the graph balancing problem with two rational weights r , s , where 1 / ( k + 1 ) < r 1 / k and ( k 1 ) / k s < k / ( k + 1 ) that either finds a solution of value at most 3 / 2 or proves that O P T > 1 .
Proof. 
We consider two cases: r + s > 1 , and r + s 1 . Assuming O P T 1 , if r + s > 1 either at most one big edge is oriented towards a vertex or at most k small edges are oriented towards a vertex; apply Lemma 2 to obtain an orientation where each vertex has load at most 3 / 2 , if such an orientation exists.
From this point forward, assume r + s 1 . Observe that 2 r + s > 1 . If O P T 1 , an optimal orientation either has at most a big edge oriented along with a small edge towards the same vertex, or at most k small edges are oriented towards a vertex. Like Lemma 2, compute a value β v for the dedicated load of each v V . When q v r + s , set β v = k . Otherwise, if q v s set β v = k 1 , and if not, assign β v = p v where q v = p v r . The algorithm will build a modified version of the flow network N of Lemma 2, which we describe now. First, change the capacities on the arcs incident on the big edge nodes from k to k 1 . Second, for each v V , set the capacity of the arc from buffer node v to vertex node v to k 1 instead of k. Leave the capacities from the vertex nodes to the sink α 2 as k β v . We show this flow network in Figure 2. It is straightforward to see that this modified network maintains the same property that all the arcs leaving α 1 are saturated in an integral maximum flow if O P T 1 .
We modify the algorithm from Lemma 2 as follows. We refer the reader to BigSmall_ r s (Algorithm 3). The modified flow network we described above is built for Step 1. Steps 2–3 are the same as before. In Step 4, when constructing the bipartite graph G between the big edge nodes and buffer nodes, V b i g remains the same, but V r e c contains buffer nodes that receive instead at least ( k 1 ) / 2 units of flow from a big edge node and
E = { ( u , v ) | u V b i g , v V r e c , f ( u , v ) ( k 1 ) / 2 }
steps 5–8 remain the same as before. Since the capacities of the arcs leaving the buffer nodes and the incoming flow to the big edge nodes are one less than in the network in Lemma 2, one can show a matching on G exists if O P T 1 by replacing k with k 1 and switching the even and odd cases of our original argument in Lemma 2.
Consider the load of a vertex v in the orientation produced by the algorithm. Clearly any vertex v with q v r + s has β v = k and k β v = 0 . No flow is sent to these vertex nodes, so the load of these vertices is at most 1. Now, examine vertices with 0 q v < r + s . If q v s , then at most one additional small edge can be oriented towards v. Hence, the load of v when q v s is at most q v + r 1 + r 3 / 2 since r 1 / 2 . Finally, consider when β v = p v and q v = p v r < s .
  • Let v be a vertex with a big edge oriented towards it. At least ( k 1 ) / 2 units of flow are sent from its big edge node to v. Then, at most ( k p v ) ( k 1 ) / 2 small edges can be oriented along with the big edge towards v.
  • Let v not have a big edge oriented towards it. At most k p v small edges are oriented towards v.
Therefore, the load of v is at most
p v r + m a x { r ( k p v ) , s + r ( ( k p v ) ( k 1 ) / 2 ) } m a x { r k , s + r ( k ( k 1 ) / 2 ) } < m a x { k / k , k / ( k + 1 ) + ( k + 1 ) / 2 k } = k / ( k + 1 ) + 1 / ( 2 k ) + 1 / 2 < ( k + 1 ) / ( k + 1 ) + 1 / 2 = 3 / 2  ☐

2.4. Step 5.3

For the final case in Step 5 of our algorithm, we apply a variant of the algorithm by Ebenlendr et al. [7]. First we give a brief explanation of their original algorithm that has approximation ratio 7 / 4 .
Let E B be the set of big edges and let G B = ( V , E B ) be the subgraph of G consisting of big edges. If O P T 1 , every connected component of G B with b vertices contains at most b edges, which implies that each component has at most one cycle. For each connected component, identify a cycle if it exists, then orient every big edge not in the cycle away from the cycle and remove each oriented edge. Add the weight of each oriented big edge to the dedicated load of the endpoint farther from the cycle. G B is now a disjoint union of trees and cycles.
As shorthand, if v is a vertex and e is an edge, v e means “v is incident to e”. For any T G , let
L ( T ) = { ( v , e ) V × E | v is a leaf of T , v e , and e T }
where each ( v , e ) is called a leaf pair of T. Consider any tree T G B . Assuming O P T 1 , since T has one more vertex than edges, at most one edge in the set of leaf pairs can be oriented away from its leaf. This leads to what is called the tree constraint (Tree T) in linear program 1 (LP1) shown below, which is a relaxation of an integer program formulation of the graph balancing problem. A variable x e v is defined for each edge e E and endpoint v of e. If x e v = 1 , e is oriented towards v. If 0 < x e v < 1 , we say that e is fractionally oriented towards v.
Linear program 1 (LP1)
x e u + x e v = 1 for all e = { u , v } E q v + e | v e p e x e v 1 for all v V ( v , e ) L ( T ) p e x e v ( v , e ) L ( T ) p e 1 for each T G B ( Tree T ) x e v 0 for all e E and v e .
Solve LP1 to obtain a fractional solution x . As a brief remark, there can be exponentially many trees, but there is a separation oracle that can be used to solve LP1 in polynomial time with the ellipsoid method [7]. Let E x = { e E | 0 < x e u < 1 for u e } . Also, let G x = ( V , E x ) and G x B = ( V , E x E B ) . If a feasible solution is not found for LP1, then O P T > 1 .
The algorithm then considers fractionally oriented edges in G x , and performs a rounding procedure to determine their final orientations. It is assumed that as edges are oriented, G x and G x B are updated accordingly. If there is a vertex v of degree 1 in G x and 0 < x e v < 1 for edge e = { u , v } then
  • Leaf assignment: if p e x e u 3 / 4 , e is oriented towards v;
  • Tree assignment: if p e x e u > 3 / 4 note that e then is a big edge and the connected component of G x B containing e must be a tree T. Orient all edges in T away from v.
Finally, if no vertex v as above is found, then there must be a cycle. If so, perform a walk around the cycle changing the values x e u of the edges in the cycle by the minimum amount δ that makes at least one of these values zero and the loads on the vertices remain unchanged. Note that when traversing G x to find a cycle, big edges are taken in priority over small edges. This step is called rotation. The algorithm terminates once G x no longer has an edge.
The rounding performed by a leaf assignment increases the load of a vertex u by at most 3 / 4 if the edge e under consideration is big or it increases by at most 1 / 2 if e is small. Furthermore, a tree assignment can increase the load of a vertex u by at most 1 / 4 . A vertex u can have its load increased by either only one leaf assignment or by a tree assignment plus a leaf assignment involving a small edge. In either case the maximum load of a vertex is at most 7 / 4 . Note that a rotation does not change loads.
Now we show how to modify this algorithm for our problem.
Lemma 4. 
For every positive integer k 2 , there is a polynomial-time algorithm for the graph balancing problem with two rational weights r , s , where 1 / ( k + 1 ) < r 1 / k and 1 / 2 < s < ( k 1 ) / k that either finds a solution of value at most 3 / 2 or proves that O P T > 1 .
Proof. 
We make the following modifications to the algorithm in [7]. Consider any tree T G B . Every big edge e has weight p e = s , so we simplify the tree constraint to
( v , e ) L ( T ) s x e v ( v , e ) L ( T ) s s ( v , e ) L ( T ) x e v | L ( T ) | 1
Also, in the rounding procedure of [7] we change the leaf assignment and tree assignment:
  • New leaf assignment: if p e x e u 1 / 2 , e is oriented towards v.
  • New tree assignment: if p e x e u > 1 / 2 , then e is a big edge and the connected component of G x B containing e is a tree T. Orient all edges in T away from v.
Use the algorithm of Ebenlendr et al. [7] with the above modifications. If no fractional solution is found then no orientation exists; report FAIL if this is the case. Since modifying the above threshold from 3 / 4 to 1 / 2 will still allow all fractionally oriented edges to be rounded, the algorithm still finds an orientation in polynomial time.
We can extend the arguments by Ebenlendr et al. [7] to show that the algorithm has approximation ratio 3 / 2 in our case. It is not hard to modify the proof of Theorem 1 in [7] to show that the following conditions are maintained by each vertex v V before and after each step in the rounding procedure.
(1)
The load of v is at most 3 / 2 .
(2)
If e G x is incident on v, then v has load at most 1 + ( s 1 / 2 ) .
(3)
If e B is a big edge in G x B incident on v, the load of v is at most 1.
(4)
For any tree T that is a subgraph of G x B , the tree constraint (Tree T) is never violated.
For completeness we sketch a proof that the above conditions hold throughout the rounding procedure. At the beginning of the algorithm, after the modified LP1 is solved, all the conditions above are satisfied and the load of each vertex is at most 1. Next, we show conditions (1)–(4) are preserved for any vertex that changes its load during the rounding procedure.
  • Tree assignment: In a tree assignment, only vertices in the tree T G x B containing big edge e = { u , v } for which p e x e u > 1 / 2 and v is a leaf of T have their loads modified. Every vertex in T is incident with a big edge in G x . Hence before this step is performed, by condition (3), each one of these vertices has load at most 1. Consider vertex u in T after the tree assignment has been performed. If u = v , the load of v is decreased as big edges are oriented away from v. If u v , there exists a path P in T from u to v. Say this path begins at edge e . As P is a subtree of T, it must satisfy our tightened tree constraint of LP1 and so
    x e v + x e u | L ( P ) | 1 = 2 1 = 1 x e u ( 1 x e v ) = x e u
    All the edges in P are big, so s x e u s x e u > 1 / 2 . Hence, the load of u increases by at most s s x e u < s 1 / 2 , and conditions (1) and (2) are satisfied for vertex u . Note that since fractional edge assignments in T have been eliminated, u cannot be incident on a big edge following a tree assignment. Thus, condition (3) does not apply to this case and condition ( 4 ) is satisfied.
  • Leaf assignment: In a leaf assignment, edges are oriented towards a leaf vertex. Say vertex v is a leaf. We consider two cases for edge e = { u , v } such that p e x e u 1 / 2 : p e > 1 / 2 , and p e 1 / 2 .
    If p e > 1 / 2 , then v is incident on a big edge and so by condition (3), the load of v is at most 1 before the leaf assignment. Since p e x e v p e = x e u p e 1 / 2 , then following the leaf assignment, the load of v is at most 1 + 1 / 2 = 3 / 2 .
    If p e 1 / 2 , then p e = r . By condition (2), before the leaf assignment the load of v is at most 1 + ( s 1 / 2 ) . So after the leaf assignment the load of v is at most
    1 + ( s 1 / 2 ) + r 1 + ( k 1 ) / k 1 / 2 + 1 / k = 3 / 2
    In any case, after a leaf assignment v is isolated in G x , so conditions ( 1 ) ( 4 ) are satisfied.
  • Rotation: The rotation step does not change the vertex loads so conditions (1)–(3) hold. The argument showing that condition (4) holds is essentially the same as that in [7] and since it is a bit lengthy we omit it here.
Therefore, by condition (1), the load of a vertex is at most 3 / 2 .  ☐

2.5. Proof of Approximation Algorithm

Finally we prove our algorithm is indeed a 3 / 2 -approximation algorithm for GBP2W.
Theorem 5. 
There is a 3 / 2 -approximation algorithm for the graph balancing problem with two weights.
Proof. 
Recall that in Step 1, algorithm GB2W scales the edge weights and vertex dedicated loads by T, then sets T = 1 . Step 3 of algorithm GB2W invokes the algorithm of Lenstra et al. [2]. This algorithm finds a fractional solution using linear programming, and then it performs a two-step rounding procedure. If the value of an optimum solution is O P T 1 , the first step guarantees that the load of any vertex is at most 1; the second step orients at most one more edge towards each vertex. Hence, either an orientation with maximum load 1 + m a x { r , s } 1 + 1 / 2 = 3 / 2 is found, or O P T > 1 and an orientation is not produced. For Steps 4 and 5 of algorithm GB2W, Lemmas 1–4 ensure that either a solution of value at most 3 / 2 is found or O P T > 1 . Therefore, if O P T 1 , Step 6 of the algorithm returns an orientation γ; otherwise it returns FAIL.
The binary search then is guaranteed to find a value T O P T and an orientation with load at most 3 T / 2 . For a weighted multigraph G = ( V , E , p , q ) , since O P T | E | s , the number of iterations of the binary search is at most O ( log | E | + log s ) and since algorithm GB2W has polynomial running time, the overall running time is also polynomial in the size of the input.  ☐

3. Conclusions

We have presented a 3/2-approximation algorithm for the graph balancing problem with two weights, which meets the best-known inapproximability bound 3/2. We hope our result further motivates other researchers to investigate the 3/2 to 2 inapproximability-to-approximation gap for the makespan minimization problem on unrelated parallel machines.

Acknowledgments

The second author was partially supported by the Natural Sciences and Engineering Research Council of Canada, grant 04667-2015 RGPIN.

Author Contributions

The results in this paper were developed by both authors. Daniel Page prepared the manuscript, and Roberto Solis-Oba commented and contributed to the preparation of the final manuscript.

Conflicts of Interest

The authors declare no conflict of interest.

References

  1. Graham, R.L.; Lawler, E.L.; Lenstra, J.K.; Kan, A.R. Optimization and approximation in deterministic sequencing and scheduling: A survey. Ann. Discrete Math. 1979, 5, 287–326. [Google Scholar]
  2. Lenstra, J.K.; Shmoys, D.B.; Tardos, É. Approximation algorithms for scheduling unrelated parallel machines. Math. Program. 1990, 46, 259–271. [Google Scholar] [CrossRef]
  3. Shchepin, E.V.; Vakhania, N. An optimal rounding gives a better approximation for scheduling unrelated machines. Oper. Res. Lett. 2005, 33, 127–133. [Google Scholar] [CrossRef]
  4. Gairing, M.; Monien, B.; Woclaw, A. A faster combinatorial approximation algorithm for scheduling unrelated parallel machines. Theor. Comput. Sci. 2007, 380, 87–99. [Google Scholar] [CrossRef]
  5. Asahiro, Y.; Jansson, J.; Miyano, E.; Ono, H.; Zenmyo, K. Approximation algorithms for the graph orientation minimizing the maximum weighted outdegree. J. Comb. Optim. 2011, 22, 78–96. [Google Scholar] [CrossRef]
  6. Chakrabarty, D.; Khanna, S.; Li, S. On (1, ε)-restricted assignment makespan minimization. In Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms, San Diego, CA, USA, 4–6 January 2015; pp. 1087–1101.
  7. Ebenlendr, T.; Krčál, M.; Sgall, J. Graph balancing: A special case of scheduling unrelated parallel machines. Algorithmica 2014, 68, 62–80. [Google Scholar] [CrossRef]
  8. Kangbok, L.; Leung, J.Y.-T.; Pinedo, M. A note on graph balancing problems with restrictions. Inf. Process. Lett. 2009, 110, 24–29. [Google Scholar]
  9. Kolliopoulos, S.G.; Moysoglou, Y. The 2-valued case of makespan minimization with assignment constraints. Inf. Process. Lett. 2013, 113, 39–43. [Google Scholar] [CrossRef]
  10. Page, D.R. Approximation algorithms for subclasses of the makespan problem on unrelated parallel machines with restricted processing times. SOP Trans. Appl. Math. 2015, 2, 20–27. [Google Scholar] [CrossRef]
  11. Svensson, O. Santa claus schedules jobs on unrelated machines. SIAM J. Comput. 2012, 41, 1318–1341. [Google Scholar] [CrossRef]
  12. Vakhania, N.; Hernandez, J.A.; Werner, F. Scheduling unrelated machines with two types of jobs. Int. J. Prod. Res. 2014, 52, 3793–3801. [Google Scholar] [CrossRef]
  13. Verschae, J.; Wiese, A. On the configuration-LP for scheduling on unrelated machines. J. Sched. 2014, 17, 371–383. [Google Scholar] [CrossRef]
  14. Ebenlendr, T.; krčál, M.; Sgall, J. Graph balancing: A special case of scheduling unrelated parallel machines. In Proceedings of the Nineteenth Annual ACM-SIAM Symposium on Discrete Algorithms, San Francisco, CA, USA, 20–22 January 2008; pp. 483–490.
  15. Asahiro, Y.; Jansson, J.; Miyano, E.; Ono, H.; Zenmyo, K. Approximation algorithms for the graph orientation minimizing the maximum weighted outdegree. In Proceedings of the Third International Conference on Algorithmic Aspects in Information and Management, Portland, OR, USA, 6–8 June 2007; pp. 167–177.
  16. Hall, P. On representatives of subsets. J. London Math. Soc. 1935, 10, 26–30. [Google Scholar]
Figure 1. The flow network N for the case when 1 / ( k + 1 ) < r 1 / k and k / ( k + 1 ) s 1 . Shaded nodes represent big edge nodes, and each black node is a buffer node associated with one vertex node. Arcs that are unlabelled have flow capacity 1.
Figure 1. The flow network N for the case when 1 / ( k + 1 ) < r 1 / k and k / ( k + 1 ) s 1 . Shaded nodes represent big edge nodes, and each black node is a buffer node associated with one vertex node. Arcs that are unlabelled have flow capacity 1.
Algorithms 09 00038 g001 1024
Figure 2. The modified flow network constructed for the case when 1 / ( k + 1 ) < r 1 / k and ( k 1 ) / k s < k / ( k + 1 ) . Shaded nodes represent big edge nodes, and every black node is a buffer node associated with a vertex node. Assume arcs that are unlabelled have flow capacity 1.
Figure 2. The modified flow network constructed for the case when 1 / ( k + 1 ) < r 1 / k and ( k 1 ) / k s < k / ( k + 1 ) . Shaded nodes represent big edge nodes, and every black node is a buffer node associated with a vertex node. Assume arcs that are unlabelled have flow capacity 1.
Algorithms 09 00038 g002 1024
Algorithms EISSN 1999-4893 Published by MDPI AG, Basel, Switzerland RSS E-Mail Table of Contents Alert
Back to Top