Journal of the Operational Research Society

, Volume 62, Issue 1, pp 238–241

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

Authors

    • The Hebrew University
  • A Sarig
    • The Hebrew University
Technical Note

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(n4)) 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, Cj denotes the completion time of job j, Ej=max {dCj,0} denotes the earliness of job j, and Tj=max {Cjd,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: ∑(αjEj+βjTj). 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(n3)solution procedure for the single machine case, consisting of solving an asymmetric assignment problem, where n job processing times are matched with 2n−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(n3).

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 d1 and d2 denote the starting time and the finishing time of the due-window, respectively, and D=d2d1 denotes its size. As above, for a given schedule, Cj denotes the completion time of job j, Ej=max {d1Cj,0}, and Tj=max {Cjd2,0} denote, respectively, the earliness and tardiness of job j, j=1,…,n. Also, for a given schedule, ni 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: ∑αjEj+∑βjTj+δ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(n3). Since this procedure should be repeated for all possible D values, the total complexity of our solution procedure becomes O(n4).

An O(n4) 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 d1 and d2 coincide with a job completion time. (This property can be proved by the standard technique of small perturbations of d1 and d2 to both sides.) It follows that an optimal schedule exists in which both d1 and d2 (⩾d1)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 d1 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, |nlnk|⩽1, l,k=1,…,m, lk. (The proof is based on reducing the total cost by moving a job from machine k to machine l if nknl+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 2m(⌈n/m⌉−D)+mD=2mn/m⌉−mDpotential positions, and our assignment cost matrix is of size n × (2mn/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⌉−Dr). 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, 2m 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.

The following cost function (denotes by Cjr) considers all the above facts, and reflects the cost of assigning job j to all possible r positions:
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Equ1_HTML.gif
Let Xjr be a binary variable, equals 1 if job j is assigned to potential position r, and 0 otherwise, j=1,…,n, and r=1,…,2mn/m⌉−mD. Given the above definitions of the costs and the variables, the resulting assignment problem is the following:
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Equ2_HTML.gif
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Equ3_HTML.gif
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Equ4_HTML.gif
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Equ5_HTML.gif
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Equ6_HTML.gif
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 inO(n4) time.

Proof

  • As shown above, for a given D value, the problem is reduced to an assignment problem of size n × (2mn/m⌉−mD). The number of potential positions is 2mn/m⌉−mD, which is O(n). Hence the effort required for solving the problem (using the Hungarian method) is O(n3). This procedure should be repeated for all possible D values: D=0,1,…,⌈n/m⌉. Thus, the total complexity is O(n4). □

A numerical example

We demonstrate the solution procedure for the case of parallel identical machines on the following 2-machine 11-job problem: illustration The cost of the due window size is δ=7. The ‘long’ machine processes ⌈11/2⌉=6 jobs and the ‘short’ machine processes five jobs. Thus, there are 2mn/m⌉−mD=24−2D 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.
https://static-content.springer.com/image/art%3A10.1057%2Fjors.2009.179/MediaObjects/41274_2011_Article_BFjors2009179_Figa_HTML.jpg

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(n4) 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(n3). 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(n3logn).] 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.

Copyright information

© Operational Research Society 2011