Approximation schemes for the generalized extensible bin packing problem

TL;DR

This paper introduces an efficient approximation scheme for a generalized bin packing problem where bin costs depend on bin index, improving previous methods and providing new approximation schemes.

Contribution

It presents an EPTAS for a new generalized bin packing problem and an AFPTAS for a related variant, advancing approximation techniques.

Findings

Established an EPTAS for the generalized bin packing problem.

Developed an AFPTAS for a related bin packing variant.

Improved previous PTAS to an EPTAS for the problem.

Abstract

We present a new generalization of the extensible bin packing with unequal bin sizes problem. In our generalization the cost of exceeding the bin size depends on the index of the bin and not only on the amount in which the size of the bin is exceeded. This generalization does not satisfy the assumptions on the cost function that were used to present the existing polynomial time approximation scheme (PTAS) for the extensible bin packing with unequal bin sizes problem. In this work, we show the existence of an efficient PTAS (EPTAS) for this new generalization and thus in particular we improve the earlier PTAS for the extensible bin packing with unequal bin sizes problem into an EPTAS. Our new scheme is based on using the shifting technique followed by a solution of polynomial number of $n$-fold programming instances. In addition, we present an asymptotic fully polynomial time approximation scheme (AFPTAS) for the related bin packing type variant of the problem.

Equations

$$f_i=c_i\cdot {\sigma }_i,\forall i.$$

$$cost_{i}(L_{i})=\left\{\begin{array}[]{l l l}f_{i}&\mbox{ \ \ \ }&\mbox{if }L_{i}\leq c_{i}\\ f_{i}+\sigma_{i}\cdot(L_{i}-c_{i})&&\mbox{otherwise}\end{array}\right.$$

$$p_j^{\prime }=\lceil \frac{p_j}{(1/\epsilon {)}^{\tau (j)-1}}\rceil \cdot \left((1/\epsilon {)}^{\tau (j)-1}\right).$$

$$p_j^{\prime }\le \left(\frac{p_j}{(1/\epsilon {)}^{\tau (j)-1}}+1\right)\cdot \left((1/\epsilon {)}^{\tau (j)-1}\right)\le p_j+\left((1/\epsilon {)}^{\tau (j)-1}\right)\le (1+\epsilon )p_j$$

$$cost(\text{mbox}{Sol}_{nice})$$

$$M(t)=\{i\in \{1,2,\dots ,m\}:\lceil {\log }_{1/{\epsilon }^2}{c}_i\rceil \equiv t\mathrm{mod}\frac{1}{\epsilon }\},$$

$$t_{min}\in \arg \underset{t}{\min }\sum _{i\in M(t)}{f}_i.$$

$$cost(\text{mbox}Sol)$$

$$\le$$

$$\frac{c_i}{c_{i^{\prime }}}\le {\left(\frac{1}{\epsilon }\right)}^{4/\epsilon }.$$

$$\lceil {\log }_{\frac{1}{{\epsilon }^2}}{c}_i\rceil -\lceil {\log }_{\frac{1}{{\epsilon }^2}}{c}_{i^{\prime }}\rceil \ge \frac{2}{\epsilon }.$$

$$J_q=\{j\in J:\frac{c_{\ell (q)}}{\epsilon }\ge p_j>\epsilon \cdot c_{r(q)}\}$$

$$J_q^{\prime }=\{j\in J:\frac{c_{\ell (q+1)}}{\epsilon }<p_j\le \epsilon \cdot c_{r(q)}\}$$

$${\psi }_q=\frac{c_{\ell (q)}}{\epsilon }\cdot \min \left\{n,\lfloor \frac{{\varphi }_{q-1}-{\sum }_{j\in J_{q-1}^{\prime }}{p}_j}{\frac{c_{\ell (q)}}{\epsilon }}\rfloor \right\}.$$

$${\varphi }_{\kappa }=\epsilon \cdot c_{r(\kappa )}\cdot \lceil \frac{{\sum }_{j\in J_{\kappa }^{\prime }}{p}_j}{\epsilon \cdot c_{r(\kappa )}}\rceil .$$

$${\varphi }_q^{\ast }-\sum _{i\in S_q}vol(i)+\sum _{j\in J(q)}{p}_j\le {\psi }_q^{\ast },\text{mbox}and{\varphi }_q^{\ast }\ge \sum _{i\in S_q}vol(i),$$

$$\min \sum _{i\in S_q}\sum _{c\in {\mathcal{C}}_i}cos{t}^i(c)\cdot x_{i,c}.$$

$$\sum _{i\in S_q}\sum _{c\in {\mathcal{C}}_i}{c}_p\cdot x_{i,c}+y_p=n_p.$$

$$\sum _{p\in B_q}\frac{p}{\epsilon c_{r(q)}}\cdot y_p\le \frac{{\psi }_q}{\epsilon c_{r(q)}}.$$

$$\sum _{c\in {\mathcal{C}}_i}{x}_{i,c}=1.$$

$$0\le x_{i,c}\le 1\forall i\in S_q,\forall c\in {\mathcal{C}}_i\text{mbox}and0\le y_p\le n\forall p\in B_q.$$

$$\pi (x)=\underset{i=1,2,\dots ,m}{\min }cos{t}_i(x\cdot \frac{c_{\zeta }}{\epsilon }).$$

Full text

1 introduction

We define the following load balancing on parallel machines problem that we name the generalized extensible bin packing problem (gebp). The input consists of $n$ jobs, where job $j$ has size $p_{j}\geq 0$, there are $m$ machines where for all $i$, machine $i$ is associated with three positive input numbers $f_{i},c_{i},\sigma_{i}$, such that the following assumption holds:

[TABLE]

Assigning the set of jobs $S_{i}$ to machine $i$, incurs a load on machine $i$ that is the total size of jobs in $S_{i}$. That is, the load of machine $i$ that is assigned the set of jobs $S_{i}$ is $L_{i}=\sum_{j\in S_{i}}p_{j}$, and the cost of machine $i$ is

[TABLE]

The goal of gebp is to find a partition of the jobs to $m$ machines such that the total cost of the machines (in this solution) is minimized. In this definition of the cost function of machine $i$, the value of $f_{i}$ is seen as a fixed cost of machine $i$, the value of $c_{i}$ is the standard capacity of machine $i$, and $\sigma_{i}$ is the cost of extending the capacity of machine $i$ by one unit of overtime. The value of $\frac{1}{\sigma_{i}}$ captures the speed in which increasing the total size of jobs assigned to $i$ causes the cost of $i$ to increase by one unit. This speed is similar to the roles of speeds in the environment of uniformly related machines that is widely studied in the scheduling literature. In our study it will be easier to refer to the reciprocal of the speed (i.e., to the values of $\sigma_{i}$) and not to the speeds.

The extensible bin packing problem (ebp) is the special case of gebp where for every machine $i$ we have $f_{i}=c_{i}=\sigma_{i}=1$ (note that these values satisfy (1)). Even this special case is strongly NP-hard via the standard reduction from 3-Partition. This extensible bin packing problem was suggested by [22, 7]. Another special case of gebp that was considered before is the case of extensible bin packing with unequal bin sizes (ebp-ubs). This ebp-ubs is defined as the special case of gebp where for every machine $i$, $\sigma_{i}=1$ and $f_{i}=c_{i}$ (once again (1) holds for such values). Another interesting special case of gebp that generalizes ebp is the generalization from identical machines to uniformly related machines, that is, the special case of gebp where $f_{i}=1$ for all $i$. Observe that this last case does not generalizes ebp-ubs and it is not a special case of ebp-ubs. Our new model is defined in order to generalizes all these special cases.

Before we state our main result and present the literature, we define the notion of approximation algorithms and the different types of approximation schemes. An ${\cal R}$-approximation algorithm for a minimization problem is a polynomial time algorithm that always finds a feasible solution of cost at most ${\cal R}$ times the cost of an optimal solution. The infimum value of ${\cal R}$ for which an algorithm is an ${\cal R}$-approximation is called the approximation ratio of the algorithm. A polynomial time approximation scheme (PTAS) is a family of approximation algorithms such that the family has a $(1+\varepsilon)$-approximation algorithm for any $\varepsilon>0$. An efficient polynomial time approximation scheme (EPTAS) is a PTAS whose time complexity is of the form $f(\frac{1}{\varepsilon})\cdot poly(n)$ where $f$ is some (not necessarily polynomial) computable function, and $poly(n)$ is a polynomial function of the length of the (binary) encoding of the input. A fully polynomial time approximation scheme (FPTAS) is a stronger concept, defined like an EPTAS, but the function $f$ must be a polynomial in $\frac{1}{\varepsilon}$. When we consider an EPTAS we say that an algorithm (for some problem) has a polynomial running time complexity if its time complexity is of the form $f(\frac{1}{\varepsilon})\cdot poly(n)$. Note that while a PTAS may have time complexity of the form $n^{g(\frac{1}{\varepsilon})}$, where $g$ can be polynomial or even super-exponential, this cannot be the case for an EPTAS. The notion of an EPTAS is modern and finds its roots in the FPT (fixed parameter tractable) literature (see [4, 10, 14, 19]). It was introduced in order to distinguish practical from impractical running times of PTAS’s, for cases where a fully polynomial time approximation scheme (FPTAS) does not exist (unless P=NP). In this work, we design an EPTAS for gebp  for which an FPTAS does not exist unless P=NP as gebp is strongly NP-hard.

In [22] Speranza and Tuza analyzed an online variant of ebp and considered the list scheduling heuristic showing that it is a $5/4$-approximation while a slightly improved algorithm is suggested whose approximation ratio is $1.228$ and a lower bound of $7/6$ is established for this online variant. In [7] Dell’Olmo et al. showed that the longest processing time heuristic is a $13/12$-approximation for ebp. The EPTAS of Alon et al. [1, 2] for load balancing on identical machines solves ebp and thus this special case admits an EPTAS prior to this work. The time complexity of this EPTAS for ebp (among other problems on identical machines) was improved in the work of Jansen, Klein, and Verschae [18]. The online problem was studied further in [24]. See also [9, 3, 20] for a study of this special case in the stochastic settings in the context of scheduling operating rooms, and [21] for a use of the approximation algorithms for this problem in PCM interface management arising in wireless switch design.

The study of ebp-ubs was initiated by Dell’Olmo and Speranza [8] who showed that the approximation ratio of the longest processing time heuristic is $4-2\sqrt{2}$ and that the approximation ratio of the online algorithm list scheduling is exactly $\frac{5}{4}$. They also showed that any online algorithm has an approximation ratio of at least $\frac{7}{6}$. The PTAS of Epstein and Tassa [13] for vector scheduling in asymmetric settings gives a PTAS for ebp-ubs. Their assumption that the cost functions of the machines have a common constant upper bound on the Lipschitz constants cannot be met for gebp as this means that the maximum ratio between the costs of extending a pair of machines by one unit of overtime is bounded by a constant (i.e., their scheme assumes that $\frac{\sigma_{i}}{\sigma_{i^{\prime}}}$ is bounded by a constant independent of the pair of machines $(i,i^{\prime})$). The online problem of ebp-ubs was also studied in [23] who analyzed the performance guarantee of list scheduling as a function of the standard capacities of the machines and present an improved online algorithm for the cases $m=2,3$.

Thus, with respect to the existence of approximation schemes, ebp was known to admit an EPTAS while ebp-ubs was known to have a PTAS (that is not an EPTAS). The approximability of gebp as well as its special case of $f_{i}=1$ for all $i$ were not studied before.

Our main result is an EPTAS for gebp. In particular, we improve upon the scheme of [13] for ebp-ubs and present the first EPTAS for this (previously studied) special case. Our scheme first apply preprocessing steps and then breaks the asymmetry between the machines in a two steps approach. In the first step, we use the machinery of the shifting technique in order to partition the instance into polynomially many sub-instances each of which has the additional property that the standard capacities of the machines in the sub-instance are similar. The resulting sub-instance still captures unbounded asymmetry between the machines, and in order to tackle the sub-instances we use the recent algorithms for $n$-fold programming. We refer to [17] for an earlier EPTAS for a different scheduling problem that is based on solving an $n$-fold programming instance. The time complexity of our scheme is a single exponential function of $\frac{1}{\varepsilon}$ times a polynomial of $n,m$.

We conclude this work in Section 5 by showing the existence of an asymptotic fully polynomial time approximation scheme for a related bin packing type variant of the problem similarly to the variant of ebp studied by [6, 5]. In this variant of gebp the number of machines of each type is not part of the input and is determined as part of the solution. Namely, for every $i=1,2,\ldots,m$ we first decide how many machines of type $i$ with a fixed cost $f_{i}$, a standard capacity $c_{i}$, and the cost $\sigma_{i}$ for overtime, to have where for all $i$, $f_{i}=c_{i}\cdot\sigma_{i}$. In a second stage we find a feasible allocation of the jobs to the machines we have (according to the decisions made in the first stage). We denote this variant gebp-bpv. In Section 5 we establish the existence of an asymptotic fully polynomial time approximation scheme (AFPTAS) for gebp-bpv. We note that the special case of one type of machines with $f_{1}=c_{1}=\sigma_{1}=1$ was considered by Coffman and Lueker [6, 5] who presented an AFPTAS for this special case of gebp-bpv.

Paper outline.

We present our EPTAS for gebp in the main part of the paper. This exposition is partitioned into preprocessing steps and characterization of near optimal solutions in Section 2, followed by an analysis of the shifting technique when applied to gebp in Section 3, and finally the use of the $n$-fold programming algorithm to solve the family of sub-instances resulting from the shifting step is described in Section 4. We establish the existence of an AFPTAS for gebp-bpv in Section 5.

2 Preprocessing steps and the structure of a near optimal solution

We assume that $\varepsilon>0$ satisfies that $\frac{1}{\varepsilon}$ is integer. We use the fact that in order to establish the existence of an EPTAS for gebp, it suffices to establish for some integer constant $z$, a $(1+\varepsilon)^{z}$-approximation algorithm whose time complexity is upper bounded by the product of a computable function of $\frac{1}{\varepsilon}$ and a polynomial of the input length. When we state time complexity of steps in our algorithm we ignore polynomial factors of $\frac{1}{\varepsilon}$.

Our preprocessing steps consists of scaling and rounding of the input parameters. Our goal is to assume that job sizes are rounded and that the minimum value of $\sigma_{i}$ is $1$.

First, we consider the scaling of the parameters that allows us to assume that $\min_{i}\sigma_{i}=1$. That is, we prove the following lemma.

Lemma 1

Without loss of generality, $\min_{i}\sigma_{i}=1$.

Proof

Assume that the input of gebp does not satisfy the claim. Then we let $\sigma=\min_{i}\sigma_{i}$, and we do the following. For every machine $i$ we multiply $c_{i}$ by $\sigma$, and we divide $\sigma_{i}$ by $\sigma$. In addition, for every job $j$, we multiply the job size $p_{j}$ by $\sigma$. Observe that the new input satisfies $f_{i}=c_{i}\cdot\sigma_{i}$ for all $i$.

Next, we show that for every solution for the original input, the cost of the solution in the new input is the same as it was in the original input. To see this fact, note that for every machine $i$, its load, i.e., the value of $L_{i}$ is $\sigma$ times its value in the solution for the original input, and thus it satisfies $L_{i}\leq c_{i}$ in the new input if and only if it is satisfied in the original input. Furthermore, the value of $L_{i}-c_{i}$ in the new input is exactly $\sigma$ times its value in the original input, and thus the cost of machine $i$ is the same in the two inputs. ∎

Next, without loss of generality, we assume that machines are sorted according to their standard capacities, that is, we assume $c_{1}\geq c_{2}\geq\cdots\geq c_{m}$.

Throughout this work we use the following observation.

Observation 2.1

Let $x,y$ be two numbers such that $x\leq y\leq(1+\varepsilon)x$ and let $i$ be a machine, then $cost_{i}(x)\leq cost_{i}(y)\leq(1+\varepsilon)\cdot cost_{i}(x)$.

Proof

The inequality $cost_{i}(x)\leq cost_{i}(y)$ holds by the fact that the cost function $cost_{i}$ is monotone non-decreasing (as $\sigma_{i}$ is at least $1$, and thus non-negative). The inequality $cost_{i}(y)\leq(1+\varepsilon)\cdot cost_{i}(x)$ holds by the following argument. If $y<c_{i}$, then $x,y<c_{i}$ and we have $cost_{i}(x)=cost_{i}(y)$ and the inequality holds. Otherwise, $y\geq c_{i}$ and by the assumption $f_{i}=c_{i}\cdot\sigma_{i}$, we conclude $cost_{i}(x)\geq\sigma_{i}\cdot x$ and so $cost_{i}(x)\geq\sigma_{i}\cdot x\geq\sigma_{i}\cdot\frac{y}{1+\varepsilon}=\frac{1}{1+\varepsilon}\cdot cost_{i}(y)$ establishing the required inequality. ∎

Next, we consider the rounding of the jobs sizes and we use the following rounding method. This rounding method is motivated by the fact that the $n$-fold programming formulations which we use to solve sub-instances of the rounded problem later on, assume that all coefficients of the constraint matrix are (relatively small) integers. Thus, for every job $j$, we let $\tau(j)$ be the integer value such that $p_{j}\in\left[\frac{1}{\varepsilon^{\tau(j)}},\frac{1}{\varepsilon^{\tau(j)+1}}\right)$. We let the rounded value of $p_{j}$ be

[TABLE]

The rounded instance $I^{\prime}$ is the instance of gebp in which the values of the input parameters are $c_{i},\sigma_{i},f_{i}$ for all $i$ (such that $\min_{i}\sigma_{i}=1$), and $p^{\prime}_{j}$ for all $j$. In the sequel, we use the fact that in $I^{\prime}$, for every integer value of $\tau$ there are at most $1/\varepsilon^{2}$ distinct rounded job sizes in the interval $\left[\frac{1}{\varepsilon^{\tau}},\frac{1}{\varepsilon^{\tau+1}}\right)$.

For a solution Sol and an instance $\hat{I}$ of gebp, we denote by $cost(\mbox{{Sol}},\hat{I})$ its objective function value where the input parameters are according to $\hat{I}$ (in particular we use this notation for $\hat{I}=I$ and for $\hat{I}=I^{\prime}$). Next we analyze the impact of the rounding step on the performance guarantee of our algorithm.

Lemma 2

Let Sol be a feasible solution. Then, $cost(\mbox{{Sol}},I)\leq cost(\mbox{{Sol}},I^{\prime})\leq(1+\varepsilon)\cdot cost(\mbox{{Sol}},I)$.

Proof

For every job $j$, we have $p^{\prime}_{j}\geq p_{j}$ as we round up the size of $j$. For every $j$, we have $p^{\prime}_{j}\leq(1+\varepsilon)p_{j}$ as $\varepsilon p_{j}\geq(1/\varepsilon)^{\tau(j)-1}$ by definition of $\tau(j)$, and when we round up $p_{j}$ we increase its size by at most $(1/\varepsilon)^{\tau(j)-1}$, that is, we have

[TABLE]

as we argued.

For every machine $i$, the total size of jobs assigned to $i$ in Sol as a solution to $I$ is at most the total size of jobs assigned to $i$ in Sol as a solution to $I^{\prime}$ and this is at most $(1+\varepsilon)$ times the total size of jobs assigned to $i$ as a solution to $I$. The claim follows by Observation 2.1 and summing the costs of all machines. ∎

In what follows, we assume that the original input of gebp satisfies the assumption of Lemma 1 and the job sizes are already rounded as they are in $I^{\prime}$. With a slight abuse of notation, we let $f_{i},c_{i},\sigma_{i}$ be the parameters of machine $i$ and $p_{j}$ be the size of job $j$ (for all $i,j$) in this input which we denote by $I$. It is sufficient to provide an EPTAS for $I$, and this would imply an EPTAS for the original input.

Next, we characterize near optimal solutions. We let $h$ be an index of a machine for which $\sigma_{h}=1$.

Definition 1

A solution Sol for gebp is called a nice solution if for every machine $i\neq h$, the total size of jobs assigned to $i$ (in Sol) is at most $\frac{c_{i}}{\varepsilon}$.

The proof of the following lemma uses the observation that since $\sigma_{h}=1$, adding a set of jobs of total size $x$ to machine $h$ increases the cost of $h$ by at most $x$.

Lemma 3

Let opt be an optimal solution (for the rounded instance) whose cost is denoted as $cost(\mbox{{opt}})$. Then, there is a nice solution $\mbox{{Sol}}_{nice}$ whose cost $cost(\mbox{{Sol}}_{nice})$ is at most $(1+\varepsilon)\cdot cost(\mbox{{opt}})$.

Proof

Consider the solution opt. Let $S$ be the set of machines $i$ such that $i\neq h$ and opt assigns to $i$ a set of jobs $O_{i}$ of total size larger than $\frac{c_{i}}{\varepsilon}$. We create the solution $\mbox{{Sol}}_{nice}$ by changing the assignment of jobs in $\cup_{i\in S}O_{i}$ so that these jobs are assigned to $h$, while the assignment of other jobs is the same as in opt. That is, we reassign the jobs that were assigned to machine in $S$ so that they are assigned to $h$. Observe that the new solution $\mbox{{Sol}}_{nice}$ is indeed a nice solution.

Next, we upper bound the cost of the new solution. Let $L_{i}$ be the total size of jobs assigned by opt to machine $i$ (for all $i$). We have the following.

[TABLE]

however, $\sum_{i}cost_{i}(L_{i})=cost(\mbox{{opt}})$, and thus it suffices to show that for every $i\in S$, we have $f_{i}\leq\varepsilon\cdot cost_{i}(L_{i})$. This follows as $f_{i}=c_{i}\cdot\sigma_{i}\leq\varepsilon\cdot L_{i}\cdot\sigma_{i}=\varepsilon\cdot cost_{i}(L_{i})$ where the inequality holds as $i\in S$ and the last equation holds by the definition of $cost_{i}$ as $L_{i}\geq c_{i}$. ∎

We let opt-nice be an optimal solution among all nice solutions for the rounded instance whose cost is $cost(\mbox{{opt-nice}})$. In what follows we show an algorithm that returns a solution Sol whose cost is at most $(1+\varepsilon)^{4}(1+3\varepsilon)\cdot cost(\mbox{{opt-nice}})$ and its time complexity is $T^{\prime}(n,m,\frac{1}{\varepsilon})$. This solution Sol is a feasible solution to the original instance of gebp that is obtained in time $T^{\prime}(n,m,\frac{1}{\varepsilon})+n+m$ (as the rounding takes $O(n)$ and the scaling takes $O(n+m)$) whose approximation ratio as an approximation algorithm for the original instance of gebp is $(1+\varepsilon)^{6}\cdot(1+3\varepsilon)$.

3 Using the shifting technique to obtain a family of instances with machines with similar standard capacities

We use the shifting technique [16, 15] to partition the rounded instance into a family of problems that can be solved almost independently. For every value of $t=0,1,\ldots,\frac{1}{\varepsilon}-1$ we let

[TABLE]

and we let $t_{min}$ be an index such that

[TABLE]

Observe that the value $t_{min}$ is easily computed in $O(m)$ time.

Recall that opt-nice is the best solution for the rounded instance whose cost is $cost(\mbox{{opt-nice}})$. Let $\mbox{{opt}}^{\prime}$ be the best solution among the nice solutions which allocate no job to machines in $M(t_{min})\setminus\{h\}$. Then, we next show that the cost $cost(\mbox{{opt}}^{\prime})$ of $\mbox{{opt}}^{\prime}$ is close to $cost(\mbox{{opt-nice}})$.

Lemma 4

We have $cost(\mbox{{opt-nice}})\leq cost(\mbox{{opt}}^{\prime})\leq(1+\varepsilon)\cdot cost(\mbox{{opt-nice}})$.

Proof

The first inequality holds by definition. We prove the second inequality by establishing a nice solution Sol which allocates no job to machines in $M(t_{min})\setminus\{h\}$ and we bound its cost by $(1+\varepsilon)\cdot cost(\mbox{{opt-nice}})$. Consider opt-nice and let $J$ be the set of jobs which opt-nice assigns to machines in $M(t_{min})\setminus\{h\}$. In order to construct Sol we modify opt-nice by changing the allocation of $J$ and we assign these jobs to machine $h$ (and recall that $\sigma_{h}=1$). Clearly by moving jobs from machines to machine $h$ the property of nice solutions cannot be hurt as the load in Sol of every machine which is not $h$ is not larger than it was in opt-nice. Furthermore Sol does not allocate jobs to machines in $M(t_{min})\setminus\{h\}$. Last, the cost of Sol denoted as $cost(\mbox{{Sol}})$ satisfies

[TABLE]

where (2) holds as for every machine $i\in M(t_{min})\setminus\{h\}$ that opt-nice assigns a total load of $x$ (for $x\geq 0$) its cost in opt-nice was at least $\sigma_{i}\cdot x\geq x$ and this extra load on machine $h$ increases the cost of $h$ by at most $x$, and thus the increase of the cost of the solution due to the reallocation of jobs of size $x$ to machine $h$ is at most $f_{i}$ (the cost of $i$ in Sol); inequality (3) holds by definition of $t_{min}$; and (4) follows by the definition of the objective function of gebp. ∎

In what follows, we enforce the algorithm to allocate no job to machines in $M(t_{min})\setminus\{h\}$. Since $\mbox{{opt}}^{\prime}$ is an optimal nice solution subject to this additional constraint, we conclude that it suffices to construct a feasible solution Sol whose cost is approximately $cost(\mbox{{opt}}^{\prime})$. Next, we delete the set of machines $M(t_{min})\setminus\{h\}$ from the instance. This deletion of machines does not hurt the feasibility of Sol and of $\mbox{{opt}}^{\prime}$ (as these solutions do not allocate jobs to the deleted machines), however, it decreases the cost of both solutions by a common non-negative constant that is the total fixed cost of the deleted machines. Thus, it suffices to show that we can design an EPTAS for the instance resulted from $I$ by deleting the machines in $M(t_{min})\setminus\{h\}$. Once again, with a slight abuse of notation we assume that the instance $I$ is the instance resulted from this deletion of machines and denote by $\{1,2,\ldots,m\}$ the set of machines in $I$ such that $c_{1}\geq c_{2}\cdots\geq c_{m}$.

We partition the machine set of the instance $I$ resulting from the deletion of $M(t_{min})\setminus\{h\}$. This partition is obtained by letting each partition $S$ be a maximal (with respect to inclusion) set of consecutive indices of machines such that there are no two consecutive indices $i,i+1\in S$ satisfying $\frac{c_{i}}{c_{i+1}}\geq\left(\frac{1}{\varepsilon}\right)^{2}$. We let $\kappa$ be the number of partitions in this partition $(S_{1},\ldots,S_{\kappa})$ such that for every $q$, and for every $i(q)\in S_{q}$ and $i(q+1)\in S_{q+1}$ we have $c_{i(q)}>c_{i(q+1)}$ and in fact we have $\varepsilon^{2}\cdot c_{i(q)}\geq c_{i(q+1)}$, by the sorting of the machines. For $q=1,2,\ldots,\kappa$, let $\ell(q)=\min\{i:i\in S_{q}\}$ and $r(q)=\max\{i:i\in S_{q}\}$ so the indices in $S_{q}$ are those between $\ell(q)$ and $r(q)$. A crucial property for our algorithm is the following one.

Lemma 5

For every $q=1,2,\ldots,\kappa$, and every pair of machines $i,i^{\prime}\in S_{q}$, we have

[TABLE]

Proof

Assume by contradiction that the claim does not hold for $i,i^{\prime}\in S_{q}$. Then, $\frac{c_{i}}{c_{i^{\prime}}}>\left(\frac{1}{\varepsilon^{2}}\right)^{2/\varepsilon}$. Then, $\log_{\frac{1}{\varepsilon^{2}}}c_{i}-\log_{\frac{1}{\varepsilon^{2}}}c_{i^{\prime}}>\frac{2}{\varepsilon}.$ By the integrality of $\frac{2}{\varepsilon}$, we conclude that the following holds.

[TABLE]

Thus, by the pigeonhole principle, there are at least two integers $x<y$ which are equivalent to $t_{min}$ modulo $\frac{1}{\varepsilon}$ such that $\left\lceil\log_{\frac{1}{\varepsilon^{2}}}c_{i}\right\rceil\geq y>x>\left\lceil\log_{\frac{1}{\varepsilon^{2}}}c_{i^{\prime}}\right\rceil$. Next, we define $z$ to be either $x$ or $y$ according to the following rule. If $\left\lceil\log_{\frac{1}{\varepsilon^{2}}}c_{h}\right\rceil\neq x$ then we let $z=x$, and otherwise we let $z=y$. Then, observe that when we deleted the set of machines $M(t_{min})\setminus\{h\}$, we deleted all machines with standard capacities in the interval $\left(\left(\frac{1}{\varepsilon^{2}}\right)^{z-1},\left(\frac{1}{\varepsilon^{2}}\right)^{z}\right]$ and in particular $c_{i}$ and $c_{i^{\prime}}$ do not belong to this interval. Let $i^{\prime\prime}$ be the maximum index of a machine with $c_{i^{\prime\prime}}>\left(\frac{1}{\varepsilon^{2}}\right)^{z}$. Then, since $x\leq z\leq y$ by definition of $i^{\prime\prime}$ we have $c_{i}\geq c_{i^{\prime\prime}}>c_{i^{\prime}}$, however the ratio between $c_{i^{\prime\prime}}$ and $c_{i^{\prime\prime}+1}$ is strictly larger than $\frac{1}{\varepsilon^{2}}$ contradicting the assumption that $i,i^{\prime}\in S_{q}$ so $i,i^{\prime},i^{\prime\prime},i^{\prime\prime}+1\in S_{q}$, and thus the claim follows. ∎

We next partition the job set $J=\{1,2,\ldots,n\}$ as follows. For $q=1,2,\ldots,\kappa$ the job subset $J_{q}$ is defined as

[TABLE]

The set $J_{0}$ is $J_{0}=\{j\in J:p_{j}>\frac{c_{1}}{\varepsilon}\}$ and for every $q=1,2,\ldots,\kappa$ the set

[TABLE]

where $c_{\ell(\kappa+1)}=0$. Observe that every nice solution allocates all jobs of $J_{0}$ to machine $h$, and for every $q$ it allocates all jobs of $J_{q}\cup J^{\prime}_{q}$ to machines in $\{h\}\cup\bigcup_{i=1}^{q}S_{i}$.

For $q=1,2,\ldots,\kappa$, we define a relaxation of the problem gebp where the set of machines is $S_{q}$, the set of jobs is $J_{q}$ and in addition we have sand consisting of jobs of total size $\phi_{q}$, and where we need to schedule all jobs and the sand on the machines $S_{q}$ but we are allowed to leave jobs and sand of total size at most $\psi_{q}$ unscheduled (these jobs are assigned to machines with indices smaller than $\ell(q)$ or to machine $h$). The notion of sand means that the jobs that are part of the sand can be assigned fractionally to machines. We denote by $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$ the relaxation corresponding to the index $q$ together with the two numerical parameters $\phi_{q},\psi_{q}$.

We will show that if $\phi_{q}$ is an integer multiply of $\varepsilon\cdot c_{r(q)}$ while $\psi_{q}$ is an integer multiply of $\frac{c_{\ell(q)}}{\varepsilon}$, then $\mbox{{aux}}_{q}$ can be approximated within a multiplicative factor of $(1+\varepsilon)$ with time complexity that fits the assumptions of an EPTAS. That is, we will prove the following theorem in the next section.

Theorem 3.1

There exists an algorithm Alg that given an instance of $\mbox{{aux}}_{q}$ defined by $q,\phi_{q},\psi_{q}$ such that $\phi_{q}$ is an integer multiply of $\varepsilon\cdot c_{r(q)}$ while $\psi_{q}$ is an integer multiply of $\frac{c_{\ell(q)}}{\varepsilon}$, Alg returns a $(1+\varepsilon)$-approximated solution to $\mbox{{aux}}_{q}$ and the time complexity of Alg is upper bounded by $T(m,n,\frac{1}{\varepsilon})$ where $T(m,n,\frac{1}{\varepsilon})=O(\left((1/\varepsilon)^{{O(1/\varepsilon^{10})}}\right)\cdot m^{2}\log^{3}m)$.

Before presenting the proof of Theorem 3.1, we show that the existence of the algorithm Alg is sufficient to guarantee the existence of an EPTAS for gebp.

Theorem 3.2

There is an algorithm with time complexity $O(n^{2}\cdot m\cdot T(m,n,\frac{1}{\varepsilon}))$ that given the rounded instance returns a solution whose cost is at most $(1+\varepsilon)^{4}(1+3\varepsilon)\cdot cost(\mbox{{opt-nice}})$.

Proof

It suffices to construct a $(1+\varepsilon)^{3}(1+3\varepsilon)$-approximation algorithm for the rounded instance after deleting the machines in $M(t_{min})\setminus\{h\}$.

The first step of the algorithm is to apply Alg on a family $\cal F$ of inputs consisting of the following ones. For every $q=1,2,\ldots,\kappa$, for every $\phi_{q}$ in the interval $[0,n\cdot\varepsilon\cdot c_{r(q)}]$ that is an integer multiply of $\varepsilon\cdot c_{r(q)}$, and for every $\psi_{q}$ in $[0,n\cdot\frac{c_{\ell(q)}}{\varepsilon}]$ that is an integer multiply of $\frac{c_{\ell(q)}}{\varepsilon}$, we apply Alg to solve approximately the instance $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$. We denote by $A(q,\phi_{q},\psi_{q})$ the cost of the solution $\mbox{{Sol}}(q,\phi_{q},\psi_{q})$ returned by Alg when applied on the instance $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$. The time complexity of the first step is $O(n^{2}m\cdot T(m,n,\frac{1}{\varepsilon}))$ as the number of inputs solved by Alg is at most $O(n^{2}m)$ using $\kappa\leq m$.

The second step is to use dynamic programming in order to concatenate a sequence of inputs in the family $\cal F$ consisting of one input for each value of $q$. We define the dynamic programming formulation as a shortest path computation in a directed layered graph $G=(V,E)$. The graph consists of $\kappa+1$ layers denoted as $L_{0},L_{1},L_{2},\ldots,L_{\kappa}$ and one additional node $t$. The nodes of layer $L_{q}$ are associated with the possible value of $\phi_{q}$. This defines the nodes of layers $L_{1},L_{2},\ldots,L_{\kappa}$, however to use this definition for layer $L_{0}$ we define a value $\phi_{0}$ as the total size of jobs in $J_{0}$ plus the value of $\psi_{1}$, i.e., $\phi_{0}=\sum_{j\in J_{0}}p_{j}+\psi_{1}$. Thus, in every layer there are $n+1$ nodes, and in total there are $O(nm)$ nodes in $G$. We next describe the edge set of $G$ together with the length associated with each edge. For $q=\kappa,\kappa-1,\ldots,1$ and a node $\phi_{q}$ in layer $L_{q}$ and node $\phi_{q-1}$ in layer $L_{q-1}$ we have an edge from the node $\phi_{q}$ in $L_{q}$ towards node $\phi_{q-1}$ in $L_{q-1}$ whose length is defined as follows. We compute a value $\psi_{q}$ that is the maximum integer multiply of $\frac{c_{\ell(q)}}{\varepsilon}$ such that together with the total size of jobs in $J^{\prime}_{q-1}$ the resulting size is at most $\phi_{q-1}$. That is, for $q\geq 2$, we compute

[TABLE]

The value of $\psi_{1}$ is computed slightly different. We subtract from $\phi_{0}$ the total size of jobs in $J_{0}$ and the resulting value is $\psi_{1}$ (note that this is already a rounded value). That is, $\psi_{1}=\phi_{0}-\sum_{j\in J_{0}}p_{j}$. The length of the edge in the graph between these two nodes is defined as $A(q,\phi_{q},\psi_{q})$. For every node $\phi_{0}$ in layer $L_{0}$ we have an edge from this node directed to $t$ whose length is $\phi_{0}$. This length of the edges directed to $t$ is motivated by the fact that assigning jobs of total size $\phi_{0}$ to machine $h$ costs at most $\phi_{0}$. In the resulting directed graph we find a shortest path $\cal P$ from the node $\phi_{\kappa}$ in layer $L_{\kappa}$ to node $t$, where $\phi_{\kappa}$ is defined as follows.

[TABLE]

The time complexity of the second step is determined by the number of edges in the graph that is at most $O(n^{2}m)$. We denote by $\phi^{*}_{q}$ the node in layer $L_{q}$ that belongs to the shortest path computed by the algorithm, and we let $\psi^{*}_{q}$ be the corresponding value of $\psi_{q}$ that the algorithm computed using (5) for the sequence of $\phi^{*}$.

The third (and last) step of the algorithm is to compute a feasible solution for gebp whose cost is at most $(1+\varepsilon)$ times the total length of $\cal P$. For $q=\kappa,\kappa-1,\ldots,1$, we show that we can assign (integrally) the jobs $J_{q}$ and small jobs of total size $\phi^{*}_{q}$ each of which of size at most $\varepsilon\cdot c_{r(q)}$ such that a total size of at most $\psi^{*}_{q}$ is not assigned (such a solution is called feasible), and the cost of this feasible solution is at most $(1+\varepsilon)\cdot A(q,\phi^{*}_{q},\psi^{*}_{q})$.

Consider one specific value of $q$. We say that the jobs in $J_{q}$ are large and the other jobs are small. The solution $\mbox{{Sol}}(q,\phi^{*}_{q},\psi^{*}_{q})$ returned by Alg specifies the assignment of large jobs to machines in $S_{q}$ (some of these jobs might be unassigned) and for each machine $i\in S_{q}$ it defines a volume $vol(i)$ of sand that is assigned to $i$. We denote by $J(q)\subseteq J_{q}$ the set of large jobs that the solution $\mbox{{Sol}}(q,\phi^{*}_{q},\psi^{*}_{q})$ does not assign to machines in $S_{q}$. The feasibility of the solution $\mbox{{Sol}}(q,\phi^{*}_{q},\psi^{*}_{q})$ (for $\mbox{{aux}}_{q}$) ensures the following inequalities.

[TABLE]

where the first inequality holds by the guarantee on the total size of jobs and sand that the solution does not assign, and the second inequality follows by the fact that the total size of sand in the instance is at most $\phi^{*}_{q}$. In the solution that we create we assign the jobs in $J_{q}\setminus J(q)$ exactly as in $\mbox{{Sol}}(q,\phi^{*}_{q},\psi^{*}_{q})$, while for the assignment of small jobs we consider the list of small jobs $Small$ and we process the machines in $S_{q}$ one by one in an arbitrary order as long as $Small$ is not empty. When considering the current machine $i$, we find a minimum prefix of $Small$ whose total size is at least $vol(i)$, this prefix of jobs is assigned to $i$, we delete it from $Small$ and move to the next machine in $S_{q}$. If this prefix is undefined, it means that the total size of jobs in $Small$ is smaller than $vol(i)$ and we assign all jobs in $Small$ to $i$ (and stop the assignment process of small jobs to machines in $S_{q}$). The time complexity of this step is $O(n+m)$. Furthermore, if there is a machine $i$ such that when processing $i$ all jobs in $Small$ are assigned to $i$, then all small jobs are assigned and the feasibility of the solution we create to machines in $S_{q}$ follows by (6). Otherwise, every machine $i\in S_{q}$ receives a total size of small jobs of at least $vol(i)$, and once again by (6) the resulting solution we create is a feasible solution. We observe that for every machine $i\in S_{q}$, the total size of jobs assigned to $i$ is at most $\varepsilon\cdot c_{r(q)}\leq\varepsilon c_{i}$ larger than the total size of jobs (and sand) assigned to $i$ in $\mbox{{Sol}}(q,\phi^{*}_{q},\psi^{*}_{q})$. By observation 2.1, this increase of the total size of jobs assigned to $i$ may increase the cost of $i$ by a multiplicative factor of at most $(1+\varepsilon)$ as we show next. If $x$ denotes the total size of jobs and sand assigned to $i$ in $\mbox{{Sol}}(q,\phi^{*}_{q},\psi^{*}_{q})$, then the cost of $i$ in that solution is $cost_{i}(\max\{x,c_{i}\})$ and in our solution it is at most $cost_{i}(x+\varepsilon\cdot c_{i})\leq cost_{i}((1+\varepsilon)\cdot\max\{x,c_{i}\})\leq(1+\varepsilon)\cdot cost_{i}(\max\{x,c_{i}\})$ where the first inequality follows by the monotonicity of the cost function and the second inequality by Observation 2.1. In order to use the induction (and decrease the value of $q$ by $1$), note that the total size of jobs not assigned to machines that are not $h$ and with indices at least $\ell(q)$ which are of size at most $\frac{c_{\ell(q)}}{\varepsilon}$ is at most $\psi^{*}_{q}$, and the total size of jobs with sizes in the interval $(\frac{c_{\ell(q)}}{\varepsilon},\varepsilon\cdot c_{r(q-1)}]$ is the total size of jobs in $J^{\prime}_{q-1}$. Thus, by the definition of $\psi^{*}_{q}$ in terms of $\phi^{*}_{q-1}$, we conclude that the total size of jobs of size at most $\varepsilon\cdot c_{r(q-1)}$ that are still unscheduled is at most $\phi^{*}_{q-1}$ and indeed we guarantee the assumption on the recursive algorithm for $q-1$. The claim follows as any set of jobs of total size at most $\phi^{*}_{0}$ can be assigned to machine $h$ increasing the cost of that machine by at most $\phi^{*}_{0}$ that is the length of the edge of $\cal P$ adjacent to $t$.

The theorem follow by showing that the graph $G$ has a path $P_{opt}$ whose total length is at most $(1+\varepsilon)\cdot(1+3\varepsilon)\cdot cost(\mbox{{opt}}^{\prime})$ where $\mbox{{opt}}^{\prime}$ is a cheapest solution among all nice solutions which do not allocate jobs to machines in $M(t_{min})\setminus\{h\}$. Based on opt’ we define a fractional value of $\phi_{q}$ for all $q=0,1,2,\ldots,\kappa$ as follows where we let $J^{\prime}_{0}=J_{0}$. For a given value of $q$, the fractional value $\hat{\phi}_{q}$ of $\phi_{q}$ is the total size of jobs in $J^{\prime}_{q}\cup\bigcup_{q^{\prime}=q+1}^{\kappa}(J_{q^{\prime}}\cup J^{\prime}_{q^{\prime}})$ that opt’ assigns to machines in $\{h\}\cup\bigcup_{q^{\prime}=1}^{q}S_{q^{\prime}}$. Similarly, we define $\hat{\psi}_{q}=\hat{\phi}_{q-1}-\sum_{j\in J^{\prime}_{q-1}}p_{j}$. By the definition of $\mbox{{aux}}_{q}$ we conclude that the cost of an optimal solution to $\mbox{{aux}}_{q}(\hat{\phi}_{q},\hat{\psi}_{q})$ is at most the cost opt’ pays for machines in $S_{q}$.

Next, for every $q=1,2,...,\kappa$, we round up $\hat{\psi}_{q}$ to the next integer multiply of $\varepsilon\cdot c_{r(q-1)}$ and we denote by $\psi^{\prime}_{q}$ this rounded up value. This may force us to increase $\phi_{q-1}$ and thus our next step is to round up $\hat{\phi}_{q}$ (for all $q=1,2,\ldots,\kappa$) to the next integer multiply of $\varepsilon\cdot c_{\ell(q)}$ and to add another $\varepsilon\cdot c_{\ell(q)}$ to the rounded up value to get the value $\phi^{\prime}_{q}$. The rounding of $\phi^{\prime}_{0}$ is different and we round down $\hat{\phi}_{0}$ to the next value of the form of the total size of jobs in $J_{0}$ plus an integer multiply of $\varepsilon\cdot c_{\ell(1)}$.

When we compare the two instances (for $q\geq 1$) of the auxiliary problem $\mbox{{aux}}_{q}(\hat{\phi}_{q},\hat{\psi}_{q})$ with $\mbox{{aux}}_{q}(\phi^{\prime}_{q},\psi^{\prime}_{q})$, we can take a solution of the first one and add $3\varepsilon\cdot c_{\ell(q)}$ size of sand to machine $c_{\ell(q)}$ to get a feasible solution of the second problem. This is sufficient even for $q=1$ to get a feasible solution for the instance we solved for the edge between $\phi^{\prime}_{1}$ in layer $L_{1}$ to node $\phi^{\prime}_{0}$ in layer $L_{0}$. This additional sand increases the cost of machine $\ell(q)$ by a multiplicative factor of at most $(1+3\varepsilon)$ but this input satisfies the assumptions for which Alg is a $(1+\varepsilon)$-approximation for aux. Thus, the length of the edge between $\phi^{\prime}_{q}$ in layer $L_{q}$ to $\phi^{\prime}_{q-1}$ in layer $L_{q-1}$ is at most $(1+\varepsilon)\cdot(1+3\varepsilon)$ times the total cost of the machines in $S_{q}$ that opt’ pays. Since $\phi^{\prime}_{0}$ is smaller than $\hat{\phi}_{0}$, we conclude that the total size of jobs which opt’ assigns to $h$ is larger than the one in our solution due to this edge directed to $t$. ∎

4 Approximating $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$ via the use of $n$-fold programming

We assume that $\phi_{q}$ is an integer multiply of $\varepsilon\cdot c_{r(q)}$ while $\psi_{q}$ is an integer multiply of $\frac{c_{\ell(q)}}{\varepsilon}$ (and hence also an integer multiply of $\varepsilon\cdot c_{r(q)}$). We first show that by restricting ourselves to solutions of $\mbox{{aux}}_{q}$ for which the total size of sand assigned to each machine is an integer multiply of $\varepsilon c_{r(q)}$ the approximation ratio is multiplied by at most $1+\varepsilon$. We denote by $\mbox{{aux}}^{\prime}_{q}(\phi_{q},\psi_{q})$ the resulting auxiliary problem with this additional constraint.

Lemma 6

Let $\mbox{{Sol}}^{\prime}$ be an optimal solution for $\mbox{{aux}}^{\prime}_{q}(\phi_{q},\psi_{q})$, then $\mbox{{Sol}}^{\prime}$ is a $(1+\varepsilon)$-approximation for $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$.

Proof

$\mbox{{Sol}}^{\prime}$ is clearly a feasible solution to $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$. It thus suffices to upper bound its cost. Let Sol be an optimal solution for $\mbox{{aux}}_{q}(\phi_{q},\psi_{q})$. We modify the (total) size of sand assigned to each machine $i\in S_{q}$ by rounding it up to the next integer multiply of $\varepsilon\cdot c_{r(q)}$. If the total size of sand which we allocate is larger than $\phi_{q}$, then we decrease integer multiplies of $\varepsilon\cdot c_{r(q)}$ from the size of sand assigned to some machines so that the total size of sand which we assigned is exactly $\phi_{q}$. Observe that by rounding up the size of sand assigned to each machine we increase its load by at most $\varepsilon\cdot c_{r(q)}$. Let $x$ be the original load of $i$ (in Sol) and let $y$ be its load in the new created solution, then we have $x\leq y\leq x+\varepsilon c_{r(q)}$. If $y\leq c_{i}$, then the cost of machine $i$ is $f_{i}$ in both solutions. Otherwise, $cost_{i}(y)\leq cost_{i}(x)+\varepsilon f_{i}\leq(1+\varepsilon)cost_{i}(x)$. Thus, the cost of $\mbox{{Sol}}^{\prime}$ is at most $1+\varepsilon$ times the cost of Sol. ∎

Based on Lemma 6, the proof of Theorem 3.1 and thus also the proof of Theorem 3.2 follow by establishing an exact algorithm for solving $\mbox{{aux}}^{\prime}_{q}(\phi_{q},\psi_{q})$ (i.e., an algorithm for finding an optimal solution of $\mbox{{aux}}^{\prime}$) whose time complexity is upper bounded by $O\left(\left((1/\varepsilon)^{{O(1/\varepsilon^{10})}}\right)\cdot m^{2}\log^{3}m\right)$ like the algorithm we present next.

The first step of the algorithm is to partition the sand of size $\phi_{q}$ into a set of $\frac{\phi_{q}}{\varepsilon\cdot c_{r(q)}}$ dummy jobs each of which of size $\varepsilon c_{r(q)}$. Observe that the total size of these dummy jobs is $\phi_{q}$ and an assignment of the jobs in $J_{q}$ and the dummy jobs to machines in $S_{q}$ such that the total size of unassigned jobs and dummy jobs is at most $\psi_{q}$ is a feasible solution to $\mbox{{aux}}^{\prime}$ and this is a characterization of the feasible solutions of $\mbox{{aux}}^{\prime}$. Let $J^{q}$ be the set of jobs and dummy jobs of this instance. In what follows we say a job $j$ and mean that $j$ is either a job or a dummy job, that is, we do not distinguish between jobs and dummy jobs of the same size. For every $p$ that is a size of a job in $J^{q}$, we denote by $n_{p}$ the number of jobs of $J^{q}$ of size $p$.

Note that all jobs in $J^{q}$ have sizes that are integer multiply of $\varepsilon c_{r(q)}$ and have sizes of at most $\frac{c_{\ell(q)}}{\varepsilon}$. Due to our rounding of the job sizes there are $O(1/\varepsilon^{2})$ distinct sizes in every interval of sizes where the upper bound is at most $1/\varepsilon$ times the lower bound of the interval. Thus, the number of distinct sizes of jobs in $J^{q}$ is at most $\frac{1}{\varepsilon^{2}}\cdot\left(\log_{1/\varepsilon}\frac{c_{\ell(q)}}{c_{r(q)}}+1\right)<\left(\frac{7}{\varepsilon^{4}}\right)$ where the inequality follows by lemma 5. We let $B_{q}$ be the set of distinct sizes of jobs in $J^{q}$.

For machine $i\in S_{q}$ we define a configuration of machine $i$ as a vector consisting of $|B_{q}|$ components where the components are associated with the elements in $B_{q}$ in increasing order (of the sizes in this set). Each component corresponding to $p\in B_{q}$ represents the number of jobs of size $p$ which are assigned to $i$. This number is a non-negative integer that is at most $\frac{1}{\varepsilon^{2}}\cdot\frac{c_{\ell(q)}}{c_{r(q)}}<\left(\frac{1}{\varepsilon}\right)^{7/\varepsilon}$ (as the load of $i$ is at most $\frac{c_{\ell(q)}}{\varepsilon}$). Thus, the number of distinct configurations of machine $i$ is at most $\left(\frac{1}{\varepsilon}\right)^{(7/\varepsilon)\cdot\left(\frac{7}{\varepsilon^{4}}\right)}=\left(\frac{1}{\varepsilon}\right)^{(49/\varepsilon^{5})}$. Each such configuration of machine $i$ has a cost that is the value of $cost_{i}$ when assigned the set of jobs of this configuration. We denote by ${\cal C}_{i}$ the set of configurations of machine $i$, and for each $c\in{\cal C}_{i}$ we let $cost^{i}(c)$ be the cost of this configuration.

We next formulate $\mbox{{aux}}^{\prime}$ as an integer linear program. The decision variables are $x_{i,c}$ for every machine $i\in S_{q}$ and $c\in{\cal C}_{i}$ that is an indicator variable that equals $1$ when machine $i$ is assigned a configuration $c$ and [math] otherwise, and the set of additional variables $y_{p}$ for every $p\in B_{q}$ encoding the number of jobs in $J^{q}$ of size $p$ which are not assigned to machines in $S_{q}$.

The objective function is clearly to minimize the total cost of the used configurations. That is,

[TABLE]

We have the following families of constraints:

The global constraints.

We have a constraint for each $p\in B_{q}$ saying that every job of size $p$ is either assigned to one of the machines in $S_{q}$ or not assigned to any machine in $S_{q}$. That is, for every $p\in B_{q}$ we introduce the constraint:

[TABLE]

In addition we have a bound of $\psi_{q}$ on the total size of unassigned jobs. We divide this inequality by $\varepsilon c_{r(q)}$ and obtain the following inequality as an additional global constraint.

[TABLE]

We use the division by this common factor to conclude that all coefficients of the global constraints are non-negative integers which are at most $\left(\frac{1}{\varepsilon}\right)^{7/\varepsilon}$. Furthermore, observe that the number of global constraints which we denote by $r$ is a small constant $r=|B_{q}|+1\leq\left(\frac{7}{\varepsilon^{4}}\right)$.

Next, we group the decision variables $x_{i,c}$ in bricks where a brick is the collection of variables corresponding to one specific machine $i$. The columns corresponding to variables of each brick are consecutive columns of the resulting constraint matrix.

The local constraints.

For every brick, namely for every machine $i$, we have one local constraint involving (only) variables of that brick, namely the constraint that each machine is assigned exactly one configuration. That is, for every $i$, the local constraint of brick $i$ is

[TABLE]

In addition, we have lower and upper bounds on the variables. In our settings the $x_{i,c}$ is an indicator variable (so it should be between [math] and $1$) while the $y_{p}$ are non-negative and we can add the additional (meaningless) upper bound of $n$. Thus we introduce the following bounds.

[TABLE]

Using these constraints and variables, the integer linear program formulating $\mbox{{aux}}^{\prime}$ is to minimize the objective (7) subject to the constraints (8) for every $p\in B_{q}$, the constraint (9), the constraints (10) for every $i\in S_{q}$, and the constraints (11) (in addition to the requirement that all variables are integers).

For using the results for $n$-fold programming we note the following bounds.

• •

The number of global constraints is $r\leq\frac{7}{\varepsilon^{4}}$.

• •

The number of local constraints of a brick is $s=1$.

• •

The maximum absolute value of a component of the constraint matrix (i.e., the infinity-norm of the matrix) is $a\leq\left(\frac{1}{\varepsilon}\right)^{7/\varepsilon}$.

• •

The number of variables in every brick is $t\leq\left(\frac{1}{\varepsilon}\right)^{(49/\varepsilon^{5})}$.

• •

The number of bricks is $|S_{q}|\leq m$ while the right hand side is bounded by $n$.

The problem we formulated is a special case of generalized $n$-fold programming where the number of variables $N=|S_{q}|\cdot t+|B_{q}|\leq mt+\frac{7}{\varepsilon^{4}}\leq mt+t$. The running time of the algorithm of Eisenbrand et al. [11] for solving such problem (see the scaling,$\rho$ column of the linear objective case of Corollary 91 in [11]) is upper bounded by $O((ars)^{O(r^{2}s+s^{2}r)}\cdot N^{2}\log^{3}(nN))$. Using our bounds and $s=1$, this is upper bounded by $O((ar)^{O(r^{2})}\cdot(t^{2}\log^{3}t)\cdot(m^{2}\log^{3}m))$. The coefficient $(ar)^{O(r^{2})}\cdot t^{2}\log^{3}t$ is a function of $\varepsilon$ that is upper bounded by $O\left((1/\varepsilon)^{{O(1/\varepsilon^{10})}}\right)$ and $m^{2}\log^{3}m$ is a strongly polynomial bound independent of $\varepsilon$.

5 An asymptotic fully polynomial time approximation scheme for gebp-bpv

When considering asymptotic schemes that return a solution of cost at most $(1+\varepsilon)cost(\mbox{{opt}}(I))+g(1/\varepsilon)$ for some function $g$ where $cost(\mbox{{opt}}(I))$ is the optimal cost of the same instance, the additive term $g(1/\varepsilon)$ is not scalable. In order to use this definition of asymptotic approximation scheme we assume that $\max_{i=1,2,\ldots,m}f_{i}=1$.

Lemma 7

Without loss of generality $\max_{i}f_{i}=1$, and $\min_{i}\sigma_{i}=1$.

Proof

Assume that the claim does not hold. We first scale all the $f_{i},\sigma_{i}$ by dividing these numbers by a common factor of $\max_{i}f_{i}$. Observe that the cost of every feasible solution is scaled by this factor, and the first part of the claim holds. Furthermore, assumption (1) still holds. We apply Lemma 1 and observe that the transformation in the proof of that lemma does not change the fixed costs of machines. ∎

Let $I$ be the resulting instance after (perhaps) changing the input according to the proof of the last lemma. Let $\mbox{{opt}}(I)$ denotes an optimal solution for this instance, and $cost(\mbox{{opt}}(I))$ denotes its cost. We show the existence of an algorithm that returns a feasible solution for $I$ with cost at most $(1+\varepsilon)\cdot(1+2\varepsilon)\cdot cost(\mbox{{opt}}(I))+g(1/\varepsilon)$ and time complexity that is upper bounded by a polynomial in $n,m,\frac{1}{\varepsilon}$.

Lemma 8

Consider an optimal solution Sol for $I$ under the additional constraint that for every $i$ and every machine $\mu$ of type $i$, either Sol assigns a unique job to $\mu$, or the load of $\mu$ is at most $\frac{c_{i}}{\varepsilon}$. Then, the cost of Sol is at most $(1+2\varepsilon)\cdot cost(\mbox{{opt}}(I))$.

Proof

Assume that the assumption is not satisfied with respect to the set of jobs $J^{\prime}$ that $\mbox{{opt}}(I)$ assigns to $\mu$. We replace $\mu$ by a collection of machines of type $i$ and assign $J^{\prime}$ to these machines such that the total cost of these machines is at most $(1+2\varepsilon)$ times the cost of $\mu$ in $\mbox{{opt}}(I)$. Applying this transformation for each machine establish the claim of the lemma.

Consider $J^{\prime}$, for every job of size at least $\frac{c_{i}}{\varepsilon}$ we add a dedicated machine of type $i$ for this job and assign it to its dedicated machine. Performing this step on all such jobs may increase the cost of the solution by at most an additive term of $f_{i}$ but this additive term is at most an $\varepsilon$ fraction of the cost of $\mu$ in $\mbox{{opt}}(I)$. Moreover, if an increase of the cost occurred it means that the resulting set of machines (the new dedicated machines as well as machine $\mu$) satisfy the conditions of the lemma.

If the conditions of the claim do not hold yet, then in particular it means that the remaining set of jobs $J^{\prime\prime}\subseteq J^{\prime}$ that were not assigned to dedicated machines (by the previous modification) have total size larger than $\frac{c_{i}}{\varepsilon}$. Then, we pack these jobs into bins, each of which of capacity $\frac{c_{i}}{\varepsilon}$ using the next-fit heuristic. That is, we have an open machine of type $i$, and we process the jobs one by one. When we process job $j$, we try to assign it to the current open machine. If the resulting set of jobs assigned to the open machine has total size at most $\frac{c_{i}}{\varepsilon}$ we do so, and continue to the next job, otherwise we close the open machine and open a new open machine of type $i$ and assign $j$ there. If $L$ was the total size of jobs in $J^{\prime\prime}$ we use at most $\frac{2\varepsilon L}{c_{i}}$ machines to pack all the jobs in $J^{\prime\prime}$, and this may increase the cost of the resulting solution by the total fixed cost of these machines, that is, by at most $\frac{2\varepsilon L}{c_{i}}\cdot f_{i}=2\varepsilon L\sigma_{i}$ using (1). This is at most $2\varepsilon$ times the cost of assigning $J^{\prime\prime}$ to $\mu$ and the claim follows. ∎

Let $\zeta$ be such that $c_{\zeta}=\max_{i}c_{i}$. Then, by Lemma 8, we conclude that every job of size larger than $\frac{c_{\zeta}}{\varepsilon}$ is allocated a dedicated machine. For each such job, we find the type $i$ for which the resulting cost of the dedicated machine is minimized and we use such machine to process the job. In this way, we eliminate all jobs of size larger than $\frac{c_{\zeta}}{\varepsilon}$. In the remaining instance that we denote as $I^{\prime}$, the load of every machine (in Sol) is at most $\frac{c_{\zeta}}{\varepsilon}$ and for every collection of such jobs there is a type of machines such that if we assign it to such machine, then the resulting cost would be at most $\frac{c_{\zeta}}{\varepsilon}\cdot\sigma_{\zeta}=\frac{f_{\zeta}}{\varepsilon}\leq\frac{1}{\varepsilon}$ where the inequality follows by Lemma 7.

It suffices to construct an asymptotic approximation scheme for $I^{\prime}$ where we modify the definition of the problem so that the load of every machine is at most $\frac{c_{\zeta}}{\varepsilon}$. We next show that such a scheme was established by Epstein and Levin in [12]. To use the results of [12], we transform the instance $I^{\prime}$ into an instance of bin packing with bin utilization cost (BPUC) for which [12] designed an AFPTAS. In BPUC we are given a monotonically non-decreasing non-negative cost function $\pi$, where its domain contains the interval $[0,1]$, and a set of items $\{1,2,\ldots,n\}$, where item $j$ has a non-negative size $s_{j}$ (such that $s_{j}\in[0,1]$ for all $j$). The goal is to partition the items into subsets $S_{1},\ldots,S_{m}$ such that the total size of items in each subset is at most $1$ and the cost, which is defined as $\sum_{i=1}^{m}\pi(\sum_{j\in S_{i}}s_{j})$, is minimized.

In order to transform $I^{\prime}$ into an instance of BPUC, we do the following. The set of items is the set of jobs. The size of item $j$ in the BPUC instance is $\frac{p_{j}}{c_{\zeta}/\varepsilon}$ (that is, the fraction of a largest load of a machine in a solution that satisfies the additional constraint), and to define the bin utilization cost $\pi$ we do the following. For $x\in[0,1]$, we set $\pi(x)$ to be

[TABLE]

Observe the following simple properties. First, $\pi$ is a monotone non-decreasing function as for every $i$ the cost function $cost_{i}$ is monotone non-decreasing. Second for every $x\in[0,1]$ we can evaluate $\pi(x)$ in polynomial time as we can evaluate $cost_{i}$ in constant time for every $i$. Last for every $y>0$ we can find a maximum value $x$ such that $\pi(x)\leq y$, since for every $i$ in constant time we can compute a maximum value of $x$ such that $cost_{i}(x)=y$ (if $y\geq f_{i}$ while if $y<f_{i}$ then there is no $x$ for which $cost_{i}(x)\leq y$). These properties guarantee the assumptions used by [12] to design their AFPTAS for BPUC.

The following theorem follows by the observation that partitioning the jobs of $I^{\prime}$ to subsets according to the solution obtained for BPUC and then choosing for each subset the type of machine that minimizes the cost of assigning the jobs to that machine type, results in a solution for $I^{\prime}$ of the same cost as the cost of the solution for BPUC. This holds also in the other direction if we are given an optimal solution for $I^{\prime}$ we obtain an optimal solution for the input of BPUC. Thus, $I^{\prime}$ is equivalent to the instance we created for BPUC which proves the following theorem.

Theorem 5.1

There is an AFPTAS for gebp-bpv.