APPROXIMATE ALGORITHMS FOR UNRELATED MACHINE SCHEDULING TO MINIMIZE MAKESPAN

. We study two unrelated machine scheduling problems with machine dependent release dates to minimize the makespan. For the case with ﬁxed processing time where processing job j on machine i requires time p ij and incurs a cost of c ij , we derive a 2-approximation algorithm. For the problem with variable processing times where the cost increases linearly as the processing time decreases, we propose a (2 + (cid:15) )-approximation algorithm.


1.
Introduction. The unrelated parallel machine scheduling problem to minimize the makespan, R||C max in the three-field notation (see [5]), is one of the classic NPhard problems in combinatorial optimization. This problem is mentioned in many works concerning approximation algorithms ( [12,13]), and it has received much attention in the past few decades with many extant approximation algorithms, among which the currently best 2-approximation algorithm is due to [7], who also show that the problem cannot be approximated within a factor smaller than 3/2, unless P = N P . Recently, a slightly better algorithm that achieves (2 − 1/m)approximation is obtained by [9] (m is the number of unrelated machines). A special case of this problem where jobs are restricted to a subset of machines, i.e., p ij ∈ {p j , +∞}, has attracted more and more concern in recent years. Ebenlendr et al. [3] propose a 1.75-approximation algorithm when each job is restricted to at most two machines. A polynomial time algorithm is provided that estimates the optimal makespan up to a factor of ( 33 17 + ) for the restricted assignment problem in [11]. A relevant problem with additional cost c ij if job j is processed on machine i is considered by [10]. Shmoys and Tardos [10] prove that, if a schedule with total cost C and makespan T exists, a schedule with total cost C and makespan 2T can be found in polynomial time. Their proof relies on rounding the solution of an LP relaxation. They obtain the same result even for a more general version of the problem, i.e., the variable model, in which the processing time p ij of any job-machine pair (i, j) is a linear decreasing function of the associated cost c ij . Another variant of the unrelated parallel machine scheduling with resource dependent processing times is considered in [6]. They also use LP rounding technique to obtain a 4approximation algorithm and an improved 3.75-approximation algorithm for the problem. Given an energy budget, a (2 + )-approximation algorithm is given for the makespan minimization problem under two different settings (see [1]). We refer to [2,4,8] and references therein for other variants of unrelated parallel machine scheduling problems.
The unrelated machine scheduling problem we are interested in this work is stated as follows: We are given a job set {J 1 , . . . , J n } and a machine set {M 1 , . . . , M m } respectively. Each job is to be processed without interruption by exactly one machine. Job J j has a release time r ij (a nonnegative integer) on machine M i (i = 1, . . . , m, j = 1, . . . , n). We are also provided with a constant C, which is an upper bound on the total cost for processing jobs {J 1 , . . . , J n }. The objective is to find a schedule that minimizes the makespan with total cost no more than C.
In this paper we consider two versions of the generalized assignment problem, namely, the fixed model and the variable model. These two models may arise from the following actual conditions: Due to their difference in skills, the workers spend different times and get different pays when executing the same task. Here the workers correspond to the machines in our problem, and their pays are a counterpart to the processing costs. The decision maker always wants to finish all the tasks as soon as possible subject to the condition that the total cost he pays to the workers does not exceed a certain budget. In the fixed model, the processing time and the pay are fixed; and in the variable model, the pay is a linearly decreasing function of the processing time-and hence slower works are paid less.
The linear program formulations we consider are almost the same as those proposed by [10]. The authors in [10] mainly introduce a new rounding technique and show how to obtain a required schedule from a feasible solution of a certain linear program. Our main contribution lies in the following: We declare that the linear programming model possesses some properties (Theorem 3.4), which serve as the foundation for a subsequent binary search procedure to carry through.
The remainder of this paper is organized in the following way: We present the 2-approximation and the (2+ )-approximation algorithms for the fixed and variable models in sections 2 and 3, respectively. We then offer some concluding remarks in Section 4.

2.
A 2-approximation algorithm for the fixed model. For this model, Job J j has processing time p ij (a positive integer) when processed on machine M i and thus incurs a cost c ij . Remember that job J j has release time r ij (a nonnegative integer) on machine M i . Our goal is to find a schedule that minimizes the makespan with the total cost no more than C.
Note that LP(T * ) admits a feasible solution since IP(T * ) has a feasible solution.
We denote by M ij the machine with the minimum cost for job J j (j = 1, 2, . . . , n), i.e., i j = arg min i {c ij }. Meanwhile we have the following notations: Job J j is assigned to machine M ij , and the jobs on each machine are scheduled in an increasing order of their release times. We denote by U 0 the makespan of the schedule obtained in such a way. Obviously we have U 0 ≤ r max + p sum . Assume that L 0 = 0.
The minimum positive integer with which LP(t) admits a feasible solution is denoted by T . Clearly we have T ≤ T * , where T can be found by conducting a binary search over the interval [L 0 , U 0 ] after at most log(r max + p sum ) steps.
Assume that x LP is a feasible solution for LP( T ). Then x LP can be converted into a feasible solution x IP for the following integer program using the technique in [10]. c ij x ij ≤ C, Here p max = max{p ij |x LP ij > 0}. The rounding procedure of [10] ensures that in x IP , except for at most one job on each machine (called an extra job if exists), the total processing time of all the other jobs is no more than T (for details see the proof of Theorem 2.1 in [10]).
This property allows us to respect the release time of each job by ordering the jobs on each machine such that all the jobs start at T unless there exist some extra jobs on some machines, in which case the extra job of each machine is processed first before any other job. Hence we can construct a feasible schedule with makespan no more than 2 T ≤ 2T * .
In conclusion, we obtain a 2-approximation algorithm as follows: Algorithm 2.1.
Step 1: Find the minimum positive integer T with which LP(t) admits a feasible solution by binary search.
Step 2: Solve LP( T ) and obtain a feasible solution x LP .
Step 3: Transform x LP into a solution x IP for the integer program (3) by the rounding technique of [10].
Step 4: Construct a schedule from x IP , while respecting the release time of each job.

3.
A (2 + )-approximation algorithm for the variable model. In this model, job J j may be processed by machine M i in t ij time units, where l ij ≤ t ij ≤ u ij ; and the cost linearly increases as the processing time of each job decreases. Accordingly, we are also given the minimum cost c u ij and the maximum cost c l ij of assigning job J j to machine M i . The cost associated with processing J j on machine M i in time t ij is λc l ij + (1 − λ)c u ij when t ij is written as t ij = λl ij + (1 − λ)u ij for 1 ≥ λ ≥ 0. Job J j has release time r ij ≥ 0 on machine M i . We shall find a schedule that minimizes the makespan with the total cost no more than C.
We still denote by π * the optimal schedule to this model, and by T * the makespan for π * . A key observation is that we can always reduce u ij ,j to T * −r ij ,j for those J j satisfying r ij ,j + u ij ,j > T * (J j is processed on machine M ij in π * ). This reduction maintains both the structure and the makespan of the optimal schedule. The above observation motivates the following definition.
Definition 3.1. For any given parameter t > 0 and machine-job pair (i, j), we define adjusted upper bound u ij (t) and the corresponding cost c u ij (t) in the following way: We now relax the variable model as the following linear program.
In the above, there are two variables x l ij and x u ij for each machine-job pair (i, j), where i = 1, . . . , m and j = 1, . . . , n. A feasible schedule with makespan t directly corresponds to a feasible solution to the linear program. Job J j is assigned to machine M i if x l ij + x u ij = 1, and the assigned time is l ij x l ij + u ij (t)x u ij with the associated cost c l ij x l ij + c u ij (t)x u ij . Since T * is the makespan for the optimal schedule, LP 1 (T * ) admits a feasible solution from the above discussion. We now relax LP 1 (t) to the following linear program.
We first give two lemmas as preliminary.
Proof. From the definition of u ij (t), the event r ij + u ij (t 2 ) > t 2 occurs only when r ij + l ij > t 2 . Hence, we get r ij + l ij > t 1 , implying that r ij + u ij (t 1 ) = r ij + u ij ≥ r ij + l ij > t 1 .
Proof. We consider the following three cases according to the adjusted upper bounds u ij (t 1 ) and u ij (t 2 ).
We are ready to present a property for the program LP 2 (t), which serves as the foundation for the subsequent binary search procedure.
Lemma 3.3 implies that u ij (t 1 ) ≤ u ij (t 2 ) for any machine-job pair (i, j) satisfying r ij + l ij ≤ t 1 . The relationship between the cost and the processing time implies is not a feasible solution for LP 2 (t 2 ), there must be at least one We can transform x l(1) ij , x u(1) ij into a feasible solution for LP 2 (t 2 ) in the following way.
As before, we denote by M ij the machine with the minimum cost for job J j , i.e., i j = arg min i {c u ij }. Meanwhile we have the following notations: Job J j is processed on machine M ij with processing time u ij ,j (j = 1, 2, . . . , n); The jobs on each machine are scheduled in an increasing order of their release times. We denote by U 0 the makespan of the schedule obtained in such a way. Obviously we have U 0 ≤ r max + p sum . Let L 0 = 1 2 min i,j {l ij }. Note that L 0 > 0, and the feasible set of LP 2 (L 0 ) is φ. We execute the following binary search procedure.
If LP 2 (t) has a feasible solution then U k ← t and L k ← L k−1 else L k ← t, and U k ← U k−1 End-while The binary search procedure terminates when U k ≤ (1 + )L k , i.e., U k − L k ≤ L k , which is equivalent to U0−L0 2 k ≤ L k . The procedure terminates after at most log( U0 L0 ) ≤ log( rmax+psum L0 ) recursions. We now have U k ≤ (1 + )L k < (1 + )T * , implying that LP 2 (L k ) is not feasible. Theorem 3.4 therefore implies that L k < T * since LP 2 (T * ) admits a feasible solution.
Suppose x l ij , x u ij (i = 1, . . . , m, j = 1, . . . , n) is a feasible solution for LP 2 (U k ). We consider the following linear program along with the construction of a feasible solution x ij .