Approximation results for makespan minimization with budgeted uncertainty

TL;DR

This paper develops approximation algorithms for minimizing makespan under processing time uncertainty, providing an EPTAS for identical machines and bounds for unrelated machines.

Contribution

It introduces an EPTAS for makespan minimization with uncertainty on identical machines and analyzes approximation bounds for unrelated machines.

Findings

EPTAS achieved for identical machines

3-approximation algorithm for unrelated machines

Inapproximability ratio of 2−ε for unrelated machines

Abstract

We study approximation algorithms for the problem of minimizing the makespan on a set of machines with uncertainty on the processing times of jobs. In the model we consider, which goes back to~\cite{BertsimasS03}, once the schedule is defined an adversary can pick a scenario where deviation is added to some of the jobs' processing times. Given only the maximal cardinality of these jobs, and the magnitude of potential deviation for each job, the goal is to optimize the worst-case scenario. We consider both the cases of identical and unrelated machines. Our main result is an EPTAS for the case of identical machines. We also provide a $3$-approximation algorithm and an inapproximability ratio of $2-\epsilon$ for the case of unrelated machines

Equations

$$p_{ij}:=\{\begin{array}{ll}{\overline{p}}_{ij}+{\hat{p}}_{ij}& \text{if }j\in B_i\\ {\overline{p}}_{ij}& \text{otherwise.}\end{array}$$

$$c_i:=1-\Gamma \cdot t_i+ϵ.$$

$$p_{ij}:=\{\begin{array}{ll}{\overline{p}}_j+{\hat{p}}_j-t_i& \text{ if }{\hat{p}}_j\ge t_i,\\ {\overline{p}}_j& \text{ if }{\hat{p}}_j<t_i.\end{array}$$

$$\sum _{j\in {\sigma }_i^2}{p}_{ij}=\sum _{j\in {\sigma }_i^2}{\overline{p}}_j+{\hat{p}}_j\le 1<c_i.$$

$$\sum _{j\in {\sigma }_i^2}{p}_{ij}=\sum _{j\in \Gamma ({\sigma }_i^2)}{p}_{ij}+\sum _{j\in {\sigma }_i^2\setminus \Gamma ({\sigma }_i^2)}{p}_{ij}=\sum _{j\in \Gamma ({\sigma }_i^2)}[{\overline{p}}_j+{\hat{p}}_j-t_i]+\sum _{j\in {\sigma }_i^2\setminus \Gamma ({\sigma }_i^2)}{\overline{p}}_j\le 1-\Gamma \cdot t_i<c_i.$$

$$p_{ij}=\{\begin{array}{ll}{\overline{p}}_j+{\hat{p}}_j-t_i\ge {\overline{p}}_j& \text{ if }{\hat{p}}_j\ge t_i,\\ {\overline{p}}_j& \text{ if }{\hat{p}}_j<t_i.\end{array}$$

$$p_{ij}=\{\begin{array}{ll}{\overline{p}}_j+{\hat{p}}_j-t_i& \text{ if }{\hat{p}}_j\ge t_i,\\ {\overline{p}}_j>{\overline{p}}_j+{\hat{p}}_j-t_i& \text{ if }{\hat{p}}_j<t_i.\end{array}$$

$$\begin{gathered} \sum _{j\in \Gamma ({\sigma }_i^2)}[{\overline{p}}_j+{\hat{p}}_j]+\sum _{j\in {\sigma }_i^2\setminus \Gamma ({\sigma }_i^2)}{\overline{p}}_j\le \Gamma \cdot t_i+\sum _{j\in \Gamma ({\sigma }_i^2)}[{\overline{p}}_j+{\hat{p}}_j-t_i]+\sum _{j\in {\sigma }_i^2\setminus \Gamma ({\sigma }_i^2)}{\overline{p}}_j \\ \le \Gamma \cdot t_i+\sum _{j\in \Gamma ({\sigma }_i^2)}{p}_{ij}+\sum _{j\in {\sigma }_i^2\setminus \Gamma ({\sigma }_i^2)}{p}_{ij}=\Gamma \cdot t_i+\underset{\le (1+ϵ)\cdot c_i}{\underbrace{\sum _{j\in {\sigma }_i^2}{p}_{ij}}}\le \Gamma \cdot t_i+(1+ϵ)\cdot (1-\Gamma \cdot t_i+ϵ)\le (1+ϵ{)}^2. \end{gathered}$$

$${\log }^{O(1/ϵ\log (1/ϵ))}(m)=({\log }^{1/2}(m){)}^{2\cdot O(1/ϵ\log (1/ϵ))}\le (1/ϵ\log (1/ϵ){)}^{O(1/ϵ\log (1/ϵ))}\le 2^{O(1/ϵ{\log }^2(1/ϵ))}.$$

$${\log }^{O(1/ϵ\log (1/ϵ))}(m)\le {\log }^{O(\log (m)/\log \log (m))}(m)=2^{O(\log (m)/\log \log (m)\cdot \log \log (m))}=m^{O(1)}.$$

$${\log }^{O(1/ϵ\log (1/ϵ))}(m)\le 2^{O(1/ϵ{\log }^2(1/ϵ))}+m^{O(1)}.$$

$$\sum _l[2{\overline{m}}_l-m_l^{\ast }]=2\sum _l{\overline{m}}_l-\sum _l{m}_l^{\ast }=2m^{\prime }-m.$$

Full text

Keywords: Makespan minimization, robust optimization, approximation algorithms, EPTAS, parallel machines, unrelated machines

1 Introduction

Classical optimization models suppose perfect information over all parameters. This can lead to optimal solutions having poor performance when the actual parameters deviate, even by a small amount, from the predictions used in the optimization model. Different frameworks have been proposed to overcome this issue, among which Robust Optimization which tackles the uncertainty by providing a set of possible values for these parameters, and considering the worst outcome over that set. In this paper, we consider the problem of scheduling a set of jobs $J$ on the set of machines $M$, so as to minimize the makespan, and considering that the processing times are uncertain. What is more, we consider the budgeted uncertainty model introduced by [3] where each processing time varies between its nominal value and the latter plus some deviation. Further, in any scenario, at most $\Gamma$ of the uncertain parameters take the higher values, the other being at their nominal values.

Let us now formally define the Robust Scheduling on Unrelated Machines ($R|\mathcal{U}^{\Gamma}|C_{\max}$) problem. For any job $j\in J$ and machine $i\in M$, we denote by $\overline{p}_{ij}\geq 0$ the nominal processing time of $j$ on $i$, and by $\hat{p}_{ij}\geq 0$ the (potential) deviation of $j$ on $i$. A schedule $\sigma$ is a function from $J\rightarrow M$. We write $\sigma_{i}$ for the subset of jobs scheduled on machine $i$. Let $\mathcal{U}^{\Gamma}=\{\xi\in\{0,1\}^{|J|}:\|\xi\|_{1}\leq\Gamma\}$ be the set of all possible scenarios where at most $\Gamma$ jobs deviate. For any $\xi\in\mathcal{U}^{\Gamma}$, we set $p^{\xi}_{ij}=\overline{p}_{ij}+\xi_{j}\hat{p}_{ij}$ to be the actual processing time of $j$ on $i$ in scenario $\xi$.

Let us now formalize some common terms, but with dependence on scenario $\xi$. The load of machine $i$ in scenario $\xi$ is calculated as $\sum_{j\in\sigma_{i}}p^{\xi}_{ij}$. The makespan in scenario $\xi$ is the maximum load in scenario $\xi$, i.e., $C^{\xi}_{\max}(\sigma)=\max_{i\in M}\sum_{j\in\sigma_{i}}p^{\xi}_{ij}$. Finally, $C_{\max}^{\Gamma}(\sigma)=\max_{\xi\in\mathcal{U}^{\Gamma}}C_{\max}^{\xi}(\sigma)$ denotes the objective function we consider in Robust Scheduling, where the adversary takes the worst scenario among $\mathcal{U}^{\Gamma}$.

Next, we will state important observations about the objective function. We first need to introduce the following notations. Given a set of jobs $X_{i}$ scheduled on machine $i$, we define $\overline{p}(X_{i})=\sum_{j\in X_{i}}\overline{p}_{ij}$, $\hat{p}(X_{i})=\sum_{j\in X_{i}}\hat{p}_{ij}$, $\Gamma(X_{i})$ as the set of the $\Gamma$ jobs of $X_{i}$ with the largest $\hat{p}_{ij}$ values (or $\Gamma(X_{i})=\sigma_{i}$ when $|X_{i}|<\Gamma$) with ties broken arbitrarily. Finally, set $\hat{p}_{\Gamma}(X_{i})=\hat{p}(\Gamma(X_{i}))$.

By definition we have $C_{\Gamma}(\sigma)=\max_{\xi\in\mathcal{U}^{\Gamma}}\max_{i\in M}\sum_{j\in\sigma_{i}}C_{\xi}(\sigma)$, and thus we can rewrite $C_{\Gamma}(\sigma)=\max_{i\in M}\max_{\xi\in\mathcal{U}^{\Gamma}}\sum_{j\in\sigma_{i}}C_{\xi}(\sigma)=\max_{i\in M}C_{\Gamma}(\sigma_{i})$, where $C_{\Gamma}(\sigma_{i})=\max_{\xi\in\mathcal{U}^{\Gamma}}\sum_{j\in\sigma_{i}}C_{\xi}(\sigma)$ is the worst-case makespan on machine $i$. The benefit of rewriting $C_{\Gamma}(\sigma)$ in this form is that it is now clear that $C_{\Gamma}(\sigma_{i})=\overline{p}(\sigma_{i})+\hat{p}_{\Gamma}(\sigma_{i})$ as the worst scenario $\xi$ for a fixed $\sigma_{i}$ is obtained by picking the $\Gamma$ jobs with highest $\hat{p}_{ij}$ and make them deviate. Thus, $R|\mathcal{U}^{\Gamma}|C_{\max}$ can also be thought as a “classical” scheduling problem (without adversary) where the makespan on a machine $C_{\Gamma}(\sigma_{i})$ is simply the sum of all the nominal processing time of jobs of $\sigma_{i}$, plus only the $\Gamma$ largest deviating values of jobs of $\sigma_{i}$. We are now ready to define $R|\mathcal{U}^{\Gamma}|C_{\max}$.

Problem 1

Robust Scheduling on Unrelated Machines ($R|\mathcal{U}^{\Gamma}|C_{\max}$)

• •

Input: $(J,M,\overline{p}\in\mathbb{Q}^{|M|\times|J|}_{+},\hat{p}\in\mathbb{Q}^{|M|\times|J|}_{+})$ where $J$ is the set of jobs, $M$ the set of machines, $\overline{p}$ are the vectors of nominal processing times, and $\hat{p}$ the vectors of deviation

• •

Output: find a schedule $\sigma:J\rightarrow M$

• •

Objective function: min $C_{\Gamma}(\sigma)=\max_{\xi\in\mathcal{U}^{\Gamma}}\max_{i\in M}\sum_{j\in\sigma_{i}}[\overline{p}_{ij}+\xi_{j}\hat{p}_{ij}]=\max_{i\in M}C_{\Gamma}(\sigma_{i})$, where $C_{\Gamma}(\sigma_{i})=\overline{p}(\sigma_{i})+\hat{p}_{\Gamma}(\sigma_{i})$.

Following the classical three field notation, we denote by $R|\mathcal{U}^{\Gamma}|C_{\max}$ the previous problem. Notice that when all $\hat{p}_{ij}=0$ the problem corresponds to the classical $R||C_{\max}$, for which we denote by $C(\sigma_{i})=\sum_{j\in\sigma_{i}}\overline{p}_{ij}$ the makespan on machine $i$. We are also interested in simplifications of the above problem. The first one is Robust Scheduling on Uniform Machines ($Q|\mathcal{U}^{\Gamma}|C_{\max}$) where each machine has a speed $s_{i}$, each job has two processing times ($\overline{p}_{j}$ and $\hat{p}_{j}$), and we have $\overline{p}_{ij}=\frac{\overline{p}_{j}}{s_{i}}$ and $\hat{p}_{ij}=\frac{\hat{p}_{j}}{s_{i}}$. The other simplification is Robust Scheduling on Identical Machines ($P|\mathcal{U}^{\Gamma}|C_{\max}$) where $s_{i}=1$ for any machine $i$.

Robust scheduling has been considered in the past, mostly for finite uncertainty sets without particular structure, see for instance [1, 6, 9, 10, 12]. More recently, [5, 13, 2] considered robust packing and scheduling with the budgeted uncertainty model $\mathcal{U}^{\Gamma}$ from [4]. Specifically, [5] (with authors in common) provided a 3-approximation algorithm and a $(1+\epsilon)$-approximation (PTAS) for $P|\mathcal{U}^{\Gamma}|C_{\max}$ but only for a constant $\Gamma$, as well as a randomized approximation algorithm for $R|\mathcal{U}^{\Gamma}|C_{\max}$ having an average ratio of $O(\log(m))$. They also considered problem $1|\mathcal{U}^{\Gamma}|\sum_{j}w_{j}C_{\max}$, proving that the problem is ${\cal NP}$-hard in the strong sense, and providing a polynomial-time algorithm when $w_{j}=1$ for $j\in J$. Authors of [13] considered the robust one-machine problem for four commonly-used objective criteria: (weighted) total completion time, maximum lateness/tardiness, and number of late jobs. They showed that some of these problems are polynomially solvable and provide mixed-integer programming formulations for others. Their results considered $\mathcal{U}^{\Gamma}$ as well as two closely related uncertainty sets. Paper [2] (with also authors in common) considers robust bin-packing problem for $\mathcal{U}^{\Gamma}$ and one of the uncertainty sets considered by [13], and provided constant-factor approximations algorithms for the two problems.

In this paper we improve the results of [5] for $P|\mathcal{U}^{\Gamma}|C_{\max}$ and $R|\mathcal{U}^{\Gamma}|C_{\max}$. In Section 2 we show that any $c$-approximation for the classical $R||C_{\max}$ problem leads to a $(c+1)$-approximation for $R|\mathcal{U}^{\Gamma}|C_{\max}$, hence obtaining a $3$-approximation algorithm for the latter problem, and a $(2+\epsilon)$-approximation for $Q|\mathcal{U}^{\Gamma}|C_{\max}$. We point out that this result improves the ad-hoc $3$-approximation of [5] for $P|\mathcal{U}^{\Gamma}|C_{\max}$, while having a simpler proof. In Section 3, we show through a reduction from the Restricted Assignment Problem that there exists no $(2-\epsilon)$-approximation algorithm for $R|\mathcal{U}^{\Gamma}|C_{\max}$ unless ${\cal P}={\cal NP}$. In Section 4 we consider the $P|\mathcal{U}^{\Gamma}|C_{\max}$ problem and present the first step our main result, namely a PTAS which is valid even when $\Gamma$ is part of the input, i.e., not constant. Having $\Gamma$ in the input (and not constant) requires a totally different technique from the one used in [5]. The algorithm is turned into an EPTAS in Section 5, i.e., a PTAS where the dependency of $\epsilon$ is not in the exponent of the encoding length.

2 A 3-approximation for unrelated machines

Theorem 2.1

Any polynomial $c$-approximation for $R||C_{\max}$ implies a polynomial $(c+1)$-approximation for $R|\mathcal{U}^{\Gamma}|C_{\max}$.

Proof (Proof of Theorem 2.1)

We design a dual approximation, i.e., given an instance $I$ of $R|\mathcal{U}^{\Gamma}|C_{\max}$ and an threshold $T$, we either give a schedule $\sigma$ of $I$ with $C_{\Gamma}(\sigma)\leq(c+1)T$, or prove that $T<\mathrm{OPT}(I)$. Using a binary search on $T$ this will imply a $(c+1)$-approximation algorithm.

For that, given an instance $I=(J,M,\overline{p},\hat{p})$ of $R|\mathcal{U}^{\Gamma}|C_{\max}$, and $T$ the current threshold, our objective is to define an instance $I^{\prime}=(J,M,p)$ of the classical $R||C_{\max}$ problem. The transformation of a solution for $I^{\prime}$ to a solution for $I$ will be straightforward since the jobs and machines will be the same.

Given a machine $i$, let $B_{i}=\{j|\hat{p}_{ij}>\frac{T}{\Gamma}\}$ and $S_{i}=J\setminus B_{i}$. Define

[TABLE]

Let us now prove that (1) if $\mathrm{OPT}(I^{\prime})>T$ then we have $\mathrm{OPT}(I)>T$, and (2) every schedule $\sigma$ with makespan $C^{I^{\prime}}(\sigma)$ in $I^{\prime}$ has a makespan at most $C^{I^{\prime}}(\sigma)+T$ in $I$ ($C_{\Gamma}(\sigma)\leq C^{I^{\prime}}(\sigma)+T$).

For (1), we prove that $\mathrm{OPT}(I)\leq T$ implies that $\mathrm{OPT}(I^{\prime})\leq T$. Let $\sigma$ be an optimal solution of $I$ and $i$ a machine. $C_{\Gamma}(\sigma)\leq T$ implies that $C_{\Gamma}(\sigma_{i})\leq T$ for any $i$, and thus that $\overline{p}(\sigma_{i})+\hat{p}_{\Gamma}(\sigma_{i})\leq T$. Now, observe that $B_{i}\subseteq\Gamma(\sigma_{i})$. Indeed, assume towards contradiction that there exists $j\in B_{i}\setminus\Gamma(\sigma_{i})$. This implies that $|\Gamma(\sigma_{i})|=\Gamma$. As by definition, any $j^{\prime}\in\Gamma(\sigma_{i})$ has $\hat{p}_{ij^{\prime}}\geq\hat{p}_{ij}>\frac{T}{\Gamma}$, we get that $\hat{p}_{\Gamma}(\sigma_{i})>T$, a contradiction. This implies $C^{I^{\prime}}(\sigma_{i})=\overline{p}(\sigma_{i})+\hat{p}(B_{i})\leq\overline{p}(\sigma_{i})+\hat{p}_{\Gamma}(\sigma_{i})\leq T$.

For (2), let $\sigma$ be a solution of $I^{\prime}$. Let $i\in M$. Observe that $\hat{p}(\Gamma(\sigma_{i}))\leq\hat{p}(B_{i})+T$ as $\Gamma(\sigma_{i})$ contains at most $\Gamma$ jobs in $\sigma_{i}\setminus B_{i}$, and these jobs have $\hat{p}_{ij}\leq\frac{T}{\Gamma}$. Thus, $C_{\Gamma}(\sigma_{i})=\overline{p}(\sigma_{i})+\hat{p}_{\Gamma}(\sigma_{i})\leq\overline{p}(\sigma_{i})+\hat{p}(B_{i})+T=C^{I^{\prime}}(\sigma_{i})+T$.

Thus, given a $T$ and $I$ we create $I^{\prime}$ as above and run the $c$-approximation for $R||C_{\max}$ to get a solution $\sigma$. If $C^{I^{\prime}}(\sigma)>cT$ then $\mathrm{OPT}(I^{\prime})>T$, implying $\mathrm{OPT}(I)>T$, and thus we reject $T$. Otherwise, we consider $\sigma$ as a solution for $I$, and $C_{\Gamma}(\sigma)\leq(c+1)T$.

∎

Using the well-known 2-approximation algorithm from [11], we obtain immediately the following.

Corollary 1

There is a $3$-approximation for $R|\mathcal{U}^{\Gamma}|C_{\max}$.

Since by this reduction uniform machines stay uniform we also obtain the following using the EPTAS of [7] for the classical $Q||C_{\max}$ problem.

Corollary 2

For every $\epsilon>0$ there is a $(2+\epsilon)$-approximation for $Q|\mathcal{U}^{\Gamma}|C_{\max}$ running in time $2^{O(1/\epsilon\log(1/\epsilon)^{4})}+poly(n)$.

3 A $2-\epsilon$ inapproximability for unrelated machines

For the classical $R||C_{\max}$ problem, when all $p_{ij}\in\{1,\infty\}$, deciding if the optimal value is at most $1$ is polynomially solvable as it can be reduced to finding a matching in a bipartite graph. The result below shows that answering the same question for $R|\mathcal{U}^{\Gamma}|C_{\max}$ is ${\cal NP}$-complete.

Theorem 3.1

Given an instance $I$ of $R|\mathcal{U}^{\Gamma}|C_{\max}$, it is NP-complete to decide if $\mathrm{OPT}(I)\leq 1$ or $\mathrm{OPT}(I)\geq 2$, and thus for any $\epsilon>0$ is no $(2-\epsilon)$-approximation algorithm for $R|\mathcal{U}^{\Gamma}|C_{\max}$ unless ${\cal P}={\cal NP}$, even for $\Gamma=1$ and when each job can be scheduled on at most $3$ machines.

Proof

Let us define a reduction from $3$-SAT to $R|\mathcal{U}^{\Gamma}|C_{\max}$ with $\Gamma=1$. Let $I_{0}$ be an instance of $3$-SAT with clauses $\{C_{i},i\in[m_{0}]\}$ and variables $\{x_{j},j\in[n_{0}]\}$. Each $C_{i}$ is of the form $l^{1}_{i}\vee l^{2}_{i}\vee l^{3}_{i}$ where $l^{k}_{i}\in\{x_{j},\bar{x}_{j}\}$ for some $j$. We define an instance $I$ of $R|\mathcal{U}^{\Gamma}|C_{\max}$ with $m=2n_{0}$ machines and $n=n_{0}+m_{0}$ jobs as follows. To each variable $x_{j}$ we associate two machines $\{j_{f},j_{t}\}$. We create a set of $n_{0}$ variable jobs where for any $j\in[n_{0}]$, $\overline{p}_{j_{f}j}=\overline{p}_{j_{t}j}=1$, $\overline{p}_{i^{\prime}j}=\infty$ for any other $i^{\prime}$, and $\hat{p}_{ij}=0$ for any $i\in[m]$. For any clause $C_{i}$, $i\in[m_{0}]$ we define $M_{i}$: the set of $3$ machines corresponding to literals $\{l^{k}_{i}\}$ satisfying $C_{i}$. For example, if $C_{7}=x_{1}\vee\bar{x}_{3}\vee x_{5}$ then $M_{7}=\{1_{t},3_{f},5_{t}\}$. We now define a set of $m_{0}$ clause jobs as follows. For any $j\in[n_{0}+1,n_{0}+m_{0}]$, job $j$ represents clause $C_{j-n_{0}}$ with $\hat{p}_{ij}=1$ iff $i\in M_{j-n_{0}}$, $\hat{p}_{i^{\prime}j}=\infty$ for any other $i^{\prime}$, and $\overline{p}_{ij}=0$ for any $i\in[m]$. For example, job $j=n_{0}+7$ is associated to $C_{7}$ where in particular $\hat{p}_{1_{t}j}=\hat{p}_{3_{f}j}=\hat{p}_{5_{t}j}=1$. Notice that each clause job can be scheduled on at most $3$ machines. Let us now verify that $I_{0}$ is satisfiable iff $\mathrm{OPT}(I)=1$.

$\Rightarrow$. Suppose $I_{0}$ is satisfied by assignment $a$. For any $j\in[n_{0}]$, we schedule $j$ on $j_{t}$ if $x_{j}$ is set to false in $a$ and on $j_{f}$ otherwise. For any $j\in[n_{0}+1,n_{0}+m_{0}]$, we schedule job $j$ on any machine $i\in M_{j-n_{0}}$ corresponding to a literal satisfying $C_{i}$ in assignment $a$. Notice that in this schedule, a machine either receives exactly one variable job, implying a makespan of $1$, or only clause jobs, also implying a makespan of $1$ as $\Gamma=1$.

$\Leftarrow$. Suppose that $\mathrm{OPT}(I)=1$ and let us define an assignment $a$. This implies that any variable job $j$ is either scheduled on machine $j_{f}$, in which case we set $x_{j}$ to true, or on machine $j_{t}$, in which case we set $x_{j}$ to false. As $\mathrm{OPT}(I)=1$, and clause job $j\in[n_{0}+1,n_{0}+m_{0}]$ is scheduled on a machine $i\in M_{j-n_{0}}$ that did not receive a variable job, implying that clause $j-n_{0}$ is satisfied by literal $i$. ∎

4 A PTAS for identical machines

Note that we can assume that $m<n$. If $m\geq n$, a trivial schedule with every job on a different machine is optimal. In some problems the encoding length may be much smaller than $m$, when $m$ is only encoded in binary. However, here a polynomial time algorithm is allowed to have a polynomial dependency on $m$.

Recall that for the $P|\mathcal{U}^{\Gamma}|C_{\max}$ problem, given two $n$ dimensional vectors $\hat{p}$ and $\overline{p}$ and the number of machine $m$, the objective is to create a schedule $\sigma$ that minimizes $\max_{i\in M}C_{\Gamma}(\sigma_{i})$. Recall also that $C_{\Gamma}(\sigma_{i})=\overline{p}(\sigma_{i})+\hat{p}_{\Gamma}(\sigma_{i})$, where $\overline{p}(\sigma_{i})=\sum_{j\in\sigma_{i}}\overline{p}_{j}$, and $\hat{p}_{\Gamma}(\sigma_{i})$ is the sum of the $\hat{p}_{j}$ values of the $\Gamma$ largest jobs (w.r.t. $\hat{p}_{j}$) of $\sigma_{i}$ (or the sum of all $\hat{p}_{j}$ values if $|\sigma_{i}|\leq\Gamma$). To obtain a PTAS for $P|\mathcal{U}^{\Gamma}|C_{\max}$, we will reduce to the following problem, which admits an EPTAS (see [8]).

Problem 2

Unrelated Machines with few Machine Types

• •

Input: $n$ jobs and a set $M$ of $m$ machines with processing times $p_{ij}\geq 0$ for job $j$ on machine $i$. Moreover, there is a constant $k$ and machine types $T_{1}\dot{\cup}\cdots\dot{\cup}T_{k}=\{1,\dotsc,m\}$, such that every machine within a type behaves the same. Formally, for every $k^{\prime}$, every $i,i^{\prime}\in T_{k^{\prime}}$ and every $j\leq n$ it holds that $p_{ij}=p_{i^{\prime}j}$

• •

Output: find a schedule $\sigma:J\rightarrow M$

• •

Objective function: minimize makespan $C(\sigma)=\max_{i\in M}C(\sigma_{i})$, where $C(\sigma_{i})=\sum_{j\in\sigma_{i}}p_{ij}$

Notice that the EPTAS of [8] for this problem provides an $(1+\epsilon)$-approximation running in time $f(|I|,\epsilon,k)=2^{O(k\log(k)\frac{1}{\epsilon}\log^{4}(\frac{1}{\epsilon}))}+poly(|I|)$.

We also introduce the following decision problem.

Problem 3

Unrelated Machines with few Machine Types and capacities

• •

Input: as above, but in addition every machine $i$ has a capacity $c_{i}\in(0,1]$. Moreover, capacities are the same among a type (for any $k^{\prime}\in[k]$, for any $i,i^{\prime}\in T_{k^{\prime}}$, $c_{i}=c_{i^{\prime}}$)

• •

Output: decide if there is a schedule where $C(\sigma_{i})\leq c_{i}$ for any $i$.

Notice that the EPTAS for Problem 2 allows to approximately decide Problem 3 in the following sense.

Lemma 1

There is an algorithm that for any $\epsilon>0$, either outputs a schedule with $C(\sigma_{i})\leq(1+\epsilon)\cdot c_{i}$ for any $i$, or reject the instance, proving that there is no schedule with $C(\sigma_{i})\leq c_{i}$ for any $i$. This algorithm runs in time $f(|I|,\epsilon,k)$ where $f$ is the complexity of the above EPTAS to get a $(1+\epsilon)$-approximation.

Proof

Let $A$ be the EPTAS of [8] for Problem 2. Given a input $I$ of Problem 3 we define an input $I^{\prime}$ of Problem 2 in the following way. For every $j\leq n$, scale $p_{ij}$ to $p_{ij}/c_{i}$. Then, if $A(I^{\prime})\leq(1+\epsilon)$, we can convert the solution found by $A$ into a solution for $I$ of makespan at most $(1+\epsilon)\cdot c_{i}$ for any $i$. Otherwise, as $A$ is a $(1+\epsilon)$-approximation, it implies that $\mathrm{OPT}(I^{\prime})>1$, and thus that no solution can have makespan at most $c_{i}$ for any $i$. ∎

Let us now describe the PTAS for $P|\mathcal{U}^{\Gamma}|C_{\max}$. Our objective is to provide a $(1+O(\epsilon))$ dual approximation for $P|\mathcal{U}^{\Gamma}|C_{\max}$. The constant factor with $\epsilon$ can be ignored, since we can divide $\epsilon$ with this constant in the preprocessing.

1. Guess the makespan and scale $\mathrm{OPT}$ to $1$.

Let $I$ be an input of $P|\mathcal{U}^{\Gamma}|C_{\max}$, and $T$ be a positive value (representing the current threshold). We start by redefining $I$ by scaling $p_{j}:=\frac{p_{j}}{T}$. Our objective is now to produce a schedule $\sigma$ with $C_{\Gamma}(\sigma)\leq 1+\epsilon$, or to prove that $\mathrm{OPT}(I)>1$.

2. Rounding deviations.

Let us now define $I^{1}$ (having vectors $\overline{p}^{1}$ and $\hat{p}^{1}$) in the following way. For any $j$, if $\hat{p}_{j}<\epsilon/\Gamma$ then we set $\hat{p}^{1}_{j}\leftarrow 0$. Intuitively, this will only result in an error of at most $\Gamma\cdot\epsilon/\Gamma$ on every machine. Otherwise ($\hat{p}_{j}\geq\epsilon/\Gamma$), we define $\hat{p}^{1}_{j}$ by rounding $\hat{p}_{j}$ to the closest smaller value of the form $\epsilon/\Gamma\cdot(1+\epsilon)^{i}$.

Observation 1

In $I^{1}$ there are at most $O(1/\epsilon\log(\Gamma/\epsilon))$ deviation values, and at most $O(1/\epsilon\log(1/\epsilon))$ deviation values in the interval $[\epsilon/\Gamma,1/\Gamma]$.

In the following, we will denote by $C^{I^{\prime}}_{\Gamma}(\sigma)$ the cost of $\sigma$ for instance $I^{\prime}$.

Observation 2

If $\mathrm{OPT}(I)\leq 1$ then $\mathrm{OPT}(I^{1})\leq 1$. If we get solution $\sigma^{1}$ of $I^{1}$, then $C^{I}_{\Gamma}(\sigma^{1})\leq(1+\epsilon)C^{I^{1}}_{\Gamma}(\sigma^{1})+\epsilon$

It only remains now to either produce a good solution of $I^{1}$ (of cost at most $1+O(\epsilon)$), or prove that $\mathrm{OPT}(I^{1})>1$.

3. Machine thresholds.

Given any solution $\sigma$ of $I^{1}$ such that $C^{I^{1}}_{\Gamma}(\sigma)\leq 1$, we can associate to $\sigma$ an outline $t=o(\sigma)$ which is defined as follows. For any machine $i$ with more that $\Gamma$ jobs, the threshold value $t_{i}$ is such that any job on $i$ with $\hat{p}_{j}>t_{i}$ deviates (belongs to $\Gamma(\sigma_{i})$) and none of the jobs with $\hat{p}_{j}<t_{i}$ deviate. Notice that among jobs with $\hat{p}_{j}=t_{i}$, some may deviate, but not necessarily all. For any machine $i$ with at most $\Gamma$ jobs, we define $t_{i}=0$, implying again that any job with $\hat{p}_{j}>t_{i}$ deviates on $i$. Notice that in both cases we have $\hat{p}_{\Gamma}(\sigma_{i})\geq\Gamma\cdot t_{i}$. Notice also that $C^{I^{1}}_{\Gamma}(\sigma)\leq 1$ implies $t_{i}\leq\frac{1}{\Gamma}$. Indeed, if we had $t_{i}>\frac{1}{\Gamma}$, there would be $\Gamma$ deviating jobs with $\hat{p}_{j}>t_{i}$, implying $C^{I^{1}}_{\Gamma}(\sigma_{i})>1$, a contradiction. Let us denote by $\Delta$ the set of all possible values of a $t_{i}$. According to Observation 1 we have $|\Delta|=O(1/\epsilon\log(1/\epsilon))$. Let $\mathcal{P}=\Delta^{m}$ be the set of all outlines (of solutions of cost at most $1$).

Lemma 2

Consider a solution $\sigma^{1*}$ of $I^{1}$ such that $C_{\Gamma}(\sigma^{1*})\leq 1$, and let $t^{*}=o(\sigma^{1*})$. Then, we can guess in $m^{O(1/\epsilon\log(1/\epsilon))}$ time the vector $t^{*}$ (or a permutation thereof).

Proof

As $t^{*}\in T$, all the $t^{*}_{i}$ have a value in $\{0\}\cup[\frac{\epsilon}{\Gamma},\frac{1}{\Gamma}]$. Thus, as deviating values are rounded in $I^{1}$, there are only a constant number of possible threshold value and we can guess them. For every possible threshold, we guess how many machines in the optimal solution have it.∎

Thus, we can now assume that we know the vector $t^{*}$.

4. Constructing an instance with few machine types and capacities.

To give an insight of the correct reduction defined below, let us first see what happen if we define an instance $I^{2}(t^{*})$ of $R||C_{\max}$ as follows. For simplicity, we also assume that there are no job with $\hat{p}_{j}=t^{*}_{i}$ on each machine $i$ in the previously considered optimal solution of $I^{1}$. For any machine $i$ and job $j$, define the processing time in $I^{2}(t^{*})$ as $p_{ij}=\overline{p}_{j}+\hat{p}_{j}$ if $\hat{p}_{j}\geq t^{*}_{i}$, and $p_{ij}=\overline{p}_{j}$ otherwise. Then, consider the following implications.

if $OPT(I^{1})\leq 1$, then $\mathrm{OPT}(I^{2}(t^{*}))\leq 1$ 2. 2.

for any solution $\sigma^{\prime}$ of $I^{2}(t^{*})$, $C^{I^{1}}_{\Gamma}(\sigma^{\prime})\leq C^{I^{2}}(\sigma^{\prime})$ (implying that if there exists $\sigma^{\prime}$ with $C^{I^{2}}(\sigma^{\prime})\leq 1+\epsilon$, then we will have our solution for $I^{1}$ of cost $1+\epsilon$)

While Property $(1)$ holds, this is not the case for Property $(2)$. Indeed, suppose that in $\sigma^{\prime}$ there is a machine $i$ such that for all jobs $j$ scheduled on $i$, $\hat{p}_{j}<t^{*}_{i}$. This implies that $C(\sigma_{i})=\sum_{j\in\sigma_{i}}\overline{p}_{j}$. However, if we look now at $\sigma^{\prime}$ in $I^{1}$, we get $C^{I^{1}}_{\Gamma}(\sigma_{i})=C^{I^{2}}(\sigma_{i})+\hat{p}(\Gamma(\sigma_{i}))$, which is greater than the claimed value. To solve this problem we have to remember in $R||C_{\max}$ that there will be a space of size at most $\Gamma\cdot t_{i}$ which will be occupied by deviations.

Let us now turn to the correct version.

Definition 1

For any $t\in\mathcal{P}$, we define the following input $I^{2}(t)$ of Problem 3. We set the machine capacity to

[TABLE]

The addition of $\epsilon$ is only a technicality to ensure that all $c_{i}$ are non-zero. Note that if there are less than $\Gamma$ jobs on $i$, then $t_{i}$ must be [math] and therefore $c_{i}=1+\epsilon$. For every job $j$ set

[TABLE]

Note that at $\hat{p}_{j}=t_{i}$, the values of both cases are equal. Notice also that in $I^{2}(t)$ there are only $|\Delta|$ different machine types.

Lemma 3

If $\mathrm{OPT}(I^{1})\leq 1$ and $t$ is the outline of an optimal solution $\sigma^{2}$, for any $i$, $C^{I^{2}(t)}(\sigma^{2}_{i})\leq c_{i}$.

Proof

Let us consider jobs $\sigma^{2}_{i}$ scheduled on machine $i$. If $t_{i}=0$, then

[TABLE]

Assume now $t_{i}>0$, implying that $|\Gamma(\sigma^{2}_{i})|\geq\Gamma$. By choice of $t_{i}$, every job $j\in\Gamma(\sigma^{2}_{i})$ has $\hat{p}_{j}\geq t_{i}$ and every $j\in\sigma^{2}_{i}\setminus\Gamma(\sigma^{2}_{i})$ has $\hat{p}_{j}\leq t_{i}$. This implies

[TABLE]

∎

Lemma 4

For any $t\in\mathcal{P}$, if there is a solution $\sigma^{2}$ of $I^{2}(t)$ such that $C^{I^{2}(t)}(\sigma^{2}_{i})\leq(1+\epsilon)\cdot c_{i}$ for any $i$, then $C^{I^{1}}_{\Gamma}(\sigma^{2})\leq(1+\epsilon)^{2}$.

Proof

Let $i$ be a machine. Then for every $j\in\sigma^{2}_{i}$,

[TABLE]

Furthermore, for every $j\in\Gamma(\sigma^{2}_{i})$,

[TABLE]

This implies,

[TABLE]

∎

Theorem 4.1

There is a $(1+\epsilon)$-approximation algorithm for $P|\mathcal{U}^{\Gamma}|C_{\max}$ running in time $O(m^{O(1/\epsilon\log(1/\epsilon))}\times f(|I|,\epsilon,O(1/\epsilon\log(1/\epsilon)))$ where $f$ is the function of Lemma 1.

Proof

Given $I$ input of $P|\mathcal{U}^{\Gamma}|C_{\max}$ and a threshold $T$, we run algorithm $A$ of Lemma 1 on $I^{2}(t)$ for any $t\in\mathcal{P}$ with a precision $\epsilon$. If $A$ rejects all the $I^{2}(t)$ then we can reject $T$ according to Observation 2 and Lemma 3. Otherwise, there exists $t_{0}$ such that $A(I^{2}(t_{0}))$ outputs a schedule $\sigma^{2}$ where $C^{I^{2}(t_{0})}(\sigma^{2})\leq(1+\epsilon)\cdot c_{i}$ for any $i$, implying $C^{I}_{\Gamma}(\sigma^{2})\leq(1+\epsilon)C^{I^{1}}_{\Gamma}(\sigma^{2})+\epsilon\leq(1+\epsilon)^{3}+\epsilon\leq 1+5\epsilon$ according to Observation 2 and Lemma 4 (for sufficiently small $\epsilon$). Finally, the running time is as claimed due to the bound of $\mathcal{P}$ in Lemma 2. ∎

5 EPTAS for identical machines

The approach for an EPTAS is similar to the PTAS above. We would like to remove the bottleneck from the previous section, which is the guessing the thresholds. In the PTAS we notice that even if the thresholds were chosen incorrectly, but we find a solution to the derived problem, we can get a good solution for the initial problem. Informally, we will now still create an instance of Problem 3, but we only guess approximately the number of machines for each threshold.

We start by defining $I^{1}$ as in the previous section. Given any solution $\sigma^{1}$ of $I^{1}$ such that $C^{I^{1}}_{\Gamma}(\sigma^{1})\leq 1$, we can associate to $\sigma$ a restricted outline $\overline{m}=\overline{o}(\sigma)$ where $\overline{m}$ is defined as follows. Let $t=o(\sigma)$. For any threshold value $l\in\Delta$, let $m_{l}=|\{i|t_{i}=l\}|$ be the number of machines with threshold $l$ in $\sigma^{1}$. We define $\overline{m}_{l}\in\{0,1,2,4,8,\dotsc,2^{\lfloor\log(m)\rfloor}\}$ such that $\overline{m}_{l}\leq m_{l}<2\overline{m}_{l}$. Let \overline{\mathcal{P}}=\{\overline{m}\in\{0,1,2,4,8,\dotsc,2^{\lfloor\log(m)\rfloor}\}^{\Delta}\mbox{ such that \frac{m}{2}\leq\sum_{l}\overline{m}_{l}\leq m}\} be the set of restricted outlines (of solutions of cost at most $1$).

Lemma 5

Consider a solution $\sigma^{1*}$ of $I^{1}$ such that $C_{\Gamma}(\sigma^{1*})\leq 1$, and let $\overline{m}^{*}=\overline{o}(\sigma^{1*})$. Then, we can guess in time $2^{O(1/\epsilon\log^{2}(1/\epsilon))}+m^{O(1)}$ the vector $\overline{m}^{*}$.

Proof

Clearly it suffices to iterate over all values $\overline{m}_{i}\in\{0,1,2,4,8,\dotsc,2^{\lfloor\log(m)\rfloor}\}$, i.e., $O(\log(m))$ many. Guessing this number for every threshold value in $\Delta$ takes $\log^{O(1/\epsilon\log(1/\epsilon))}(m)$ time. Consider first the case when $\log(m)/\log\log(m)\leq 1/\epsilon\log(1/\epsilon)$. For sufficiently large $m$ it holds that $\log^{1/2}(m)\leq\log(m)/\log\log(m)\leq 1/\epsilon\log(1/\epsilon)$. Hence,

[TABLE]

If on the other hand $\log(m)/\log\log(m)\geq 1/\epsilon\log(1/\epsilon)$, then

[TABLE]

We conclude,

[TABLE]

From all the guesses, we report fail whenever $\sum_{i}m_{i}<m/2$ or $\sum_{i}m_{i}>m$. ∎

For any $\overline{m}\in\overline{\mathcal{P}}$, we define the following input $I^{2}(\overline{m})$ of Problem 3. We first create for any $l$ a set $M_{l}$ of $\overline{m}_{l}$ machines where for each machine $i\in M_{l}$ the capacity and the $p_{ij}$ are defined as in Definition 1 for threshold $t_{i}=l$. Then, we create another set $M^{\prime}_{l}$ of $\overline{m}_{l}$ machines (that we call cloned machines) with the same capacity and the same $p_{ij}$ values. Let $m^{\prime}=\sum\overline{m}_{l}$. Notice that the total number of machines is $2m^{\prime}$, with $m\leq 2m^{\prime}<2m$. Thus, we have to ensure that not too many machines are used in total. For that purpose we add a set of $2m^{\prime}-m$ dummy jobs $D$, where all $j\in D$ have $p_{ij}=\infty$ on the original machines $i\in M_{l}$ and $p_{ij}=c_{i}$ on every cloned machine $i\in M^{\prime}_{l}$. Notice that the number of types is now $2|\Delta|$, which is still small enough to get an EPTAS. Let us call the non-dummy jobs regular jobs.

Lemma 6

If $\mathrm{OPT}(I^{1})\leq 1$ and $\overline{m}$ is the restricted outline of an optimal solution, then there exists a solution $\sigma^{2}$ of $I^{2}(\overline{m})$ such that for any $i$, $C^{I^{2}(\overline{m})}(\sigma^{2}_{i})\leq c_{i}$.

Proof

Let $m^{*}_{l}=|\{i|t_{i}=l\}|$ be the number of machines with threshold $l$ in the considered optimal solution of $I^{1}$. Let $l\in\Delta$ be a threshold value. We first schedule $2\overline{m}_{l}-m^{*}_{l}$ many dummy jobs on cloned machines of $M^{\prime}_{l}$. This will cover all dummy jobs, since

[TABLE]

We will now schedule all remaining jobs on the empty machines. For every threshold value $l$ we have $2\overline{m}_{l}-(2\overline{m}_{l}-m^{*}_{l})=m^{*}_{l}$ many empty machines. In other words, we are left with an instance with the exact same number of machines for each threshold as in the optimal solution and with the original jobs. As argued in Lemma 3, we get the desired claim. ∎

Lemma 7

For any $\overline{m}\in\overline{\mathcal{P}}$, if there is a solution $\sigma^{2}$ of $I^{2}(\overline{m})$ such that $C^{I^{2}(\overline{m})}(\sigma_{i}^{2})\leq c_{i}+\epsilon$ for any $i$, then we can deduce a solution $\sigma^{3}$ for $I^{1}$ with $C^{I^{1}}_{\Gamma}(\sigma^{3})\leq(1+2\epsilon)^{2}$.

Proof

We will first normalize $\sigma^{2}$. Since dummy jobs have $p_{ij}=c_{i}$ on cloned machines, in a $(1+\epsilon)$-approximation there can only be one per machine (assuming that $\epsilon<1$). Indeed, there may still be a load of $\epsilon\cdot c_{i}$ from other jobs on the same machine. We want to ensure that every machine either has a dummy job or some regular load, but not both. For every threshold value $l\in\Delta$, there can be at most $\overline{m}_{l}$ machines in $M^{\prime}_{l}$ that have a dummy job. For any such machine in $M^{\prime}_{l}$, we remove all the regular jobs (of total load of at most $\epsilon\cdot c_{i}$) from it and move them to one of the original machines in $M_{l}$, without using the same machine in $M_{l}$ twice. Since for any $i\in M_{l}$ we had $C^{I^{2}(\overline{m})}(\sigma^{2}_{i})\leq(1+\epsilon)c_{i}$ before moving the jobs, and since regular jobs have the same processing time on machines $M_{l}$ and $M^{\prime}_{l}$, after moving the jobs we get $C^{I^{2}(\overline{m})}(\sigma^{2}_{i})\leq(1+2\epsilon)c_{i}$ for any $i\in M_{l}$. We now have a solution violating the capacities by at most $2\epsilon\cdot c_{i}$ such that a machine with a dummy job has no other jobs.

We now forget about all dummy jobs and the machines they are on. What we are left with is a set of $m$ machines (with some thresholds $t$) such that for any $i$ we have $C^{I^{2}(\overline{m})}(\sigma^{2}_{i})\leq(1+2\epsilon)c_{i}$. By Lemma 4 we get the desired result. ∎

All in all, we were able to reduce the number of instances created to only $2^{O(1/\epsilon\log^{2}(1/\epsilon))}+m^{O(1)}$ many and removed the bottleneck from the PTAS this way. As in Theorem 4.1, given an instance of $P|\mathcal{U}^{\Gamma}|C_{\max}$ we will use the algorithm of Lemma 1 on $I^{2}(m)$ for any $m\in\overline{\mathcal{P}}$. This leads to the following result.

Theorem 5.1

There is a $(1+\epsilon)$-approximation algorithm for $P|\mathcal{U}^{\Gamma}|C_{\max}$ running in time $O(2^{O(1/\epsilon\log^{2}(1/\epsilon))}+m^{O(1)})\times f(|I|,\epsilon,O(1/\epsilon\log(1/\epsilon)))$ where $f$ is the function of Lemma 1.