A $(2 + \epsilon)$-approximation for precedence constrained single machine scheduling with release dates and total weighted completion time objective

TL;DR

This paper presents a $(2 + )$-approximation algorithm for single machine scheduling with precedence constraints and release dates, effectively addressing a recent conjecture in the field.

Contribution

It introduces a novel approximation algorithm that achieves a $(2 + )$-approximation for the problem, settling a recent conjecture.

Findings

Achieves a $(2 + )$-approximation ratio.

Provides a new approach to scheduling with precedence constraints.

Settles a recent open conjecture in the domain.

Abstract

We give a $(2 + \epsilon)$-approximation algorithm for minimizing total weighted completion time on a single machine under release time and precedence constraints. This settles a recent conjecture made in [18]

Equations

$$\text{(LP) }\min$$

$$s.t.$$

$$\sum _{j\in U}{p}_j{C}_j\ge r_{\min }(U)p(U)+\frac{1}{2}p(U{)}^2$$

$$p_j{C}_j\ge p_j(r_j+p_j/2).$$

$$p(U)C_{\max }(U)\ge \sum _{j\in U}{p}_j{C}_j\ge r_{\min }(U)p(U)+\frac{1}{2}p(U{)}^2,$$

$$C_j^{\sigma }\le t+2C_j-2r_{\min }(U).$$

$$C_j^{\sigma }\le 2C_j.$$

$$r_{\min }(U)>s,$$

$$C_j^{\sigma }=t+P(U)\le t+2C_{max}(U)-2r_{\min }(U)=t+2C_j-2r_{\min }(U).$$

$$C_j^{\sigma }\le t+2C_j-2r_{\min }(U)<t+2C_j-2s.$$

$$\sum _j{w}_j{C}_j^{\sigma }\le 2\sum _j{w}_j{C}_j=2Z_{LP}\le 2\text{textsc}Opt.$$

$$\max \{3t_i,r_{\max }(J_i)\}+P(J_i).$$

$$P(J_i)\le 2C_{\max }(J_i)\le 2t_{i+1}.$$

$$\max \{3t_i,r_{\max }(J_i)\}+P(J_i)\le t_{i+1}+2t_{i+1}=3t_{i+1}.$$

$$\mathbb{E}[t_{i(j)}]=C_j\mathbb{E}[e^{-x}]=\frac{C_j}{a}\underset{x=0}{\overset{x=a}{\int }}{e}^{-x}dx=\frac{C_j(1-e^{-a})}{a}<\frac{C_j}{a}=\frac{ϵC_j}{3}.$$

$$\sum _i\text{textsc}{Opt}_i\le \sum _i\text{textsc}Opt{|}_i+3\sum _i\sum _{j\in J_i}{w}_j{t}_i=\text{textsc}Opt+3\sum _j{w}_j{t}_{i(j)}.$$

$$\mathbb{E}[\sum _i\text{textsc}{Opt}_i]\le \text{textsc}Opt+3\sum _j{w}_j\mathbb{E}[t_{i(j)}]\le \text{textsc}Opt+\frac{3}{a}\sum _j{w}_j{C}_j\le (1+\frac{3}{a})\text{textsc}Opt.$$

$$\sum _i\mathbb{E}[\alpha \text{textsc}{Opt}_i]=\alpha \sum _i\mathbb{E}[\text{textsc}{Opt}_i]\le \alpha (1+ϵ)\text{textsc}Opt.$$

$$C_j^{\prime }\le C_j^{\ast }+\sum _{k\le j}ϵp_k=C_j^{\ast }+ϵ\sum _{k\le j}{p}_k\le (1+ϵ)C_j^{\ast }.$$

$${\log }_2\left(\frac{(1+ϵ)\beta L}{L}\right)={\log }_2((1+ϵ)\beta )=O(\log \beta ).$$

$$T=\bigcup _{j\in A}\left]S_j^{\prime },S_j^{\prime }+p_j\right[.$$

$$\sum _j{w}_j{C}_j^{\sigma }\le 2\sum _j{w}_j{C}_j=2Z_{LP}\le 2\text{textsc}{Opt}^{\prime }\le 2(1+ϵ)\text{textsc}Opt.$$

$$t>2s.$$

$$r_{\min }^{\prime }(U)>s\ge S_k^{\prime }.$$

$$r_{\min }^{\prime }(U)\ge S_k^{\prime }+p_k\ge p_k=t-s>t/2.$$

$$C_j^{\sigma }\le t+2C_j-2r_{\min }^{\prime }(U)<2C_j.$$

$$T=\bigcup _{i\in B}\left]S^{(i)},S^{(i)}+(1+ϵ{)}^i\right[.$$

Full text

1 Introduction

We consider the problem of minimizing the total weighted completion time on a single machine under precedence and release time constraints, denoted by $1|r_{j},prec|\sum w_{j}C_{j}$ in the standard notation from [8]. An instance is given by a set of jobs $J=\{1,2,\dots,n\}$ and for each $j\in J$ an integer processing time $p_{j}\geq 0$, release time $r_{j}\geq 0$, and weight $w_{j}\geq 0$. Further, we are given a partial order $\prec$ on $J$ representing the precedence constraints between the jobs. (The partial order is transitive, i.e., if $h\prec j$ and $j\prec k$ then $h\prec k$.) A schedule is defined by a start time $S_{j}\geq 0$ for each $j$ such that no job starts before its release time, i.e., $S_{j}\geq r_{j}$, and no two jobs are processed at the same moment, i.e., for any pair $j,k$ either $S_{j}\geq S_{k}+p_{k}$ or $S_{k}\geq S_{j}+p_{j}$, where the latter must hold in case $j\prec k$. The cost of a schedule is the weighted sum of job completion times, $\sum_{j}w_{j}C_{j}$, where $C_{j}=S_{j}+p_{j}$, and the goal is to minimize cost. We say that an algorithm is an $\alpha$-approximation algorithm ($\alpha\geq 1$) if for any instance the cost of the algorithm’s schedule is at most $\alpha$ times the optimal cost.

The special case without release time constraints ($r_{j}=0$ for all jobs $j$) has been well studied but the computational complexity is still not completely settled. Several 2-approximation algorithms are known [4],[5],[9],[10],[12],[14] and Bansal and Khot [2] showed that no $(2-\epsilon)$-approximation algorithm exists assuming a variant of the unique games conjecture is true. It is yet unknown if this lower bound holds under the common assumption $\mathcal{P}\neq\mathcal{NP}$. For the problem with release dates, a $3$-approximation algorithm was given by Schulz [14] and Hall et al. [9]. Schulz and Skutella [15] gave an $e+\epsilon$-approximation algorithm by sequencing jobs in order of random $\alpha$-points. Recently, Skutella [18] improved the ratio to $\sqrt{e}/(\sqrt{e}-1)<2.542$ and conjectured that a $(2+\epsilon)$-approximation algorithm exists. See the papers [3],[1], and [18] for a more detailed overview of approximation results. Here, we give a positive answer to the conjecture by presenting a polynomial time $(2+\epsilon)$-approximation algorithm for any constant $\epsilon>0$.

Our algorithm works as follows. First, we show that with loss of a factor $(1+\epsilon)$ we can decompose the problem into subproblems that can be solved independently. The final schedule is obtained by placing the schedules for subproblems one after the other. Each subproblem has the property that all jobs are scheduled in an interval $[L,\beta L]$ where $L>0$ and $\beta>1$ is a constant depending on $\epsilon$ only. This property is exploited to get a $(2+\epsilon)$-approximation for subproblems. The decomposition is done at random but is easy to derandomize. For each subproblem we work as follows. We guess the approximate start time of $O(1/\epsilon)$ jobs and add that information to the LP. Then we solve the LP and apply list scheduling in order of LP-values. For each subproblem we only need a polynomial number of guesses and return the best solution found.

2 List Scheduling in order of LP-values

A common technique for minimizing total weighted completion time in scheduling is to apply list scheduling in an order that is derived from a linear program relaxation. (See for example [14],[9],[11],[15].) In list scheduling, all jobs are in a list and are added to the schedule one by one in an order derived from the list. In the presence of release dates, there are two intuitive versions of List Scheduling. The most natural one is to schedule job as early as possible precisely in the order of the list. Note that this may cause the machine to stay idle while jobs (later in the list) are available. Schulz [14] showed that for this version, List Scheduling in order of LP-values is a 3-approximation algorithm for $1|r_{j},prec|\sum w_{j}C_{j}$. Alternatively, one may schedule at any moment that the machine is idle, the job that comes earliest in the list among the available jobs. It is this latter variant that we use here. Possibly, our approach in this paper can be modified to work with the natural version of List Scheduling but we do not see a proof that is substantially easier than the proof presented here. In our algorithm we shall relabel jobs before applying list scheduling, i.e., we assume w.l.o.g that the ordered list is $1,2,\dots,n$. Further, we assume this order is consistent with the precedence constraints, i.e., $j<k$ whenever $j\prec k$.

Given a (partial) schedule, we say that the machine is available at time $t$ if for any job in the schedule either $C_{j}\leq t$ or $S_{j}\geq t$. We say that a job $j$ is available at time $t$ if (i) $r_{j}\leq t$, (ii) job $j$ was not scheduled yet, (iii) all jobs $k$ with $k\prec j$ have been completed.

Algorithm List Scheduling (LS):

Let the jobs $J=\{1,2,\dots,n\}$ be labeled such that $j<k$ whenever $j\prec k$. At any moment $t$ that the machine is available, start the job with the smallest index $j$ among the available jobs.

We assume w.l.og. that for any given instance, release dates are consistent with precedence constraints, i.e., we assume that $r_{j}\leq r_{k}$ if $j\prec k$. (In Section 4, we modify release dates but maintain consistency.)

Lemma 1

*If release dates are consistent with precedence constraints, i.e., $r_{j}\leq r_{k}$ if $j\prec k$, then LS has the following property:

If at time $t$ the machine is available and there is is a job $j$ with $r_{j}\leq t$ and job $j$ has not started yet, then LS starts some job $h\leq j$ at time $t$.*

Proof For any job $h\prec j$ it holds that $r_{h}\leq r_{j}$. Hence, if $j$ is not available at time $t$ then there must be some job $h\prec j$ that is available at time $t$. $\hfill\Box$

Linear programs for scheduling problems typically use three types of variables: Time-indexed variables (indicating wether job $j$ is processed at time $t$), linear ordering variables (indicating whether job $j$ precedes job $k$), and completion time variables. An elegant LP-fomulation for our problem was introduced by Queyranne [13] and is based on completion time variables only. It was later refined by Goemans [6],[7] to handle release times. Altough the number of constraints in linear program (LP) is exponential, they can separated in polynomial time by efficient submodular function minimization [6]

[TABLE]

In constraint (2), $p(U)=\sum_{j\in U}p_{j}$ and $r_{\min}(U)=\min\{r_{j}\mid j\in U\}$. For later use, we define $r_{\max}(U)=\max\{r_{j}\mid j\in U\}$ and (given a solution) define the values $C_{\min}(U)$ and $C_{\max}(U)$ in the obvious way. The linear program (LP) can obviously be strengthened by adding the constraint $C_{j}\geq r_{j}+p_{j}$. For our analysis it is enough to have the following implied inequality.

Lemma 2

$C_{j}\geq r_{j}+p_{j}/2$* for any $j\in J$.*

Proof Let $U=\{j\}$. Then the second LP-constraint (2) states

[TABLE]

$\hfill\Box$

For any schedule $\sigma$ and $U\subseteq J$ the inequality $p(U)\leq C_{\max}^{\sigma}(U)-r_{\min}(U)$ clearly must hold. The following similar but weaker inequality is implied by (LP).

Lemma 3

$p(U)\leq 2C_{\max}(U)-2r_{\min}(U)$* for any $U\subseteq J$.*

Proof From the second LP-constraint we have

[TABLE]

for any $U\subseteq J$. Dividing both sides by $P(U)$ gives $C_{\max}(U)\geq r_{\min}(U)+\frac{1}{2}p(U)$ which is the inequality of the lemma. $\hfill\Box$

Algorithm LP+LS:

Solve the linear program (LP). Relabel such that $C_{1}\leq...\leq C_{n}$ and such that $j<k$ if $j\prec k$.

• 2)

Run list scheduling (LS) in the order $1,\dots,n$. Let $C^{\sigma}_{j}$ be the completion time of job $j$ in the final schedule $\sigma$.

The algorithm as defined above has an unbounded approximation ratio as shown by the following example. Let $p_{1}=1,r_{1}=1$, $p_{2}=M,r_{2}=0,w_{1}=M$ and $w_{2}=0$. For large $M$, the optimal schedule places jobs in the order $1,2$ and has value $2M$. The algorithm however, will schedule job $2$ first since it is the only available job at time [math] which gives value $(M+1)M$. If jobs are relatively small compared to their release time ($p_{j}\leq r_{j}$ for all $j$) then the algorithm is a $2$-approximation as we show below. The proof follows easily from the lemma below. We shall use this lemma again in Section 4.

Lemma 4

Let $\sigma$ be a schedule returned by algorithm LP+LS. Let $j\in J$ and let $t$ be the smallest value such that the interval $[t,C^{\sigma}_{j}]$ has no idle time and only contains jobs $h\leq j$. Let $U$ be the set of jobs processed in the interval $[t,C^{\sigma}_{j}]$. Then,

[TABLE]

Further, if no job completes at time $t$ then

[TABLE]

If some job $k$ completes at time $t$ then

[TABLE]

where $s$ is the start time of the job $k$.

0$s$ t$$j$$k$$C_{j}^{\sigma}$$U

Proof Note that $U\neq\emptyset$ since $j\in U$. Further, $C_{j}=C_{\max}(U)$ since only jobs with $h\leq j$ are in $U$ and jobs are relabeled in Step 1. Now (3) follows directly from Lemma 3.

[TABLE]

If no job completes at time $t$ then either $t=0$ or the machine is idle just before time $t$. In the former case, it follows from (3) that $C_{j}^{\sigma}\leq 0+2C_{j}-2r_{\min}(U)\leq 2C_{j}$. In the latter case it follows from Lemma 1 that $t=r_{\min}(U)$ which, together with (3), implies $C_{j}^{\sigma}\leq 2C_{j}-r_{\min}(U)\leq 2C_{j}$.

Now assume job $k$ completes at time $t$. If $r_{\min}(U)\leq s$ then, by Lemma 1 some job $h\leq j$ must start at time $s$. However, $k>j$. Hence we must have $r_{\min}(U)>s$. $\hfill\Box$

Theorem 1

If $p_{j}\leq r_{j}$ for all $j\in J$ then algorithm LP+LS is a 2-approximation.

Proof Apply Lemma 4 to an arbitrary job $j$. If no job completes at time $t$ then by (4) $C_{j}^{\sigma}\leq 2C_{j}$. On the other hand, if some job $k$ completes at time $t$ then by (3) and (5)

[TABLE]

Since $p_{k}\leq r_{k}$ we have $t=s+p_{k}\leq s+r_{k}\leq 2s$. Hence, $C_{j}^{\sigma}\leq 2C_{j}$. Now take the weighted sum over all jobs:

[TABLE]

$\hfill\Box$

Given the theorem above, the following approach leads intuitively to a 2-approximation algorithm. Imagine an unknown optimal schedule $\sigma^{\prime}$ and for each job $j$ guess if it starts before time $p_{j}$ in $\sigma^{\prime}$ and if so, guess its precise start time. Then add this information to the LP and run algorithm LP+LS. Clearly, the running time is not polynomial in general since there can be $O(n)$ of those jobs. However, in the next section we show that, with loss of a factor $1+\epsilon$ in the approximation, one can decompose any instance $I$ into subinstance $I_{1},I_{2},\dots,$ such that our guessing approach is polynomial for each of the subinstances.

3 A decomposition theorem

Margot et al. [10] and Chekuri and Motwani [4] used Sidney’s decomposition theorem [16] to show that any instance $I$ of $1|prec|\sum w_{j}C_{j}$ can be split into subinstances $I_{1},\dots,I_{q}$ such that (i) for any subinstance $I_{i}$ all initial sets $U$ satisfy $p(U)/w(U)\geq p(I_{i})/w(I_{i})$ and (ii) if $\sigma_{1},\dots,\sigma_{q}$ are $\alpha$-approximate schedules for the subinstance then placing the schedules in this order yields an $\alpha$-approximate schedule for $I$, for any $\alpha\geq 1$. Subsequently, the authors present combinatorial 2-approximation algorithms for instances with this initial set property.

In the presence of release times, Sidney’s decomposition does not hold. Here, we present a different decomposition theorem (Theorem 2) that is useful in case of release times. The underlying algorithm is given below. Note that we use the common approach of partitioning time into intervals of geometrically increasing length. In general, such a partitioning gives a significant loss in the approximation ratio. We use two techniques to ensure that the (expected) loss is no more than a factor $1+\epsilon$. First, the factor of increase is taken exponential in $1/\epsilon$. This idea was used before in [17] to get a $(1+\epsilon)$-approximation for $1|prec|\sum w_{j}C_{j}$ in case of interval-ordered precedence constraints. Secondly, we use the LP to partition the job set $J$ into subsets $J_{i}$ where $J_{i}$ is the set of jobs that have their $C_{j}$ in the $i$-th interval. Using the LP ensures that the schedule for $J_{i}$ is only a constant factor longer than the length of the $i$-th interval (Lemma 5). This property, together with the large factor of increase ($e^{3/\epsilon}$) and the randomness, ensures that the expected delay due to this partitioning is only a factor $1+\epsilon$.

For the ease of analysis we shall assume that there is no initial set $U$ with $p(U)=0$ since such set can be scheduled at time [math] and hence can be removed from the instance. What we get from this is that in any LP-solution, $C_{j}\geq 0.5$ for all $j$ (using Lemma 2 and $p_{j}$ integer).

Algorithm Decompose:

Solve the linear program (LP). Let $C_{1},\dots,C_{n}$ be the LP-values.

• 2)

Let $a=3/\epsilon$ and take $b$ uniformly at random from $[0,a]$. Let $t_{i}=e^{a(i-3)+b}$ for $i=1,2,\dots,q$. Choose $q$ large enough such that $C_{max}(J)\leq t_{q}$. Partition the jobs into $J_{i}=\{j|t_{i}\leq C_{j}<t_{i+1}\}$, $i\in\{1,2,\dots,q\}$.

• 3)

Let $I_{i}$ be the scheduling instance defined by jobs $J_{i}$ with the additional constraint that no job is allowed to start before time $3t_{i}$. For each $i$, run the algorithm described in Section 4 and let $\sigma_{i}$ be the schedule returned.

• 4)

Return $\sigma$ which is the concatenation of $\sigma_{1},\dots,\sigma_{q}$.

First, let us see that the algorithm returns a feasible schedule. Step 1 is the same as in algorithm LP+LS except that relabelling is not needed here. To ensure that $t_{1}\leq C_{\min}(J)$ we used $i-3$ in stead of just $i$ in Step 2. Note that $t_{1}=e^{b-2a}\leq e^{-a}<0.5\leq C_{\min}(J)$. Hence, Step 2 defines a partition of $J$. Further, since the partial order $\prec$ is transitive, the instances of Step 3 are well defined. (The precedence constraints between jobs in $J_{i}$ are the same as in $J$.) Finally, note that the first LP-constraint (1) ensures that the precedence constraints are satisfied in $\sigma$ since if $k\prec j$ then $C_{k}\leq C_{j}$ and $k$ will be scheduled before $j$ in $\sigma$. Hence, $\sigma$ is feasible if we place the partial schedules in the order $\sigma_{1},\dots,\sigma_{q}$ and shift schedules forward in case of overlap. However, we will show below that schedule $\sigma_{i}$ is contained in the interval $[3t_{i},3t_{i+1}]$. That means we can simply take the union of the $\sigma_{i}^{\prime}s$ and do not need to shift.

3.1 Analysis

Say that a schedule is tight if no job can be shifted to the left (scheduled earlier) while maintaining feasibility and without shifting any of the other jobs. Clearly, a non-tight schedule can be made tight by checking each job. Hence we may assume that the schedules $\sigma_{i}$ returned by the algorithm described in Section 4 are tight.

Lemma 5

Any tight schedule for $I_{i}$ is contained in the interval $[3t_{i},3t_{i+1}]$.

Proof We assumed here that $\epsilon$ is small enough. To be precise, we assume $\epsilon\leq 3/\ln 3$ since then $t_{i+1}=e^{3/\epsilon}t_{i}\geq 3t_{i}$. By definition, no job starts before time $3t_{i}$. Since the schedule is tight the last job completes latest at time

[TABLE]

Note that $r_{\max}(J_{i})\leq t_{i+1}$ since $r_{j}\leq C_{j}\leq t_{i+1}$ for all jobs $j\in J_{i}$. Also, $3t_{i}\leq t_{i+1}$ as we showed above. Further, by Lemma 3,

[TABLE]

Hence, the last job completes latest at time

[TABLE]

$\hfill\Box$

Let $\textsc{Opt}_{i}$ be the optimal value of instance $I_{i}$. Now, consider an optimal schedule $\sigma^{*}$ for $I$ and let $\textsc{Opt}|_{i}$ be the contribution of $J_{i}$ in the optimal schedule. That means, $\textsc{Opt}|_{i}=\sum_{j\in J_{i}}w_{j}C_{j}^{*}$, where $C_{j}^{*}$ is the completion time of job $j$ in $\sigma^{*}$. A feasible schedule for $I_{i}$ is obtained by removing the jobs not in $J_{i}$ from $\sigma^{*}$ and shifting the remaining schedule forward by at most $3t_{i}$. Hence we get the following bound.

Lemma 6

$\textsc{Opt}_{i}\leq\textsc{Opt}|_{i}+3t_{i}\sum_{j\in J_{i}}w_{j}$.

The value $\textsc{Opt}_{i}$ depends on the random variable $b$ which defines the partition. For job $j$ let $i(j)$ be such that $j\in J_{i(j)}$, that means, $t_{i(j)}\leq C_{j}<t_{i(j)+1}$. Note that $t_{i(j)}$ is a stochastic variable of the form $t_{i(j)}=e^{-x}C_{j}$ where $x$ is uniform on $[0,a]$.

[TABLE]

Lemma 7

$\mathbb{E}[\sum_{i}\textsc{Opt}_{i}]\leq(1+3/a)\textsc{Opt}=(1+\epsilon)\textsc{Opt}$.

Proof From Lemma 6,

[TABLE]

From (6), the expected value over $b$ is

[TABLE]

$\hfill\Box$

Remember that a schedule is called tight if no job can be shifted left (scheduled earlier) while maintaining feasibility and without shifting any of the other jobs.

Definition 1

We say that an instance of $1|r_{j},prec|\sum w_{j}C_{j}$ with job set $J$ is bounded if there is some number $L>0$ such that $r_{\min}(J)\geq L$ and any tight schedule completes within time $\beta L$ for some constant $\beta$.

Theorem 2

For any instance $I$ of $1|r_{j},prec|\sum w_{j}C_{j}$ and constant $\epsilon>0$ we can find bounded instances $I_{1},\dots,I_{q}$ such that if $\sigma_{1},\dots,\sigma_{q}$ are (randomized) $\alpha$-approximate schedules for $I_{1},\dots,I_{q}$ then the schedule obtained by placing the $\sigma_{i}$’s in order $i=1,\dots,q$ is a randomized $\alpha(1+\epsilon)$-approximate schedule for $I$.

Proof Each $I_{i}$ is a bounded instance with $L=3t_{i}$ and $\beta=e^{3/\epsilon}$. If each schedule $\sigma_{i}$ is an $\alpha$-approximation for instance $I_{i}$ then the union is feasible (Lemma 5) and has expected value (Lemma 7) at most

[TABLE]

By Lemma 5 there is no overlap in the schedules $\sigma_{i}$. Hence Note that the union is indeed $\hfill\Box$

The theorem implies that any (randomized) polynomial time $\alpha$-approximation algorithm for bounded instances yields a randomized polynomial time $\alpha(1+\epsilon)$-approximation for general instances. If the algorithm for the bounded instances is deterministic then we can easily derandomize the combined algorithm by discretizing the probability distribution for $b\in[0,a]$. We show in the next section how to get a deterministic $\alpha$-approximate schedule for bounded instances with $\alpha=2(1+\epsilon)$.

4 Algorithm for bounded instances.

In this section we restrict to bounded instances as defined in Definition 1. Apart from that definition, the analysis here is independent of Section 3. Hence, let $I$ be any bounded instance with parameters $\beta$ and $L$.

The main idea of the algorithm is to guess enough information about an (unknown) optimal schedule for $I$ such that the algorithm LP+LS of Section 2 yields a $2(1+\epsilon)$-approximate schedule. To restrict the number of guesses we first observe (Section 4.1) that we only need to consider a nearly optimal schedule $\sigma^{\prime}$ in which each job $j$ starts at a time that is a multiple of $\epsilon p_{j}$. Say that a job $j$ is early in $\sigma^{\prime}$ if it starts at time $S^{\prime}_{j}<p_{j}$. We will guess the start time of each early job. The second observation is that the number of early jobs is $O(\log\beta)$ (Lemma 8). With these two observations, the number of guesses is polynomially bounded. For each guess, we adjust release times of jobs in correspondence with our guess and run algorithm LP+LS. The final solution is the best schedule over all guesses.

Algorithm Bounded:

Guess the set $A\subseteq J$ of jobs that are early in the (near) optimal schedule $\sigma^{\prime}$ and for each $j\in A$ guess its start time. For each guess, adjust the release times $r_{j}\rightarrow r^{\prime}_{j}$ and run algorithm LP+LS. Let $\sigma$ be the best schedule over all possible guesses.

4.1 Restricting the optimal schedule.

Let Opt be the optimal value for the bounded instance $I$. Consider some (unknown and tight) optimal schedule $\sigma^{*}$ and let $C^{*}_{1}<\dots<C^{*}_{n}$ be the completion times. Assume we shift jobs one by one (starting with job 1) such that the start time of each job $j$ is a multiple of $\epsilon p_{j}$. Let this schedule be $\sigma^{\prime}$. Then, for any $j$ the new completion time is

[TABLE]

Let $\textsc{Opt}^{\prime}$ be the value of $\sigma^{\prime}$. We have the following properties.

1. (i)

$\textsc{Opt}^{\prime}\leq(1+\epsilon)\textsc{Opt}$. 2. (ii)

The start time $S^{\prime}_{j}$ of job $j$ is a multiple of $\epsilon p_{j}$. 3. (iii)

All jobs are schedule in the interval $[L,(1+\epsilon)\beta L]$.

From now, let $\sigma^{\prime}$ be our (unknown) near-optimal schedule and let $\textsc{Opt}^{\prime}$ be its value. We will show how to get a schedule of value at most $2\textsc{Opt}^{\prime}$.

4.2 Guessing the optimal schedule.

The first step of the algorithm is to make guesses about $\sigma^{\prime}$. Let $S^{\prime}_{j}$ be the start time of job $j$ in $\sigma^{\prime}$. Say that a job $j$ is early in $\sigma^{\prime}$ if $S^{\prime}_{j}<p_{j}$.

Lemma 8

The number of early jobs in $\sigma^{\prime}$ is $O(\log\beta)$.

Proof If $j$ is an early job in $\sigma^{\prime}$ then $C^{\prime}_{j}>2S^{\prime}_{j}$. Hence, the number of early jobs is bounded by

[TABLE]

$\hfill\Box$

Our algorithm guesses the set $A\subseteq J$ of early jobs in $\sigma^{\prime}$ and for each early job $j$ we guess its start time $S_{j}^{\prime}$ in $\sigma^{\prime}$. If $j$ is early then there are at most $1/\epsilon$ possibilities to consider since $S^{\prime}_{j}<p_{j}$ and $S^{\prime}_{j}$ is a multiple of $\epsilon p_{j}$. Hence, the total number of guesses is bounded by $(n/\epsilon)^{O(\log\beta)}$.

4.3 Adjusting release times: $r_{j}\rightarrow r^{\prime}_{j}$

We describe this step under the assumption that our guess about $\sigma^{\prime}$ is correct, i.e., $A\subseteq J$ is the set of early jobs in $\sigma^{\prime}$. We increase release times step by step such that the following properties hold. Let $r^{\prime}_{j}\geq r_{j}$ be the new release times and $I^{\prime}$ the new instance.

1. (a)

Schedule $\sigma^{\prime}$ is feasible for $I^{\prime}$ 2. (b)

if $j\in A$ then $r^{\prime}_{j}\geq S^{\prime}_{j}$ 3. (c)

if $j\notin A$ then $r^{\prime}_{j}\geq p_{j}$ 4. (d)

if $j\prec k$ then $r^{\prime}_{j}\leq r^{\prime}_{k}$

Let $T$ be the set of open time intervals at which an early job is processed, i.e.,

[TABLE]

No job starts at a time $t\in T$ in $\sigma^{\prime}$ so we may increase release times further such that

1. (e)

$r^{\prime}_{j}\notin T$ for any $j\in J$

The increase due to (e) may give a conflict with (d) causing a sequence of increases by rules (d) and (e). Clearly, this process ends after a polynomial number of iterations. Note that $|T|$ consists of only $O(\log\beta)$ intervals. A rough upper bound on the number of iterations is $O(n^{2}\log\beta)$. Hence, we can find release times $r^{\prime}_{j}$ such that (a)-(e) hold.

4.4 The analysis.

Theorem 3

Algorithm Bounded returns a $2(1+\epsilon)$ approximate solution for bounded instances.

Proof Assume that we guessed the information about $\sigma^{\prime}$ correctly. Let $Z_{LP}$ be the LP value obtained. Then $Z_{LP}\leq\textsc{Opt}^{\prime}$. We will show that $C^{\sigma}_{j}\leq 2C_{j}$ for any job $j$, where $C_{j}$ is the optimal LP-value for $I^{\prime}$. Then the theorem follows by taking the weighted sum over all jobs:

[TABLE]

Consider schedule $\sigma$ returned by algorithm Bounded. Let $j$ be an arbitrary job and apply Lemma 4 to $\sigma$. If no job completes at time $t$ then $C_{j}^{\sigma}\leq 2C_{j}$. Now assume some job $k$ completes at time $t$ and let $s$ be its start time. If $t\leq 2s$ then from (3) and (5) , $C_{j}^{\sigma}\leq t+2C_{j}-2r^{\prime}_{\min}(U)<t+2C_{j}-2s\leq 2C_{j}$. Hence, assume from now that

[TABLE]

0$s$ t$$j$$k$$C_{j}^{\sigma}$$U

Then, $p_{k}=t-s>s\geq r_{k}^{\prime}$ and by (c) we must have $k\in A$, i.e., $k$ is an early job. Since $k\in A$ we have (from (b)) $S^{\prime}_{k}\leq r_{k}^{\prime}\leq s$ and (from (5))

[TABLE]

Also, since $k\in A$, we know from (e) that $r^{\prime}_{\min}(U)\notin\ ]S^{\prime}_{k},S^{\prime}_{k}+p_{k}[$. Together with (8) and (7) we get that

[TABLE]

Again using (3) we conclude that

[TABLE]

$\hfill\Box$

Lemma 9

Algorithm Bounded runs in polynomial time.

Proof The number of guesses to consider is $(n/\epsilon)^{O(\log\beta)}$. For each guess, adjusting the release times takes $O(n^{2}/\epsilon)$ time. Also, list scheduling and the LP run in poynomial time, as mentioned earlier in Section 2. The total running for algorithm Bounded is $(n/\epsilon)^{O(\log\beta)}$. $\hfill\Box$

5 Conclusion and remarks.

Total running time.

The linear program (LP) is solved once to partition an instance $I$ into $O(n)$ instances $I_{i}$. For each $I_{i}$ the algorithm takes $(n/\epsilon)^{O(\log\beta)}$ time where $\log\beta=O(1/\epsilon)$. Hence, the total running time is $(n/\epsilon)^{O(1/\epsilon)}$.

Reducing the running time.

We can reduce the total running to $f(\epsilon)p(n)$ for some function $f$ and polynomial $p$ by rounding the processing times up to powers of $1+\epsilon$. This reduces the number of guesses needed substantially. Say that job $j$ is of type $i$ if its rounded processing $p^{\prime}_{j}$ is $(1+\epsilon)^{i}$. Assume that in the near optimal schedule $\sigma^{\prime}$ the processing times are rounded. Note that in $\sigma^{\prime}$ there is at most one early job of each type. In stead of guessing all early jobs it is enough to guess which of the types do have an early job. Let $S^{(i)}$ be the smallest start time among the jobs of type $i$ in $\sigma^{\prime}$. Say that type $i$ is early if $S^{(i)}<(1+\epsilon)^{i}$. Let $B$ be the types that are (guessed) to be early. Let $I^{\prime}$ be the instance for adjusted release times $r^{\prime}_{j}$ defined by the following rules.

1. (a)

Schedule $\sigma^{\prime}$ is feasible for $I^{\prime}$ 2. (b)

if $i\in B$ and $j$ is of type $i$ then $r^{\prime}_{j}\geq S^{(i)}$ 3. (c)

if $i\notin B$ and $j$ is of type $i$ then $r^{\prime}_{j}\geq p^{\prime}_{j}$ 4. (d)

if $j\prec k$ then $r^{\prime}_{j}\leq r^{\prime}_{k}$ 5. (e)

$r^{\prime}_{j}\notin T$ for any $j\in J$

Here, $T$ is again the set of open time intervals at which an early job is processed, i.e.,

[TABLE]

The analysis is exactly the same except for the bound on the number of guesses. Note that if type $i$ is early then $(1+\epsilon)^{i}>L$ since no job starts before time $L$. Further, we must have $(1+\epsilon)^{i}<(1+\epsilon)^{2}\beta L$ since no job completes after time $(1+\epsilon)^{2}\beta L$ in $\sigma^{\prime}$. Hence, we only need to consider a range of $O(\log_{(1+\epsilon)}\beta)$ values for $i$. The number of guesses is bounded by $(1/\epsilon)^{O(\log_{(1+\epsilon)}\beta)}=(1/\epsilon)^{O((\log\beta)/\epsilon)}$.

No release times.

The decomposition theorem of Section 3 is still meaningful in the absence of release times. It then states that an $\alpha(1+\epsilon)$-approximation for the problem $1|prec|\sum_{j}w_{j}C_{j}$ follows from an $\alpha$-approximation for instances of $1|r_{j},prec|\sum_{j}w_{j}C_{j}$ in which all jobs have the same release time $r_{j}=L$ where $L=\Omega(\sum_{j}p_{j})$. Although this does not seem helpful to get below an approximation ratio of $2$ in general, it can be useful for special type of precedence constraints. Moreover, a similar decomposition can be useful for other optimization problems with total completion time objective.