Scheduling problems with controllable processing times and a common deadline to minimize maximum compression cost

Abstract

We consider a range of scheduling problems with controllable processing times, in which the jobs must be completed by a common deadline by compressing appropriately their processing times. The objective is to minimize the maximum compression cost. We present a number of algorithms based on common general principles adapted with a purpose of reducing the resulting running times.

1 Introduction

The area of Scheduling with Controllable Processing Times (SCPT) has been active since the 1980s; see surveys [21, 26], as well as the review [31] that covers the most recent developments in the area. In particular, it is demonstrated in [31] that the SCPT models include those models that have been studied within another popular area of research known as Scheduling with Imprecise Computation (SIC), see [10, 18] for the corresponding reviews.

The range of scheduling problems we address in this paper can be described as follows. The jobs of set $N=\left\{ 1,2,\ldots ,n\right\}$ should be processed either on a single machine $M_{1}$ or on parallel machines $M_{1},M_{2},\ldots ,M_{m}$, where $m\ge 2$. Job $j\in N$ arrives at time $r\left( j\right)$ and must be completed by time $d\left( j\right)$. Processing of any job can be preempted and resumed later on the same or on a different machine. In classical scheduling models with fixed processing times, each job $j\in N$ is given a value $p\left( j\right)$ that represents its duration. In the SCPT models, an actual processing time $p\left( j\right)$ of job j is not known in advance, but has to be chosen from a given interval $\left[ l( j),u\left( j\right) \right]$, where $l\left( j\right)$ and $u\left( j\right)$ are a given lower bound and a given upper bound on the processing time, respectively. The value $x\left( j\right) =u\left( j\right) -p\left( j\right)$ shows by how much the largest possible processing time is reduced and is called a compression amount of job $j\in N$.

In the case of the parallel machines, we distinguish between the identical machines and the uniform machines. In the former case, the machines have the same speed, so that for a job j with an actual processing time p(j) the total length of the time intervals in which this job is processed in a feasible schedule is equal to p(j). If the machines are uniform, then it is assumed that machine $M_{i}$ has speed $s_{i}$, $1\le i\le m$. If for job j the value u(j) is compressed to $p\left( j\right)$ and this job is assigned to machine $M_{i}$ alone then the duration of such processing is $p\left( j\right) /s_{i}$.

A popular range of the SCPT problems addresses issues of determining actual processing times of the jobs in such a way that there exists an optimal schedule in which no job $j\in N$ is processed outside the interval $\left[ r\left( j\right) ,d\left( j\right) \right]$ and a certain objective $\Phi$ that depends on compressions $x\left( j\right)$ is minimized. Each job can be associated with a weight $w\left( j\right)$, which reflects its relative importance. The two following objective functions are among those that have received most attention:

• Total compression cost $\Phi _{\Sigma }=\sum _{j\in N}w\left( j\right) x\left( j\right)$, and

• Maximum compression cost $\Phi _{\max }=\max \left\{ x\left( j\right) /w\left( j\right) |j\in N\right\}$.

The problems with the $\Phi _{\Sigma }$ objective are mainly addressed in the mainstream study of SCPT, while those with the $\Phi _{\max }$ objective are studied within the SIC literature. The most recent survey [31] indicates that in the most general setting, when the jobs have arbitrary release dates and arbitrary deadlines, algorithms developed for the problems with the $\Phi _{\Sigma }$ objective for all machine environments and for the $\Phi _{\max }$ objective on parallel machines are not-improvable, since they are as fast as the algorithms for the counterparts with fixed processing times. If the jobs have a common deadline, for the problems of minimizing $\Phi _{\Sigma }$ algorithms are known that perform faster than in the general case. In this paper, we explore the unstudied versions of the problems to minimize $\Phi _{\max }$, in which all jobs have a common deadline $d_{(j)}=d$.

The SIC models, although they have received considerable separate attention, should be viewed as one of possible interpretations of the SCPT models. In the SIC models, the jobs are seen as computational tasks to be processed with preemption in a computing system that consists either of one processor or of several parallel processors (machines). In computing systems that support imprecise computation, some computations (image processing programs, implementations of heuristic algorithms) can be run partially, producing less precise results. In our notation, a task with the processing requirement u(j) can be split into a mandatory part which takes $l\left( j\right)$ time, and an optional part that may take up to $u(j)-l(j)$ additional time units. To produce a result of reasonable quality, the mandatory part must be completed in full, while an optional part improves the accuracy of the solution. If instead of an ideal computation time u(j) task j is executed for $p(j)=u(j)-x(j)$ time units, then computation is imprecise and x(j) corresponds to the error of computation. In the SIC terminology the function $\Phi _{\Sigma }$ is called the total weighted error, while $\Phi _{\max }$ is known as the maximum weighted error.

In accordance with standard scheduling notation, a three-field string $\alpha |r(j),$$C(j)\le d\left( j\right) ,$$pmtn|-$ denotes a feasibility problem, in which it is required to verify whether a set N of jobs with given fixed processing times $p\left( j\right)$, $j\in N$, can be processed with preemption in such a way that each job j starts no earlier than its release date $r\left( j\right)$ and completes no later than its deadline $d\left( j\right)$. Here, in the first field we define a machine environment which could be a single machine ($\alpha =1$), m parallel identical machines ($\alpha =P$), or m parallel uniform machines $(\alpha =Q$). In the middle field, the presence of $r\left( j\right)$ means that the jobs may have individual release date (otherwise, they have a common zero release date). The inequality $C(j)\le d\left( j\right)$ stresses that each job must complete by its deadline, while pmtn points out that preemptive processing is allowed.

For problems with controllable processing times, the notation above is extended to become $\alpha |r(j),$$p(j)=u(j)-x(j),$$C(j)\le d\left( j\right)$, $pmtn|\Phi$, where in the middle field we additionally write $p(j)=u(j)-x(j)$ to emphasize that the actual processing time of each job is obtained by reducing the largest possible processing time $u\left( j\right)$ by $x\left( j\right)$, while in the third field $\Phi$ is an objective function that depends on compressions $x\left( j\right)$, $j\in N$.

It is clear that the running time needed to solve a feasibility problem $\alpha |r(j)$, $C(j)\le d\left( j\right)$, $pmtn|-$ provides a lower bound on the running time that is required to solve the corresponding problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d\left( j\right)$, $pmtn|\Phi$. Table 1 presents the best known running times required for solving the SCPT problems in the most general setting, i.e., with arbitrary release dates and deadlines, with an objective $\Phi \in \left\{ \Phi _{\Sigma },\Phi _{\max }\right\}$, compared with the running times needed to solve the corresponding feasibility problems. We see that the SCPT problems on parallel machines are no harder computationally than the associated feasibility problem. On a single machine, in the case of the $\Phi _{\max }$ objective there is still a complexity gap.

Table 1 Running times for solving feasibility problems $\alpha |r(j),C(j)\le d\left( j\right) ,pmtn|-$ and problems $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d\left( j\right)$, $pmtn|\Phi$

For completeness, we briefly review the algorithmic techniques employed in the methods listed in Table 1. The single machine feasibility problem $1|r(j),C(j)\le d(j),pmtn|-$ in principle cannot be solved faster than finding the sorted sequence of the release dates and deadlines. The best possible running time of $O\left( n\log n\right)$ for solving the problem is achieved by the Earliest Deadline First (EDF) scheduling policy designed by Horn [13]. Notice that the running time of $O\left( n\log n\right)$ remains the best even if either all release dates are zero or all jobs have a common deadline. For problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d(j)$, $pmtn|\Phi _{\Sigma }$, the running time of $O\left( n\log n\right)$, which matches that of the EDF algorithm, is obtained due to reformulating the problem as a linear programming problem over a submodular polyhedron and finding its solution by a novel decomposition algorithm [30].

The feasibility problems on parallel machines are handled by finding the maximum flow in the corresponding bipartite networks; see [4, 13]. McCormick [19] reduces problems with the $\Phi _{\Sigma }$ objective to finding the maximum flow in networks in which capacities of some arcs linearly depend on a parameter, individual for each of these arcs. To deal with the $\Phi _{\max }$ objective, Shioura et al. [31] demonstrate that the corresponding SCPT problems can be reduced to solving lexicographic flow sharing problems in special networks. In these networks, capacities of some arcs depend on a common parameter and the required flow sharing problems can be solved by methods developed in [7], which results into the algorithms that run faster than those reported for these problems in the SIC literature [10]. See [31], where the methodologies outlined above are discussed in detail.

It is quite often required that the jobs must be completed by a common deadline, rather than by individual deadlines. Besides, it is possible that the jobs do not have specific release dates but are available simultaneously at time zero. In such situations, there is a hope that a simplified problem can be solved faster than in the general case. The main purpose of this paper is to develop fast algorithms for the SCPT problems to minimize the maximum cost $\Phi _{\max }$ for these simplified problems. The summary of our results is presented in the last column of Table 2. For completeness, we list in that table the results for the relevant feasibility problems and the SCPT problems to minimize the total compression cost $\Phi _{\Sigma }$.

Table 2 Running times for solving feasibility problems $\alpha |r(j),C(j)\le d,pmtn|-$ and problems $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi$

Notice that for the problems to minimize the objective $\Phi _{\Sigma }$, the results for parallel machine problems quoted in Table 2 are obtained by reformulating the corresponding problem as a linear programming problem over a submodular polyhedron and finding its solution by a novel decomposition algorithm [29]. The only exception is problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$, which is essentially a continuous knapsack problem [16].

2 Problems with a common deadline: general principles

In this section, we outline a generic procedure aimed at solving problems $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ for $\alpha \in \left\{ 1,P,Q\right\}$. We start with some terminology, including that related to optimization with submodular constraints. For the latter purpose, we mainly follow a comprehensive monograph on submodular optimization by [6], see also [17, 25].

For a positive integer n, let $N=\{1,2,\ldots ,n\}$ be a ground set, and let $2^{N}$ denote the family of all subsets of N. For a subset $Y\subseteq N$, let $\mathbb {R}^{Y}$ denote the set of all vectors ${\mathbf {p }}$ with real components p(j), where $j\in Y$. For a vector ${\mathbf {p}} \in \mathbb {R}^{N}$, define $p(Y)=\sum _{j\in Y}p(j)$ for every set $Y\in 2^{N}$.

A set-function $\varphi :2^{N}\rightarrow \mathbb {R}$ is called submodular if the inequality

$$\begin{aligned} \varphi (Y)+\varphi (Z)\ge \varphi (Y\cup Z)+\varphi (Y\cap Z) \end{aligned}$$

holds for all sets $Y,Z\in 2^{N}$. For a submodular function $\varphi$ defined on $2^{N}$ such that $\varphi (\emptyset )=0$, the pair $(2^{N},\varphi )$ is called a submodular system on N, while $\varphi$ is referred to as its rank function. For a submodular system $(2^{N},\varphi )$,

$$\begin{aligned} P(\varphi )=\{{\mathbf {p}}\in \mathbb {R}^{N}\mid p(Y)\le \varphi (Y),\quad Y\in 2^{N}\} \end{aligned}$$

is the submodular polyhedron.

We now define submodular polyhedra for the problems under study. For a set of jobs $Y\subseteq N$, let $\varphi (Y)$ be a set-function that represents the total production capacity available for processing the jobs of set Y. If we ignore the machine speeds, then $\varphi (Y)$ is essentially equal to the length of all time intervals within which the jobs of set Y can be processed. This means that for a problem with fixed processing times a feasible schedule exists if and only if the inequality

$$\begin{aligned} p(Y)\le \varphi (Y) \end{aligned}$$

(1)

holds for all sets $Y\subseteq N$.

The actual representation of function $\varphi \left( Y\right)$ is problem dependent. The capacity functions $\varphi$ for the problems $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi$ are given in [28, 29]. Notice that all these functions are submodular.

Given problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi$, we always assume that $r\left( j\right) +l\left( j\right) \le d$ for each job $j\in N$; otherwise the problem is infeasible. Let $x\left( j\right)$ be a compression amount of job $j\in N$ in some feasible schedule. Then in any feasible schedule $0\le x\left( j\right) \le u\left( j\right) -l\left( j\right)$, or, equivalently, $l\left( j\right) \le p\left( j\right) \le u\left( j\right)$ for each job $j\in N$. A generic problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi$ associated with a capacity function $\varphi$ can be formulated as the following problem with the decision variables $x\left( j\right)$, $j\in N$:

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {\min } &{} \displaystyle \Phi \left( x\left( 1\right) ,\ldots ,x\left( n\right) \right) &{} \\ \mathrm {s.t.} &{} \displaystyle p\left( Y\right) =u\left( Y\right) -x(Y)\le \varphi \left( Y\right) , &{} Y\in 2^{N}, \\ &{} \displaystyle 0\le x(j)\le u(j)-l(j), &{} j\in N. \end{array} \end{aligned}$$

(2)

In the case of minimizing the total cost $\Phi _{\Sigma }$, the objective function is $\sum w\left( j\right) x\left( j\right)$, and by switching to the decision variables $p\left( j\right) =u\left( j\right) -x\left( j\right)$, $j\in N$, we can reduce a problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$ to solving the linear programming problem of the following structure:

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {max} &{} \displaystyle \sum _{j\in N}w(j)p(j) &{} \\ \mathrm {s.t.} &{} \displaystyle p(Y)\le \varphi (Y), &{} Y\in 2^{N}, \\ &{} \displaystyle l(j)\le p(j)\le u(j), &{} j\in N. \end{array} \end{aligned}$$

(3)

Notice that the feasible region of problem (3) is a submodular polyhedron (1) intersected with the box. For $\alpha \in \left\{ P,Q\right\}$, fast algorithms developed in [29] for problems $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$ are based on reformulation of these problems in terms of (3). The optimal actual processing times can be found by solving (3), which can be done by a decomposition algorithm that consists of $O\left( \log n\right)$ iterations.

The maximum cost $\Phi _{\max }$ function is defined by $\max \left\{ x\left( j\right) /w\left( j\right) |j\in N\right\}$, so that problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ can be reformulated as

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {\min } &{} \displaystyle \max \left\{ x\left( j\right) /w\left( j\right) |j\in N\right\} &{} \\ \mathrm {s.t.} &{} \displaystyle u\left( Y\right) -\varphi (Y)\le x\left( Y\right) , &{} Y\in 2^{N}, \\ &{} \displaystyle 0\le x(j)\le u(j)-l(j), &{} j\in N. \end{array} \end{aligned}$$

(4)

It is convenient to rewrite (4) in terms of new decision variables

$$\begin{aligned} \lambda \left( j\right) =\frac{x\left( j\right) }{w\left( j\right) },~j\in N, \end{aligned}$$

(5)

so that problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ reduces to

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {\min } &{} \displaystyle \max \left\{ \lambda \left( j\right) |j\in N\right\} &{} \\ \mathrm {s.t.} &{} \displaystyle u\left( Y\right) -\varphi (Y)\le \sum _{j\in Y}\lambda \left( j\right) w\left( j\right) , &{} Y\in 2^{N}, \\ &{} \displaystyle 0\le \lambda (j)\le \lambda _{j}, &{} j\in N. \end{array} \end{aligned}$$

(6)

where

$$\begin{aligned} \lambda _{j}=\frac{u\left( j\right) -l\left( j\right) }{w\left( j\right) }. \end{aligned}$$

(7)

A variable $\lambda \left( j\right)$ represents the weighted cost of compressing job $j\in N$. Since for job j the largest compression is equal to $u\left( j\right) -l\left( j\right)$, which occurs if the actual processing time of job j is $l\left( j\right)$, the value of $\lambda _{j}$ represents the largest possible contribution that job j can make into the objective function $\Phi _{\max }.$

For simplicity of presentation, throughout this paper we assume that the values of $\lambda _{j}$ defined by (7) are distinct and the jobs are numbered in such a way that

$$\begin{aligned} \lambda _{1}=\min \left\{ \lambda _{j}|j\in N\right\} ,~\lambda _{n}=\max \left\{ \lambda _{j}|j\in N\right\} . \end{aligned}$$

(8)

Denote $\lambda _{0}:=0$. Let $\Lambda$ be the list of the $\lambda$ -values $\lambda _{0},\lambda _{1},\ldots ,\lambda _{n}$. Notice that, unless stated otherwise, we do not assume that the list $\Lambda$ is sorted.

For a job $j\in N$, given a value of $\lambda \in \left[ \lambda _{0},\lambda _{n}\right]$ and $\lambda _{j}$ defined by (7), define the values of the decision variables in (6) by

$$\begin{aligned} \lambda \left( j\right) =\left\{ \begin{array}{ll} \lambda _{j}, &{}\quad \mathrm {if~}\lambda _{j}<\lambda \\ \lambda , &{}\quad \mathrm {if~}\lambda _{j}\ge \lambda \end{array} \right. \end{aligned}$$

(9)

and compute the associated compressions $x\left( j\right)$ by

$$\begin{aligned} x\left( j\right) =\lambda \left( j\right) w\left( j\right) ,~j\in N. \end{aligned}$$

(10)

Here, each of the jobs j with $\lambda _{j}<\lambda$ is fully compressed, i.e., $x\left( j\right) =u\left( j\right) -l\left( j\right)$ and its weighted compression is less than the value of $\lambda$. For each of the other jobs, the weighted compression is equal to $\lambda$.

A given $\lambda \in \left[ \lambda _{0},\lambda _{n}\right]$ is said to be feasible for problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, if variables $\lambda \left( j\right)$, $j\in N$, defined by (9) deliver a feasible solution to problem (6). In scheduling terms, this means that there exists a feasible schedule with actual processing times equal to $u\left( j\right) -x\left( j\right)$, where compressions $x\left( j\right)$, $j\in N$, satisfy (10). For a particular problem, we can check whether $\lambda$ is feasible either analytically (by verifying certain relations that define the feasible region of problem (6)) or by running an algorithm that checks the existence of a feasible schedule with constant processing times associated with the compressions $x\left( j\right)$, $j\in N$.

Below we outline a generic procedure for solving problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$.

Procedure A

• Step 1.Initialization

  Compute $\lambda _{j}$ by (7). If necessary, renumber the jobs so that (8) holds and form the list $\Lambda$.

• Step 2.Check of a trivial solution

  If $\lambda =\lambda _{0}=0$ is feasible, then the optimal compressions are $x^{*}\left( j\right) =0,~1\le j\le n$, with the optimal value of the objective function $\Phi _{\max }$ equal to zero; otherwise go to Step 3.

• Step 3.Check for infeasibility

  If $\lambda =\lambda _{n}$ is infeasible, then the original problem does not have a feasible solution; otherwise go to Step 4.

• Step 4.Localization search

  Examining list $\Lambda$, find the largest infeasible value $\lambda ^{\prime }$ and the smallest feasible value $\lambda ^{\prime \prime }$.

• Step 5.Finding an optimal solution

  Examining the interval $\left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right]$ find an optimal value $\lambda ^{*}$ as the smallest feasible value of $\lambda \in \left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right]$. The optimal compressions $x^{*}\left( j\right)$ are equal to

  $$\begin{aligned} x^{*}\left( j\right) =\left\{ \begin{array}{ll} \lambda _{j}w\left( j\right) , &{} \quad \mathrm {if~}\lambda _{j}<\lambda ^{*}\\ \lambda ^{*}w\left( j\right) , &{}\quad \mathrm {if~}\lambda _{j}\ge \lambda ^{*}. \end{array} \right. \end{aligned}$$

  (11)

The implementation details of the feasibility checks and of Steps 4 and 5 differ for different problems, as presented in the remaining parts of this paper.

All problems considered below can be formulated using a generic problem (4). However, for all these problems there is no need to consider exponentially many inequalities that define the feasible region and the problems can be solved by fast polynomial-time algorithms.

3 Single machine: arbitrary release dates

In this section, we adapt Procedure A to solving problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$.

Assume that the values $\lambda _{j}$ found by (7) are distinct and the jobs are numbered in accordance with

$$\begin{aligned} 0=\lambda _{0}<\lambda _{1}<\cdots <\lambda _{n}, \end{aligned}$$

(12)

so that list $\Lambda =\left( \lambda _{0},\lambda _{1},\ldots ,\lambda _{n}\right)$ is increasing.

Let $R^{\left( z\right) }$ denote the zth smallest release date, while $N^{\left( z\right) }$ be the set of jobs that arrive no earlier than time $R^{\left( z\right) }$, i.e.

$$\begin{aligned} N^{\left( z\right) }=\left\{ j\in N|r\left( j\right) \ge R^{\left( z\right) }\right\} , \end{aligned}$$

(13)

where $1\le z\le n$.

In order to complete all jobs $j\in N^{(z)}$ by the deadline d there must be a sufficient processing capability. If $p\left( j\right) =u\left( j\right) -x\left( j\right) \ge l\left( j\right)$ is an actual processing time of job $j\in N^{(z)}$, then the combined duration of the jobs from $N^{(z)}$ should not exceed the length of the interval [r(j), d], i.e.,

$$\begin{aligned} p\left( N^{\left( z\right) }\right) =u\left( N^{\left( z\right) }\right) -x\left( N^{\left( z\right) }\right) \le d-R^{\left( z\right) } \end{aligned}$$

must hold for each z, $1\le z\le n$; see [9] where that condition is presented (in a different but equivalent form).

Thus, for problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ the generic formulation (4) simplifies, since we do not need to consider all $2^{n}$ inequalities that define the feasible region. The simplified formulation becomes

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {\min } &{} \displaystyle \max \left\{ \frac{x\left( j\right) }{w\left( j\right) }|j\in N\right\} &{} \\ \mathrm {s.t.} &{} \displaystyle u\left( N^{\left( z\right) }\right) -d+R^{\left( z\right) }\le x\left( N^{\left( z\right) }\right) , &{} z=1,\ldots ,n; \\ &{} \displaystyle 0\le x(j)\le u(j)-l(j), &{} j\in N. \end{array} \end{aligned}$$

(14)

Changing the decision variables to $\lambda \left( j\right)$, $j\in N$, defined by (5) the problem can be reformulated as

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {\min } &{} \displaystyle \max \left\{ \lambda \left( j\right) |j\in N\right\} &{} \\ \mathrm {s.t.} &{} \displaystyle u\left( N^{\left( z\right) }\right) -d+R^{\left( z\right) }\le \sum _{j\in N^{\left( z\right) }}\lambda \left( j\right) w\left( j\right) , &{} z=1,\ldots ,n; \\ &{} \displaystyle 0\le \lambda (j)\le \lambda _{j}, &{} j\in N. \end{array} \end{aligned}$$

(15)

For the numbering (12), let us fix an interval $I=\left[ \lambda _{q},\lambda _{q+1}\right]$ between two consecutive elements of list $\Lambda$. For problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, in accordance with (9), a value of $\lambda \in I$ is feasible if

$$\begin{aligned} u\left( N^{\left( z\right) }\right) -d\!+\!R^{\left( z\right) }\le \sum _{j\in \{1,\ldots ,q\}\cap N^{\left( z\right) }}\lambda _{j}w\left( j\right) \!+\!\lambda \sum _{j\in \{q+1,\ldots ,n\}\cap N^{\left( z\right) }}w\left( j\right) ,~1\le z\le n. \end{aligned}$$

(16)

For each set $N^{\left( z\right) }$, $1\le z\le n$, each of the jobs $1,\ldots ,q$ that belongs to that set is fully compressed. On other hand, each of the jobs $q+1,\ldots ,n$ is compressed in such a way that its compression cost is equal to $\lambda$, and none of these jobs, except job $q+1$, becomes fully compressed as long as $\lambda$ changes within $\left[ \lambda _{q},\lambda _{q+1}\right]$. All feasibility checks for a given value of $\lambda$ can be done in linear time.

Below we present an algorithm that is an adaptation of Procedure A to solving problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$.

Algorithm A1

• Step 1. Find the values $R^{\left( z\right) }$ and sets $N^{\left( z\right) }$ for $z=1,2,\ldots ,n$. Compute $\lambda _{j}$ by (7), sort them in accordance with (12) and form list $\Lambda =\left( \lambda _{0}=0,\lambda _{1},\ldots ,\lambda _{n}\right)$.

• Step 2. Check if $\lambda =0$ is feasible. If yes, then the optimal compressions are $x^{*}\left( j\right) =0,~1\le j\le n$, with the optimal value of the objective function $\Phi _{\max }$ equal to zero; otherwise, set $\underline{q}=0$ and go to Step 3.

• Step 3. Check if $\lambda =\lambda _{n}$ is feasible. If not, then the original problem does not have a feasible solution; otherwise set $\overline{q}=n$ and go to Step 4.

• Step 4. Repeat until $\overline{q}=\underline{q}+1$:

  • (a) Compute $q=\left\lceil \left( \overline{q}+\underline{q}\right) /2\right\rceil .$

  • (b) Define $\lambda =\lambda _{q}$. Compute $\lambda (j)$ by (9) and the compressions $x\left( j\right)$ by (10). Use ( 16) to check feasibility of $\lambda$. If $\lambda$ is infeasible, then update $\underline{q}:=q$; otherwise, $\lambda$ is feasible and we update $\overline{q}=q$.

• Step 5. Define $q=\underline{q}$. An optimal maximum compression cost $\lambda ^{*}$ is the smallest feasible value of $\lambda \in \left[ \lambda _{q},\lambda _{q+1}\right]$ found by

  $$\begin{aligned} \lambda ^{*}=\max \limits _{1\le z\le n}\left\{ \frac{u\left( N^{\left( z\right) }\right) -d+R^{\left( z\right) }-\sum \nolimits _{j\in \{1,\ldots ,q\}\cap N^{\left( z\right) }}\lambda _{j}w\left( j\right) }{ \sum \nolimits _{j\in \{q+1,\ldots ,n\}\cap N^{\left( z\right) }}w\left( j\right) }\right\} . \end{aligned}$$

  (17)

  The optimal compressions $x^{*}\left( j\right)$ are defined by (11).

In Algorithm A1, the loop performed in Step 4 is a binary search procedure that implements the localization search of Step 4 of Procedure A. We come to Step 5 having found an interval $\left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right] =\left[ \lambda _{q},\lambda _{q+1}\right]$, such that $\lambda _{q}$ is infeasible and $\lambda _{q+1}$ is feasible.

Step 5 of Algorithm A1 corresponds to Step 5 of Procedure A. Here, all jobs $j\le q$ are fully compressed, while each of the remaining jobs $q+1,\ldots ,n$ is compressed in such a way that its weighted compression cost is equal to a common value $\lambda$. The formula (17) for an optimal value $\lambda ^{*}$ is derived from (16).

The binary search in Step 4 consists of $O(\log n)$ iterations, each iteration takes $O\left( n\right)$ time. Finding the optimal value of $\lambda ^{*}$ in Step 5 also takes $O\left( n\right)$ time. Thus, the following statement holds.

Theorem 1

Problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is solvable in $O\left( n\log n\right)$ time.

An alternative algorithm for problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d,$$pmtn|\Phi _{\max }$ of the same running time can be obtained by linking the problem of minimizing the maximum compression to the problem of minimizing a quadratic cost function over the same feasible region.

Based on the input data for problem 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, define the problem

$$\begin{aligned}{}\begin{array}[t]{lll} \mathrm {\min } &{} \displaystyle \sum _{j=1}^{n}\frac{1}{w(j)}x\left( j\right) ^{2} &{} \\ \mathrm {s.t.} &{} \displaystyle u\left( N^{\left( z\right) }\right) -\left( d-R^{\left( z\right) }\right) \le x\left( N^{\left( z\right) }\right) , &{} z=1,\ldots ,n; \\ &{} \displaystyle 0\le x(j)\le u(j)-l(j), &{} j\in N. \end{array} \end{aligned}$$

It follows from a general result from [5] and from Sect. 9.2 of [6] on the equivalence of quadratic and lexicographic optimization with submodular constraints that any optimal solution to the problem above is also an optimal solution to problem (14). The former problem can be classified as the resource allocation problem with a separable quadratic function under nested constraints. Such a problem can be solved in $O\left( n\log n\right)$ time, as proved in [12]. A disadvantage of using this approach is that it does not deliver a solution in a closed form.

Notice that the running time established in Theorem 1 is faster than $O\left( n^{2}\right)$, the best known time for a more general problem with distinct release dates, see Table 1. On the other hand, it matches the running time for solving the feasibility problem 1|r(j), $C(j)\le d$, $pmtn|-$ with constant processing times; see Table 2.

4 Identical parallel machines: zero release dates

In this section, we address problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, in which all jobs must be scheduled on m identical parallel machines in the time interval $\left[ 0,d\right]$. Therefore, in any feasible schedule the sum of actual processing times of all jobs $p\left( N\right)$ must not exceed md. Additionally, for each job j its actual processing time $p\left( j\right)$ may not exceed the deadline d.

As in Sect. 3, for problem $P|p(j)=u(j)-x(j)$, $C(j)\le d,$$pmtn|\Phi _{\max }$ the generic formulation based on the compression variables $x\left( j\right)$, $j\in N$, can be written as

$$\begin{aligned}{}\begin{array}[t]{ll} \mathrm {\min } &{} \displaystyle \max \left\{ \frac{x\left( j\right) }{w\left( j\right) }|j\in N\right\} \\ \mathrm {s.t.} &{} \displaystyle u\left( N\right) -md\le x\left( N\right) , \\ &{} \begin{array}[t]{l} \displaystyle 0\le x(j)\le u(j)-l\left( j\right) ,j\in N, \\ \displaystyle u(j)-x(j)\le d,j\in N, \end{array} \end{array} \end{aligned}$$

(18)

see [9, 13, 27]. We may assume that the last inequality holds with $x(j)=u(j)-l(j)$, i.e., $l(j)\le d$, $j\in N$.

Let the values $\lambda _{j}$, $j\in N$, be found and the jobs be numbered in accordance with (12). Changing variables to $\lambda \left( j\right) ={x\left( j\right) }/{w\left( j\right) }$, $j\in N$, the problem can be reformulated as

$$\begin{aligned}{}\begin{array}[t]{ll} \mathrm {\min } &{} \displaystyle \max \left\{ \lambda \left( j\right) |j\in N\right\} \\ \mathrm {s.t.} &{} \displaystyle u\left( N\right) -md\le \sum _{j\in N}\lambda \left( j\right) w\left( j\right) , \\ &{} \begin{array}[t]{l} \displaystyle 0\le \lambda (j)\le \lambda _{j},j\in N, \\ \displaystyle u\left( j\right) -\lambda (j)w\left( j\right) \le d,j\in N. \end{array} \end{array} \end{aligned}$$

(19)

Similarly to Sect. 3, for problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ a value of $\lambda \in \left[ \lambda _{q},\lambda _{q+1}\right]$, $1\le q\le n-1$, is feasible if

$$\begin{aligned} u\left( N\right) -md\le & {} \sum _{j=1}^{q}\lambda _{j}w\left( j\right) +\lambda \sum _{j=q+1}^{n}w\left( j\right) ; \nonumber \\ \frac{u\left( j\right) -d}{w\left( j\right) }\le & {} \lambda ,~j=q+1,\ldots ,n, \end{aligned}$$

(20)

where the second line guarantees that each job j, $q+1\le j\le n$, in the case of compression by $x\left( j\right) =\lambda w\left( j\right)$ will get the processing time at most d (jobs 1, ..., q are fully compressed).

Suppose that an interval $\left[ \lambda _{q},\lambda _{q+1}\right]$ is found such that $\lambda _{q}$ is infeasible while $\lambda _{q+1}$ is feasible. All jobs $j\le q$ are fully compressed and no other job, except for job $q+1$, may become fully compressed as long as $\lambda$ changes within $\left[ \lambda _{q},\lambda _{q+1}\right]$. An optimal value $\lambda ^{*}$ is the smallest feasible value of $\lambda \in \left[ \lambda _{q},\lambda _{q+1}\right]$, which can be found by

$$\begin{aligned} \lambda ^{*}=\max \left\{ \frac{u\left( N\right) -md-\sum _{j=1}^{q}\lambda _{j}w\left( j\right) }{\sum _{j=q+1}^{n}w\left( j\right) },\left. \max _{q+1\le j\le n}\left\{ \frac{u\left( j\right) -d}{ w\left( j\right) }\right\} \right\} \right. . \end{aligned}$$

(21)

Formula (21) is written under the assumption that the jobs are renumbered in such a way that the order of $\lambda _{j}$’s is given by (12). Under this assumption, the search for an interval $\left[ \lambda _{q},\lambda _{q+1}\right]$ can be performed in $O\left( n\log n\right)$ time, by a straightforward adaptation of Algorithm A1.

However, as shown below, for problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ it is possible to perform the localization search in Step 4 of Procedure A in linear time without ordering the values $\lambda _{j}$, $1\le j\le n$, by (12) but rather keeping them in an unsorted list $\Lambda$. The corresponding algorithm is outlined below. Its running time reduces to $O\left( n\right)$.

The algorithm follows Procedure A and employs a search mechanism based on the median finding technique. This mechanism allows us splitting the set N of jobs into two subsets $N^{\prime }$ and $N^{\prime \prime }$ such that there exists an optimal schedule in which each job $j\in N^{\prime }$ is fully compressed, while the weighted compression cost for each job of set $N^{\prime \prime }$ is equal to the optimum value $\lambda ^{*}$. During the course of the algorithm, we keep track of set H of the candidate jobs which are not yet assigned either to $N^{\prime }$ or to $N^{\prime \prime }$. In each iteration for a $\lambda$ equal to the median of the current list $\Lambda$ set H is split into two subsets $H^{\prime }$ and $H^{\prime \prime }$ which are used for updating either set $N^{\prime }$ or set $N^{\prime \prime }$. To speed up the algorithm, we keep records of the total compression $V^{\prime }$ of the current jobs in $N^{\prime }$ and total weight $W^{\prime \prime }$ of the current jobs in $N^{\prime \prime }$.

Algorithm AP0

• Step 1. Compute $\lambda _{j}$, $j\in N$, by (7). If necessary, renumber the jobs so that (8) holds and form an unsorted list $\Lambda$.

• Step 2. Check if $\lambda _{0}=0$ is feasible. If yes, then the optimal compressions are $x^{*}\left( j\right) =0,~1\le j\le n$, with the optimal value of the objective function $\Phi _{\max }$ equal to zero; otherwise, go to Step 3.

• Step 3. Check if $\lambda =\lambda _{n}$ is feasible. If not, then the original problem does not have a feasible solution; otherwise define $N^{\prime }:=N^{\prime \prime }:=\varnothing$, $H:=N$, $V^{\prime }:=W^{\prime \prime }:=0$ and go to Step 4.

• Step 4. Repeat until list $\Lambda$ is empty:

  • (a) Find $\hat{\lambda }$, the median of the list $\Lambda$, and set

    $$\begin{aligned} H^{\prime }:=\left\{ j\in H \mid \lambda _{j} \le \hat{\lambda }\right\} . \end{aligned}$$

  • (b) Check the inequalities

    $$\begin{aligned} u\left( N\right) -\bigg (V^{\prime } + \sum _{j \in H^{\prime }}\lambda _j w(j) \bigg ) -\hat{\lambda } \bigg (W^{\prime \prime } +\sum _{j \in H {\setminus } H^{\prime }} w(j) \bigg )\le & {} md, \\ u\left( j\right) - \lambda _j w\left( j\right)\le & {} d,\qquad j\in H^{\prime }, \\ u\left( j\right) - \hat{\lambda } w\left( j\right)\le & {} d,\qquad j\in H {\setminus } H^{\prime }. \end{aligned}$$

  • (c) If the above inequalities do not hold simultaneously (i.e., $\hat{ \lambda }$ is infeasible), then update

    $$\begin{aligned} V^{\prime }:=V^{\prime }+\sum _{j\in H^{\prime }}\lambda _j w(j), \quad N^{\prime }:=N^{\prime }\cup H^{\prime }, \quad H:=H\backslash H^{\prime }, \end{aligned}$$

    and remove $\lambda _{j}$ with $j\in {H}^{\prime }$ from the list $\Lambda$.

    Otherwise (i.e., $\hat{\lambda }$ is feasible), find ${H}^{\prime \prime }=\left\{ j\in H\ |\ \lambda _{j}\ge \hat{\lambda }\right\}$ and update

    $$\begin{aligned} W^{\prime \prime }:= W^{\prime \prime }+ \sum _{j\in {H}^{\prime \prime }}w\left( j\right) ,\quad N^{\prime \prime }:=N^{\prime \prime }\cup {H} ^{\prime \prime }, \quad H:=H\backslash H^{\prime \prime }, \end{aligned}$$

    and remove $\lambda _{j}$ with $j\in {H}^{\prime \prime }$ from the list $\Lambda$.

• Step 5. An optimal maximum compression cost $\lambda ^{*}$ is found by

  $$\begin{aligned} \lambda ^{*}=\max \left\{ \frac{u\left( N\right) -md-V^{\prime }}{ W^{\prime \prime }},\left. \max _{j\in N^{\prime \prime }}\left\{ \frac{ u\left( j\right) -d}{w\left( j\right) }\right\} \right\} \right. . \end{aligned}$$

  (22)

In each iteration of Step 4, let h be the number of elements in the current list $\Lambda$ (or, equivalently, in set H). Then the feasibility check and the transition to the next iteration require $O\left( h\right)$ time. After each iteration, the number of jobs in the list $\Lambda$ is halved. Thus, the total time needed for finding the required interval is

$$\begin{aligned} O\left( n\right) +O\left( \frac{n}{2}\right) +O\left( \frac{n}{4}\right) +\cdots =O\left( n\right) \text {.} \end{aligned}$$

Formula (22) is an adaptation of (21), so that in terms of Step 5 of Procedure A the last found infeasible $\lambda$ will play the role of $\lambda _{q}$, while $\lambda _{q+1}$ is the smallest element of the initial list $\Lambda$ that is larger than $\lambda$. Finding the optimal value of $\lambda ^{*}$ in Step 5 takes $O\left( n\right)$ time.

Thus, the following statement holds.

Theorem 2

Problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is solvable in $O\left( n\right)$ time.

Similarly to Sect. 3, consider the problem of minimizing the function $\sum _{j\in N}(1/w\left( j\right) )x\left( j\right) ^{2}$ under the same constraints as in (18). Such a problem of quadratic programming is qualified as the simple resource allocation problem and can be solved in $O\left( n\right)$ time [12]. Since any optimal solution of that resource allocation problem is also an optimal solution to problem (18), we obtain an alternative linear time algorithm for problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$.

Notice that the established running time matches the running time needed for solving the feasibility problem $P|C(j)\le d$, $pmtn|-$ with constant processing times, as well as that needed for solving problem $P|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$ to minimize total compression cost; see Table 2.

5 Identical parallel machines: arbitrary release dates

The difference between problems P|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ and 1|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is that now we have m identical parallel machines. We can adapt and extend Algorithm A1 to handle the parallel machine problem.

Similarly to Sect. 3, given problem P|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, let $R^{\left( z\right) }$ denote the zth smallest release date, $1\le z\le n.$

Perform Steps 1–4 of Algorithm A1, where the feasibility check is done by running an algorithm by Sahni [22], which in $O\left( n\log n\right)$ time verifies feasibility of problem P|r(j), $C(j)\le d,pmtn|-$ with fixed processing times. Since there are $\log n$ iterations in Step 4 of Algorithm A1, we arrive at Step 5 in $O\left( n\log ^{2}n\right)$ time, having found an interval $\left[ \lambda _{q},\lambda _{q+1}\right]$ such that $\lambda _{q}$ is infeasible while $\lambda _{q+1}$ is feasible, $0\le q\le n-1$. Notice that unlike Algorithm AP0, for the problem with arbitrary release dates Step 4 cannot be implemented in linear time by the median-finding technique. Indeed, even if the processing times of some jobs are fixed checking the feasibility of a given $\lambda _{q}$ requires time that is no less than linear in n.

We now explain how the optimal value of $\lambda ^{*}$ can be found in Step 5 and how such a search can be implemented in $O\left( n^{2}\right)$ time. Notice that even if a speed-up in Step 4 was possible it would not affect the overall running time of the algorithm.

To implement the search in Step 5 we cannot rely just on the feasibility check algorithm by Sahni [22]. We rather need to base our search on relevant analytical expressions. Recall that the necessary and sufficient conditions for the existence of a schedule that is feasible for problem P|r(j), $C(j)\le d$, $pmtn|-$ with fixed processing times $p\left( j\right)$, $j\in N$, are obtained by Horn [13]. For each job $j\in N$ and each z, $1\le z\le n$, Horn [13] determines the value $g^{\left( z\right) }\left( j\right)$, which represents the minimum duration of the processing of job j after time $R^{\left( z\right) }$ in any feasible schedule. Such values can be found by

$$\begin{aligned} g^{\left( z\right) }\left( j\right) =\left\{ \begin{array}{ll} p\left( j\right) , &{} \mathrm {if~}r\left( j\right) \ge R^{\left( z\right) },\\ \max \left\{ p\left( j\right) -\left( R^{\left( z\right) }-r\left( j\right) \right) ,0\right\} , &{} \mathrm {otherwise.} \end{array} \right. \end{aligned}$$

It is proved in Theorem 2 of [13] that for problem P|r(j), $C(j)\le d,pmtn|-$ a feasible schedule exists if and only if the inequality

$$\begin{aligned} \sum _{j\in N}g^{\left( z\right) }\left( j\right) \le m\left( d-R^{\left( z\right) }\right) \end{aligned}$$

(23)

holds for all z, $1\le z\le n$, provided that

$$\begin{aligned} p\left( j\right) \le d-r\left( j\right) ,~j\in N. \end{aligned}$$

(24)

For problem P|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, as $\lambda$ changes within the found interval $\left[ \lambda _{q},\lambda _{q+1}\right]$, two types of jobs can be distinguished. First, each job j with $\lambda _{j}\le \lambda _{q}$ is fully compressed, i.e., its actual processing time $p\left( j\right)$ is equal to $l\left( j\right)$ and remains constant. Second, for the remaining jobs $p\left( j\right) =u\left( j\right) -\lambda w\left( j\right)$. Moreover, for each job j with $r\left( j\right) <R^{\left( z\right) }$, the value $g^{\left( z\right) }\left( j\right)$ computed with respect to the actual processing time $p\left( j\right)$ should be treated as a function $g^{\left( z\right) }\left( j,\lambda \right)$ which is piecewise linear in $\lambda$, with a break-point

$$\begin{aligned} \mu ^{\left( z\right) }\left( j\right) =\frac{u\left( j\right) +r\left( j\right) -R^{\left( z\right) }}{w\left( j\right) }. \end{aligned}$$

(25)

Let $\lambda \in \left[ \lambda _{q},\lambda _{q+1}\right]$ be feasible and $\lambda (j)$ be defined by (9). Then it follows from (24) that the inequality

$$\begin{aligned} \lambda (j)w\left( j\right) \ge u\left( j\right) -d+r\left( j\right) \end{aligned}$$

holds for all j, $1\le j\le n$. Additionally, (23) implies that the inequality

$$\begin{aligned} \sum _{j\in N}g^{\left( z\right) }\left( j,\lambda \right) \le m\left( d-R^{\left( z\right) }\right) \end{aligned}$$

(26)

holds for all z, $1\le z\le n$, where

$$\begin{aligned} g^{\left( z\right) }\left( j,\lambda \right) =\left\{ \begin{array}{ll} u\left( j\right) -\lambda (j)w\left( j\right) , &{} \mathrm {if~}r\left( j\right) \ge R^{\left( z\right) }, \\ \max \left\{ u\left( j\right) -\lambda (j)w\left( j\right) -\left( R^{\left( z\right) }-r\left( j\right) \right) ,0\right\} , &{} \mathrm {otherwise.} \end{array} \right. \end{aligned}$$

(27)

Notice that in (27) the values $g^{\left( z\right) }\left( j,\lambda \right)$ depend on $\lambda \left( j\right)$, which means they depend on $\lambda$ implicitly, due to (9).

Below we provide a possible implementation of the search for an optimal $\lambda ^{*}$.

• Step 5.

  • (a) Compute the break-points $\mu ^{\left( z\right) }\left( j\right)$, $1\le z\le n$, $1\le j\le n$, by (25) and remove those which do not belong to the interval $\left[ \lambda _{q},\lambda _{q+1} \right]$. Let M be an unsorted list of the remaining $\mu$-values.

  • (b) Repeat until list M contains two distinct elements:

    Find $\hat{\mu }$, the median of the list M. If $\hat{\mu }$ is infeasible, then remove from list M all elements less than $\hat{\mu }$; otherwise, remove from list M all elements larger than $\hat{\mu }$.

  • (c) Let $\mu ^{\prime }$ and $\mu ^{\prime \prime }$ be the two remaining elements of list M. For $\lambda \in \left[ \mu ^{\prime },\mu ^{\prime \prime }\right]$, compute $\lambda \left( j\right)$ by (9) and $g^{\left( z\right) }\left( j,\lambda \right)$ by (27), $1\le z\le n$, $1\le j\le n$.

  • (d) Find an optimal $\lambda ^{*}$ as the smallest feasible $\lambda \in \left[ \mu ^{\prime },\mu ^{\prime \prime }\right] .$ The optimal compressions $x^{*}\left( j\right)$ are defined by (11).

Let us analyze Step 5 described above. Computation in Step 5(a) requires $O\left( n^{2}\right)$ time. Step 5(b) is the median-based search similar to that employed in Algorithm AP0. The computation related to repeated median-finding in the list initially consisting of $O(n^{2})$ elements takes $O(n^{2})$ time for all iterations. Additionally, feasibility checks are performed for each trial $\mu$-value by running the algorithm by Sahni [22]. Since after each iteration the number of elements in list M is halved, there are $\log \left( n^{2}\right) =O\left( \log n\right)$ iterations in this step to locate an interval $\left[ \mu ^{\prime },\mu ^{\prime \prime }\right] \subset \left[ \lambda _{q},\lambda _{q+1}\right]$ such that the value of $\mu ^{\prime }$ is infeasible, while the value of $\mu ^{\prime \prime }$ is feasible, so that all feasibility checks take $O\left( n\log ^{2}n\right)$ time. The latter estimate defines the overall time complexity of Step 5(b).

As $\lambda$ changes within $\left[ \mu ^{\prime },\mu ^{\prime \prime } \right]$, each $g^{\left( z\right) }\left( j,\lambda \right)$ defined in Step 5(c) does not change its shape, i.e., remains either constant or linear in $\lambda$. All such $g^{\left( z\right) }\left( j,\lambda \right)$, $j\in N$, $1\le z\le n$, can be found in $O\left( n^{2}\right)$ time. For each relevant z, $1\le z\le n$, the sum $\sum _{j\in N}g^{\left( z\right) }\left( j,\lambda \right)$ involved in (26) is linear in $\lambda$ and can be computed in $O\left( n\right)$ time as the sum of linear functions. Thus, an optimal value of $\lambda$ that satisfies the condition (26) can be found in $O\left( n^{2}\right)$ time.

The overall running time of Step 5 is $O\left( n^{2}\right)$ and the following statement holds.

Theorem 3

Problem $P|r\left( j\right) ,p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is solvable in $O\left( n^{2}\right)$ time.

Notice that the established running time exceeds the running time of $O\left( n\log n\right)$ needed for solving the feasibility problem $P|r\left( j\right) ,C(j)\le d$, $pmtn|-$ with constant processing times, as well as the running time of $O\left( n\log n\log m\right)$, the best known time for solving problem $P|r\left( j\right) ,p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$ to minimize total compression cost; see Table 2.

6 Uniform parallel machines: zero release dates

Consider problem $Q|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ in which the jobs have no release dates and the machines are numbered in non-increasing order of their speeds, i.e.,

$$\begin{aligned} s_{1}\ge s_{2}\ge \cdots \ge s_{m}. \end{aligned}$$

(28)

This problem can be solved by adapting the general scheme, in a similar manner as presented in Sect. 5.

Perform actions described in Steps 1–4 of Algorithm A1 (notice no finding of $R^{\left( z\right) }$ and $N^{\left( z\right) }$ is needed since all release dates are the same). The sorted list $\Lambda =\left( \lambda _{0},\lambda _{1},\ldots ,\lambda _{n}\right)$ is searched until an interval $\left[ \lambda _{q},\lambda _{q+1}\right]$ if found, such that $\lambda _{q}$ is infeasible while $\lambda _{q+1}$ is feasible, $0\le q\le n-1$. The feasibility check for a trial value of $\lambda$ is done by running an algorithm by Gonzalez and Sahni [8] which in $O\left( n+m\log m\right)$ time verifies feasibility of problem $Q|C(j)\le d,pmtn|-$ with fixed processing times.

In $O\left( n\log n+m\log m\log n\right)$ time we arrive at Step 5. We only need to explain how the optimal value of $\lambda ^{*}\in \left[ \lambda _{q},\lambda _{q+1}\right]$ is to be found in Step 5. As in Sect. 5, for this stage of the search we need to explore the explicit feasibility conditions for the underlying problem with fixed processing times.

Such conditions for problem $Q|C(j)\le d,pmtn|-$ are well-known. Below, we present them following [2]. All jobs can be completed by time d, provided that

• Any job can be completed by time d if it is processed on the fastest machine $M_{1}$,

• For any v, $2\le v\le m-1$, any subset of v jobs can be completed by d on the v fastest machines $M_{1}$, $M_{2},\ldots ,M_{v};$

• All jobs can be completed by d on all m machines.

For a taken $\lambda \in \left[ \lambda _{q},\lambda _{q+1}\right]$, define the compressions $x\left( j\right)$ by (10) and the actual processing times $p\left( j\right) =u\left( j\right) -x\left( j\right)$. For v, $1\le v\le m-1$, let $N^{\left[ v\right] }\left( \lambda \right)$ be the set of v jobs with the longest processing times. Then $\lambda$ is feasible if

$$\begin{aligned} p\left( N^{\left[ v\right] }\left( \lambda \right) \right)\le & {} d\sum _{i=1}^{v}s_{i},~1\le v\le m-1; \\ p\left( N\right)\le & {} d\sum _{i=1}^{m}s_{i}. \end{aligned}$$

As $\lambda$ changes within $\left[ \lambda _{q},\lambda _{q+1}\right]$, we need to monitor (i) the sets $N^{\left[ v\right] }\left( \lambda \right)$ of v longest jobs, $1\le v\le m-1$, and (ii) the relative order of these jobs. In other words, as $\lambda$ changes we need to keep the information regarding the $m-1$ longest jobs.

Consider a job $j\in N$ such that $\lambda _{j}>\lambda _{q}$, i.e., its compression $x\left( j\right) =\lambda _{q}w\left( j\right)$ is smaller than its largest possible compression $u\left( j\right) -l\left( j\right)$. For another job $k\in N$, also with $\lambda _{k}>\lambda _{q}$, the relative order of the actual processing times of the jobs j and k changes as $\lambda$ passes the point that is the solution of the equation

$$\begin{aligned} u\left( j\right) -\lambda w\left( j\right) =u\left( k\right) -\lambda w\left( k\right) . \end{aligned}$$

On the other hand, a job $k\in N$ such that $\lambda _{k}\le \lambda _{q}$ is fully compressed and its actual time remains equal to $l\left( k\right)$ as $\lambda$ changes. The relative order of the actual processing times of the jobs j and k changes as $\lambda$ passes the point that is the solution of the equation

$$\begin{aligned} u\left( j\right) -\lambda w\left( j\right) =l\left( k\right) . \end{aligned}$$

Below we provide a possible implementation of the search for an optimal $\lambda ^{*}$.

• Step 5.

  • (a) For $j \in N$ with $\lambda _j > \lambda _q$, compute the break-points $\mu _{jk}$, $1\le k\le n$, $k \ne j$, by

    $$\begin{aligned} \mu _{jk}=\left\{ \begin{array}{ll} \frac{u\left( j\right) -u\left( k\right) }{w\left( j\right) -w\left( k\right) } &{} \mathrm {for~}k\in N,k\ne j,\lambda _{k}>\lambda _{q} \\ &{} \\ \frac{u\left( j\right) -l\left( k\right) }{w\left( j\right) } &{} \mathrm {for~} k\in N,\lambda _{k}\le \lambda _{q} \end{array} \right. \end{aligned}$$

    (29)

    and remove those $\mu$-values which do not belong to the interval $\left[ \lambda _{q},\lambda _{q+1}\right]$. Let M be an unsorted list of the remaining $\mu$-values.

  • (b) Repeat until list M contains two distinct elements:

    Find $\hat{\mu }$, the median of the list M. If $\hat{\mu }$ is infeasible, then remove from list M all elements less than $\hat{\mu }$; otherwise, remove from list M all elements larger than $\hat{\mu }$.

  • (c) Let $\mu ^{\prime }$ and $\mu ^{\prime \prime }$ be the two remaining elements of list M. Find an optimal $\lambda ^{*}$ as the smallest feasible $\lambda \in \left[ \mu ^{\prime },\mu ^{\prime \prime } \right]$ by

    $$\begin{aligned} \lambda ^{*}=\max \left\{ \tilde{\lambda },\bar{\lambda }\right\} , \end{aligned}$$

    where

    $$\begin{aligned} \tilde{\lambda }:= & {} \max _{1\le v\le m-1}\left\{ \frac{u\left( N^{\left( v\right) }\left( \tilde{\mu }\right) \right) -d\sum \nolimits _{i=1}^{v}s_{i}-\sum \nolimits _{j\in \left\{ 1,\ldots ,q\right\} \cap N^{[v] }\left( \tilde{\mu }\right) }\lambda _{j}w\left( j\right) }{\sum \nolimits _{j\in \left\{ q+1,\ldots ,n\right\} \cap N^{[ v] }\left( \tilde{\mu }\right) }w\left( j\right) }\right\} ,\\ \bar{\lambda }:= & {} \frac{u\left( N\right) -d\sum \nolimits _{i=1}^{m}s_{i}-\sum \nolimits _{j=1}^{q}\lambda _{j}w\left( j\right) }{\sum \nolimits _{j=q+1}^{n}w\left( j\right) }, \end{aligned}$$

    and $\tilde{\mu }$ is the midpoint of the interval $\left[ \mu ^{\prime },\mu ^{\prime \prime }\right]$. The optimal compressions $x^{*}\left( j\right)$ are defined by (11).

Step 5 described above is similar to Step 5 presented in Sect. 5. Computation in Step 5(a) requires $O\left( n^{2}\right)$ time. Step 5(b) is the median-based search, which requires $O(n^{2})$ time for all iterations. The feasibility check of each trial $\mu$-value is performed by running an algorithm by Gonzalez and Sahni [8]. Since there are $O(\log n)$ iterations, finding an interval $\left[ \mu ^{\prime },\mu ^{\prime \prime }\right] \subset \left[ \lambda _{q},\lambda _{q+1} \right]$ such that the value of $\mu ^{\prime }$ is infeasible, while the value of $\mu ^{\prime \prime }$ is feasible takes $O\left( n^{2}+m\log m\log n\right)$ time.

As $\lambda$ changes within the interval $\left( \mu ^{\prime },\mu ^{\prime \prime }\right]$ the sets $N^{\left[ v\right] }\left( \lambda \right)$ of v longest jobs do not change. In the formula for computing $\lambda ^{*}$ in Step 5(c) any value of $\mu \in \left( \mu ^{\prime },\mu ^{\prime \prime }\right)$ can be used, and for certainty we have selected $\tilde{\mu }$ as the midpoint of the interval $\left[ \mu ^{\prime },\mu ^{\prime \prime }\right]$.

The overall running time of Step 5 is $O\left( n^{2}\right)$. Thus, the following statement holds.

Theorem 4

Problem $Q|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is solvable in $O\left( n^{2}\right)$ time.

The established running time can be reduced by making an observation that not all $O\left( n^{2}\right)$ breakpoints $\mu _{jk}$ computed in Step 5(a) are needed, but only those which affect a relative order of the v longest jobs for $1\le v\le m-1$. Finding these relevant breakpoints can be reduced to the following problem of computational geometry. As observed earlier, after the interval $\left[ \lambda _{q},\lambda _{q+1}\right]$ is located, each job $j\in N$ can belong to one of the following categories: (i) incompressible with the actual processing time of $l\left( j\right)$, and (ii) compressible with the actual time of $u\left( j\right) -\lambda w\left( j\right)$. A job can be associated with a straight line on the plane, with $\lambda$ as the independent variable. The relevant break-points are in fact those intersection points of these straight lines that at most $m-1$ straight lines are located above them. The problem of finding all such intersection points is known as the problem of determining $\left( \le k\right)$-levels for an arrangement of lines; see [1] and [3]. In particular, adapting the algorithm from [3] to our purposes, we can replace Step 5(a) above by finding the $\left( \le m-1\right)$-levels for the n lines associated with the jobs. As a result, we will obtain the list M of the relevant break-points of the form (29) in $O\left( n\log n+nm\right)$ time, the number of these break-points being O(nm). The median-based search in Step 5(b) requires $O\left( nm\right)$ time. Thus, the overall running time that is needed for solving problem $Q|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ reduces to $O\left( n\log n+nm\right)$.

Theorem 5

Problem $Q|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is solvable in $O\left( n\log n+nm\right)$ time, provided that the method of determining $\left( \le k\right)$-levels is employed.

The resulting running time exceeds the running time of $O\left( n+m\log m\right)$ needed for solving the feasibility problem $Q|C(j)\le d$, $pmtn|-$ with constant processing times, as well as the running time of $O\left( \min \left\{ n\log n,n+m\log m\log n\right\} \right)$, the best known time for solving problem $Q|p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$ to minimize total compression cost; see Table 2.

7 Uniform parallel machines: arbitrary release dates

In this section, we consider problem $Q|r(j), p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ in which the jobs have release dates and the machines are numbered according to (28).

Below, we outline a rather universal approach to finding an optimal value $\lambda ^{*}$ of the objective function for a generic problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$. In principle, this approach can be used to solve any of the problems of the range under consideration. However, the SCPT problems from Sects. 3–6 due to their relative simplicity can be handled by faster purpose-built algorithms.

Consider problem $\alpha |r(j)$, $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ formulated by (6) with respect to an appropriate capacity function $\varphi$. Suppose that the actions described in Steps 1–4 of Procedure A have been performed and we have localized an interval $\left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right]$ such that $\lambda ^{\prime }$ is infeasible while $\lambda ^{\prime \prime }$ is a feasible value of $\lambda$. For $\lambda =\lambda ^{\prime }$, let U denote the set of the incompressible jobs j with the actual processing time $l\left( j\right)$. The jobs of set $N\backslash U$ are compressible, and the actual processing time of job $j\in N\backslash U$ is equal to $u\left( j\right) -\lambda w\left( j\right)$.

For the sake of simplicity of the algorithm description, we redefine

$$\begin{aligned} w(j)=0,\quad u(j)=l(j)\quad \text{ for } \text{ each } \text{ incompressible } \text{ job } j\in U, \end{aligned}$$

(30)

so that $u\left( j\right) -\lambda w\left( j\right) =l(j)$ holds for $j \in U$ and $\lambda \in [\lambda ^{\prime }, \lambda ^{\prime \prime }]$. This also implies that $w\left( Y\right) =w( Y {\setminus } U)$ holds for any set $Y\subseteq N$. Therefore, $\lambda \in [\lambda ^{\prime }, \lambda ^{\prime \prime }]$ is feasible if and only if

$$\begin{aligned} \lambda w(Y)-u\left( Y\right) +\varphi \left( Y\right) \ge 0 \qquad \text{ for } \text{ any } Y\subseteq N. \end{aligned}$$

(31)

The value $\lambda ^{*}$ (the optimal value of $\lambda$) can be defined as the minimum feasible value of $\lambda \in \left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right]$ such that

$$\begin{aligned} \lambda ^{*}=\min \left\{ \lambda \in \left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right] \mid \lambda w(Y)-u\left( Y\right) +\varphi \left( Y\right) \ge 0, ~Y\subseteq N \right\} . \end{aligned}$$

In other words, $\lambda ^{*}$ is such a value within the interval $\left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right]$ that

$$\begin{aligned} \lambda ^{*}=\max _{Y\subseteq N} \frac{u(Y) - \varphi (Y)}{w(Y)} . \end{aligned}$$

For a set $Y\subseteq N\backslash U$, introduce a parametric set-function

$$\begin{aligned} f\left( Y,\lambda \right) =\lambda w(Y)-u\left( Y\right) +\varphi \left( Y\right) ,\quad Y\subseteq N,\ \lambda \in [\lambda ^{\prime },\lambda ^{\prime \prime }]. \end{aligned}$$

It follows from (31) that $\lambda \in [\lambda ^{\prime },\lambda ^{\prime \prime }]$ is feasible if and only if for each set $Y\subseteq N$ the inequality $f\left( Y,\lambda \right) \ge 0$ holds. Therefore, we need to find the smallest value $\lambda ^{*}\in \left[ \lambda ^{\prime },\lambda ^{\prime \prime }\right]$ such that

$$\begin{aligned} \min _{Y\subseteq N}f\left( Y,\lambda ^{*}\right) =0. \end{aligned}$$

The required $\lambda ^{*}$ can be found by a Newton-like search procedure, similar to that presented in [7].

Procedure Newton

• Step 1. Take $\lambda ^{\left( 1\right) }=\lambda ^{\prime }.$ Find set U of incompressible jobs, and redefine w(j) and u(j) for $j \in U$ by (30). Set $k=1$.

• Step 2. Find the minimal (with respect to inclusion) set-minimizer $Y^{\left( k\right) }$ such that

  $$\begin{aligned} f( Y^{(k) },\lambda ^{\left( k\right) }) = \min \left\{ \lambda ^{(k)}w\left( Y \right) -u(Y)+\varphi \left( Y \right) \mid Y\subseteq N\right\} . \end{aligned}$$

• Step 3. If $f\left( Y^{\left( k\right) },\lambda ^{\left( k\right) }\right) =0$ then output $\lambda ^{*}=\lambda ^{\left( k\right) }$ and stop. Otherwise, find

  $$\begin{aligned} \lambda ^{\left( k+1\right) }= \frac{u(Y^{(k)}) - \varphi (Y^{(k)})}{ w(Y^{(k)})} \end{aligned}$$

  such that $f\left( Y^{\left( k\right) },\lambda ^{\left( k+1\right) }\right) =0$. Set $k:=k+1$ and go back to Step 2.

Due to the minimality of the set-minimizers in Step 2, we have that $N\supseteq Y^{\left( k\right) }\supset Y^{\left( k+1\right) }$ for each $k\ge 1$, so that the procedure consists of at most n iterations. Since the capacity function $\varphi \left( Y\right)$ is submodular for all problems of the range under consideration, the search for a set-minimizer $Y^{\left( k\right) }$ in Step 2 reduces to minimizing a submodular function, which in general can be done in polynomial time, see [14, 24].

We now describe how to implement this approach for solving problem Q|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$, the most general problem from the range under consideration of the SCPT problems with a common deadline.

Run Steps 1–4 of Procedure A, or rather of Algorithm A1, where the feasibility check is done by running an algorithm by Sahni and Cho [23] which in $O\left( nm+n\log n\right)$ time verifies feasibility of problem Q|r(j), $C(j)\le d,pmtn|-$ with fixed processing times.

In $O\left( nm\log n+n\log ^{2}n\right)$ time we arrive at Step 5, having found an interval $\left[ \lambda _{q},\lambda _{q+1}\right]$ such that $\lambda _{q}$ is infeasible while $\lambda _{q+1}$ is feasible, $0\le q\le n-1$. We only need to explain how the optimal value of $\lambda ^{*}$ is to be found in Step 5, where we use Procedure Newton.

As in Sects. 3 and 5, let $R^{\left( z\right) }$ denote the zth smallest release date. Extending this notation, for a set $Y\subseteq N$ define $R^{\left( z\right) }\left( Y\right)$ as the z th smallest release date among the jobs of set Y. For a set $Y\subseteq N$, denote $m_{Y}=\min \left\{ m,|Y|\right\}$.

Let the machines be numbered by (28). As follows from [28, 29], the capacity set-function that defines the largest capacity for preemptive processing a set Y of jobs on m uniform parallel machines can be written as

$$\begin{aligned} \varphi \left( Y\right) =\sum _{z=1}^{m_{Y}}s_{z}\left( d-R^{(z)}\left( Y\right) \right) . \end{aligned}$$

Let U be the set of incompressible jobs found with respect to $\lambda =\lambda _{q}$. In Step 2 of an iteration k in Procedure Newton, we need to minimize $\lambda ^{(k)}w\left( Y \right) -u(Y)+\varphi \left( Y \right)$ . Let each job $j\in N$ be associated with a real number

$$\begin{aligned} \gamma \left( j\right) =\lambda ^{\left( k\right) }w\left( j\right) -u(j). \end{aligned}$$

For a set $Y\subseteq N$, define a set-function $\psi ( Y) = \gamma \left( Y \right) +\varphi \left( Y\right)$, which is submodular, since function $\varphi$ is submodular. It is shown in [29] that a set-minimizer $Y^*$ of the function $\psi$ can be found in $O\left( nm\right)$ time, provided that the jobs are numbered in the non-decreasing order of their release dates. In order to guarantee minimality of the minimizer $Y^{*}$, instead of minimizing $\psi \left( Y\right)$ we minimize a function $\psi ^{\varepsilon }\left( Y\right) :=\psi \left( Y\right) +\varepsilon |Y|$ for an arbitrary small positive $\varepsilon$. A set-minimizer for function $\psi ^{\varepsilon }\left( Y\right)$ is a minimal set-minimizer for function $\psi \left( Y\right)$. Such a modification does not affect the time needed for finding the set-minimizer. Time needed to find $\lambda ^{*}$ in Step 5 by employing Procedure Newton is $O\left( mn^{2}\right)$, and this determines the overall running time for solving problem Q|r(j), $p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$.

Thus, the following statement holds.

Theorem 6

Problem $Q|r\left( j\right) ,p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\max }$ is solvable in $O\left( mn^{2}\right)$ time.

Notice that the established running time exceeds the running time needed for solving the feasibility problem $Q|r\left( j\right) ,C(j)\le d$, $pmtn|-$ with constant processing times, as well as that needed for solving problem $Q|r\left( j\right) ,p(j)=u(j)-x(j)$, $C(j)\le d$, $pmtn|\Phi _{\Sigma }$ to minimize the total compression cost; see Table 2. On the other hand, $O\left( mn^{2}\right)$ is less than the time needed for solving problem $Q|r\left( j\right) ,p(j)=u(j)-x(j)$, $C(j)\le d\left( j\right)$, $pmtn|\Phi _{\max }$ with arbitrary due dates; see Table 1.

8 Conclusions

In this paper we address a range of open problems arising in SCPT. The traditional stream of research on SCPT focuses on the $\Phi _{\Sigma }$ objectives. The research on the SIC models does consider $\Phi _{\max }$ but in the most general setting, when all jobs have arbitrary release dates and arbitrary deadlines. The subject of our study are the models with $\Phi _{\max }$ under an assumption that all jobs have a common deadline.

The general methodology we propose stems from the special representation of the solution region as a submodular polyhedron intersected with a box. It can be efficiently implemented for all versions of the problem under study, generically denoted by $\alpha |r\left( j\right) ,p(j)=u(j)-x(j), C(j)\le d$, $pmtn|\Phi _{\max }$ for $\alpha \in \{1,P,Q\}$ (the models with a single machine, identical parallel machines and uniform machines).

For the two models, one with $\alpha =1$ and arbitrary $r_{j}$ and another with $\alpha =P$ and $r_{j}=0$ for all jobs, our approach results in the fastest possible algorithms, with the same running times as the algorithms for the counterparts with fixed processing times, see the first two lines of Table 2. For the remaining three models the complexity gap is reduced, in comparison with the results from [10, 18], but not closed. A similar phenomenon is observed for the problems of minimizing the the $\Phi _{\Sigma }$ objective. It remains to be seen whether further reduction of the complexity gap is possible. In particular, it is a challenging goal to verify whether any of the problems $P|r\left( j\right) ,p(j)=u(j)-x(j), C(j)\le d$, $pmtn|\Phi _{\max }$ and $P|r\left( j\right) ,p(j)=u(j)-x(j), C(j)\le d$, $pmtn|\Phi _{\Sigma }$ admits an $O\left( n\log n\right)$-time algorithm.