# A note: a due-window assignment problem on parallel identical machines

## Authors

- First Online:

- Received:
- Accepted:

DOI: 10.1057/jors.2009.179

- Cite this article as:
- Mosheiov, G. & Sarig, A. J Oper Res Soc (2011) 62: 238. doi:10.1057/jors.2009.179

- 2 Views

## Abstract

We solve a due-window assignment problem on parallel identical machines. In addition to the standard objective of finding the optimal job schedule, in due-window assignment problems one has to assign a time interval during which goods are delivered to customers with no cost. Jobs scheduled prior to or after the due-window are penalized according to their earliness/tardiness value. We assume that jobs have identical processing times, but may have job-dependent earliness and tardiness costs (eg, due to possible different destinations). We show that the problem can be reduced to a non-standard asymmetric assignment problem, and introduce an efficient (*O*(*n*^{4})) solution procedure.

### Keywords

schedulingparallel machinesearliness–tardinessdue-windowassignment problem## Introduction

‘Due-Window Assignment’ is a topic referring to problems dealing with assigning a time interval during which goods are permitted to be delivered to customers with no cost. Goods delivered prior to or after this interval are penalized according to their earliness/tardiness value. The due-window is usually determined by the supplier during sales negotiations, considering the fact that a wide window makes him less competitive in the relevant market. This very practical topic became popular among scheduling researchers in recent years. A (partial) list of relevant references contains Weng and Ventura (1996), Liman et al (1996, 1998), Mosheiov and Oron (2004), Janiak and Winczaszek (2004, 2006) and Janiak et al (2007).

We begin by describing a classical *due-date* assignment problem, known in the literature (see Gordon et al, 2002) as Total Weighted Earliness Tardiness (TWET). There are *n* jobs, available at time zero, to be processed on a single machine. The common due-date, which is a decision variable is denoted by *d*. For a given schedule, *C*_{j} denotes the completion time of job *j*, *E*_{j}=max {*d*−*C*_{j},0} denotes the earliness of job *j*, and *T*_{j}=max {*C*_{j}−*d*,0} denotes the tardiness of job *j*, *j*=1,…,*n*. For job *j*, *α*_{j} and *β*_{j} denote the earliness unit cost and the tardiness unit cost, respectively. The objective function is minimum total weighted earliness/tardiness: ∑(*α*_{j}*E*_{j}+*β*_{j}*T*_{j}). TWET is known to be NP-hard even in the symmetric case (ie *α*_{j}=*β*_{j}, *j*=1,…,*n*), see Hall and Posner (1991).

Mosheiov and Yovel (2006) studied an important special case of TWET, in which the job processing times are assumed to be identical. They introduced an efficient *O*(*n*^{3})solution procedure for the single machine case, consisting of solving an asymmetric assignment problem, where *n* job processing times are matched with 2*n*−1 possible lateness values. They also showed that this idea can be extended with no complexity increase to the case of parallel identical machines.

Janiak and Winczaszek (2004) focused on a different extension of TWET that allows a due-window. Specifically they considered a single machine with job-dependent earliness and tardiness costs and additional cost factor reflecting the due-window size. The special case of identical processing time jobs was shown by Janiak and Winczaszek to be solved in *O*(*n*^{3}).

In this note, of we extend the above version of TWET with unit jobs and a due- window on a set *parallel identical machines*. We assume that all the jobs share a common due-window whose location (starting time and size) needs to be determined. Let *d*_{1} and *d*_{2} denote the starting time and the finishing time of the due-window, respectively, and *D*=*d*_{2}−*d*_{1} denotes its size. As above, for a given schedule, *C*_{j} denotes the completion time of job *j*, *E*_{j}=max {*d*_{1}−*C*_{j},0}, and *T*_{j}=max {*C*_{j}−*d*_{2},0} denote, respectively, the earliness and tardiness of job *j*, *j*=1,…,*n*. Also, for a given schedule, *n*_{i} denotes the number of jobs assigned to machine *i*, *i*=1,…,*m*. Let *δ* denote the due-window cost (ie the cost of increasing the due-window by one unit of time). The input for the problem contains *m* machines, *n* jobs of identical processing times (for convenience we assume unit processing time jobs; this assumption is without loss of generality as we do not require integrality of the other input parameters), *n* earliness unit costs *α*_{j}, *n* tardiness unit costs *β*_{j}, and the due-window cost *δ*. The goal is to schedule the jobs and to assign the due-window, such that the following objective function is minimized: ∑*α*_{j}*E*_{j}+∑*β*_{j}*T*_{j}+*δ**D*. We show that for a given *D* value, this problem can be reduced to a non-standard asymmetric assignment problem, which is known to be solved in *O*(*n*^{3}). Since this procedure should be repeated for all possible *D* values, the total complexity of our solution procedure becomes *O*(*n*^{4}).

## An *O*(*n*^{4}) solution

We start by mentioning several known properties of the optimal schedule in the *single machine* case. A trivial property is that an optimal schedule exists with no idle time between consecutive jobs (however, an optimal schedule may include an idle time prior to the starting time of the first job since there is no explicit cost on delaying the due-window starting time). Another property is that an optimal schedule exists such that both *d*_{1} and *d*_{2} coincide with a job completion time. (This property can be proved by the standard technique of small perturbations of *d*_{1} and *d*_{2} to both sides.) It follows that an optimal schedule exists in which both *d*_{1} and *d*_{2} (⩾*d*_{1})can get any integer value between 1 and *n*. [The latter property is true due to the fact that an optimal schedule exists that start at time zero. Note that the smallest possible value of *d*_{1} is 1 and not 0 due to the fact, again, that there is no explicit cost on the due-window starting time.] It is also easily verified (by pairwise interchange arguments) that an optimal schedule exists which is ‘V-shaped’, that is, the early jobs are scheduled in a non-increasing order of 1/*α*_{j}, and the tardy jobs are scheduled in a non-decreasing order of 1/*β*_{j}.

These properties are still valid in an optimal solution for the case of parallel identical machines: an optimal schedule exists with no idle time between consecutive jobs on each machine, and jobs are sequenced in a V-shape on each machine. It is also easily verified that an optimal schedule exists in which the load on the machines is ‘as balanced as possible’, that is, |*n*_{l}−*n*_{k}|⩽1, *l*,*k*=1,…,*m*, *l*≠*k*. (The proof is based on reducing the total cost by moving a job from machine *k* to machine *l* if *n*_{k}⩾*n*_{l}+2. However, a formal proof is omitted due to its similarity to a proof in Mosheiov and Yovel (2006).) Thus, some of the machines process ⌊*n*/*m*⌋ jobs, whereas the others process ⌈*n*/*m*⌉ jobs. (In the case that *n* is an exact multiple of *m*, clearly an optimal schedule consists with equal job allocation, and each machine processes *n*/*m* jobs.) Following Mosheiov and Oron (2004), we claim that an optimal schedule exists, such that (i) the starting of the first job on each ‘long machine’ (processing ⌈*n*/*m*⌉ jobs) is zero, (ii) the starting of the first job on each ‘short machine’ (processing ⌊*n*/*m*⌋ jobs) is either zero or one, and (iii) the due-window starting time and the due-window completion time coincide with job completion times on all the machines. (The proofs are based on a standard perturbation technique, and are avoided due to their similarity to the proofs in Mosheiov and Oron (2004).)

Based on these properties, we introduce in the following, a reduction of the problem to an assignment problem. We assume first that the window size *D* is given. Our goal is to assign a given set of (*n*) jobs to a set of potential positions as explained below. Each job can be assigned to each one of the machines, either to be early, or to be scheduled within the due-window, or to be tardy. An upper bound on the number of jobs assigned to a given machine is ⌈*n*/*m*⌉, as shown above. For a given *D* value, an upper bound on the number of early jobs, as well as on the number of tardy jobs is ⌈*n*/*m*⌉−*D*. Thus, we have a set of 2*m*(⌈*n*/*m*⌉−*D*)+*mD*=2*m*⌈*n*/*m*⌉−*mD**potential* positions, and our assignment cost matrix is of size *n* × (2*m*⌈*n*/*m*⌉−*mD*).

If job *j* is assigned to an early (potential) position *r* (*r*=1,…,⌈*n*/*m*⌉−*D*) on machine 1, its cost is given by *α*_{j}(⌈*n*/*m*⌉−*D*−*r*). If it is assigned to a tardy (potential) position *r* (*r*=⌈*n*/*m*⌉+1,…,2⌈*n*/*m*⌉−*D*) on machine 1, its cost is given by *β*_{j}(*r*−⌈*n*/*m*⌉). If job *j* is assigned to position *r* within the due-window, its cost is *δ*. We note, however, that if a job is assigned to a position within the window on one of the machines, it forces this time interval (of one unit) to be part of the window on all other machines. This implies that if a window of size 1 is assumed, *m* jobs are assigned to be within the window (one on each machine), if a window of size 2 is assumed, 2*m* jobs are assigned to be within the window (two on each machine), etc. Thus, in our programme (see below), the cost of a job assigned to be within the window is only *δ*/*m*. It follows that a window of size *D* is penalized by *D**δ*, independently of the number of machines. Finally, we claim that the cost is identical for job *j* in position *r* on any of the machines.

*C*

_{jr}) considers all the above facts, and reflects the cost of assigning job

*j*to all possible

*r*positions: Let

*X*

_{jr}be a binary variable, equals 1 if job

*j*is assigned to potential position

*r*, and 0 otherwise,

*j*=1,…,

*n*, and

*r*=1,…,2

*m*⌈

*n*/

*m*⌉−

*mD*. Given the above definitions of the costs and the variables, the resulting assignment problem is the following: The set of constraints (1) guarantees that each job is assigned. The set of constraints (2) guarantees that each early potential position is occupied by at most one job. The set of constraints (3) guarantees that each position within the window on each machine is occupied by exactly one job. The set of constraints (4) guarantees that each tardy potential position is occupied by at most one job.

### Theorem 1

*The due-window assignment problem with identical jobs and job-dependent asymmetric earliness–tardiness cost on parallel identical machines is solved in**O*(*n*^{4})*time*.

### Proof

As shown above, for a given

*D*value, the problem is reduced to an assignment problem of size*n*× (2*m*⌈*n*/*m*⌉−*mD*). The number of potential positions is 2*m*⌈*n*/*m*⌉−*mD*, which is*O*(*n*). Hence the effort required for solving the problem (using the Hungarian method) is*O*(*n*^{3}). This procedure should be repeated for all possible*D*values:*D*=0,1,…,⌈*n*/*m*⌉. Thus, the total complexity is*O*(*n*^{4}). □

## A numerical example

*δ*=7. The ‘long’ machine processes ⌈11/2⌉=6 jobs and the ‘short’ machine processes five jobs. Thus, there are 2

*m*⌈

*n*/

*m*⌉−

*mD*=24−2

*D*potential positions for a given

*D*value. We solved the problem for all possible

*D*values, and the optimal solution is obtained for

*D*=2. The optimal schedule consists of assigning six jobs to machine 1 and five jobs to machine 2. The job sequence on machine 1 is (7, 10, 5, 6, 4, 1). The job sequence on machine 2 is (8, 9, 11, 2, 3). The starting time on both machines is zero. The due-window starts at time 2 and is completed at time 4. The total optimal cost is 25.5.

## Conclusion

In this note we extended the due-window assignment problem with unit jobs and job-dependent earliness–tardiness weights (an extension of the well-known TWET problem), to a setting of parallel identical machines. We introduced an efficient *O*(*n*^{4}) algorithm.

Future research may focus on a possible reduction of the computational effort required for solving the problem. [A crucial question: is it possible to define potential positions for the due-window as well, and consequently to obtain the optimal solution by solving a single assignment problem rather than a series of assignment problems? If the answer is positive, the total complexity is reduced to *O*(*n*^{3}). Otherwise, is it possible to prove that the total cost function is convex in the window size? If the answer to this question is positive, then a binary search for the optimal window size is sufficient, and the total complexity becomes *O*(*n*^{3}log*n*).] Other interesting topics are (i) an investigation of the same objective on other machine settings, and/or (ii) considering more general (not necessarily linear) cost structures.

## Acknowledgements

The first author is the Charles Rosen Professor of Management, The School of Business Administration, The Hebrew University. The paper was supported in past by the Recanati Fund of the School of Business Administration, The Hebrew University, Jerusalem, Israel.