ri| ∑ Ui scheduling problem - Springer Link

Comput Optim Appl (2012) 51:1253–1274 DOI 10.1007/s10589-010-9378-7

New dominance  rules and exploration strategies for the 1|ri | Ui scheduling problem Gio K. Kao · Edward C. Sewell · Sheldon H. Jacobson · Shane N. Hall

Received: 28 April 2008 / Published online: 2 December 2010 © Springer Science+Business Media, LLC 2010

Abstract The paper proposes a new exact approach, based on a Branch, Bound, and Remember (BB&R) algorithm that uses the Cyclic Best First Search (CBFS) strategy,  for the 1|ri | Ui scheduling problem, a single machine scheduling problem, where the objective is to find a schedule with the minimum number of tardy jobs. The search space is reduced using new and improved dominance properties and tighter upper bounds, based on a new dynamic programming algorithm. Computational results establish the effectiveness of the BB&R algorithm with CBFS for a broad spectrum of problem instances. In particular, this algorithm was able to solve all problems instances, up to 300 jobs, while existing best known algorithms only solve problems instances up to 200 jobs. Furthermore, the BB&R algorithm with CBFS runs one to two orders of magnitude faster than the current best known algorithm on comparable instances. Keywords Branch and bound algorithms · Scheduling theory and algorithms · Dynamic programming G.K. Kao · S.H. Jacobson () Department of Computer Science, University of Illinois at Urbana-Champaign, 201 North Goodwin Ave. (MC-258), Urbana, IL 61801-2302, USA e-mail: [email protected] G.K. Kao e-mail: [email protected] E.C. Sewell Department of Mathematics and Statistics, Southern Illinois University Edwardsville, Edwardsville, IL 62026, USA e-mail: [email protected] S.N. Hall Air Mobility Command, Analyses, Assessments, and Lessons Learned, United States Air Force, 1 Soldier Way, B1900W, Scott AFB, IL 62225-5307, USA e-mail: [email protected]

1254

G.K. Kao et al.

1 Introduction Scheduling problems have attracted widespread interest within the domains of manufacturing, transportation, computer processing, and production planning, as well as computational complexity theory [3, 5, 25]. These problems involve solving for an optimal schedule under various constraints and objectives (e.g., machine environments, job characteristics). For example, single or multiple machines, job shop or flow shop models, and job preemptions are all variants of scheduling problems. Various objectives include minimizing makespan, number of late jobs, and total tardiness; see [3, 5, 10, 14, 23, 27] for reviews of various scheduling problems. The scheduling problem addressed in this paper is the single machine schedul ing problem, denoted as 1|ri | Ui [17]. The problem consists of a set of jobs J = {1, 2, . . . , n} to be scheduled in sequence, where associated with each job is a release time ri , a processing time pi , and a due-date di . The indicator variable Ui = 0(1) if job i is scheduled on time (tardy). A scheduled job i is considered tardy if its completion time ci is greater than its due-date di . Late jobs can be arbitrarily appended to the end of a sequence of on-time jobs. Without loss of generality, assume  that ri + pi ≤ di for all i = 1, 2, . . . , n. The objective of the 1|r | U scheduling i i  problem is to minimize the number of late jobs, min ni=1 Ui , where jobs are scheduled on a single  machine without preemptions. The 1|ri | Ui scheduling problem  is NP-hard [17]. The more general problem, where jobs are weighted, 1|ri | wi Ui , is NP-hard in the strong sense [17]. Polynomial-time special cases of 1|ri | Ui include when the release times are equal or when the jobs are similarly ordered (i.e., ri < rj → di ≤ dj ); these can be solved in O(n log n) time [13, 16, 19].  Exact methods for solving the 1|ri | Ui scheduling problem include B&B algorithms [2, 8, 18], a mixed integer linear program formulation [15], and a combination of constraint propagation and B&B methods [1]. Dauzère-Pérès and Sevaux [7] also propose a Lagrangian relaxation algorithm based on a new mixed integer linear programming formulation. Dauzère-Pérès [6] provides lower bounds based on a relaxation of a mixed integer linear programming formulation as well as the Minimizing Late Job (MLJ) heuristic. Meta-heuristics such as genetic algorithms have also been developed and applied to the problem [28]. M’Hallah and Bulfin [18], Péridy et al. [22], and Sadykov [26] also present results for the weighted version of the scheduling problem. The paper proposes a new exact approach, based on a Branch, Bound, and Remember (BB&R) algorithm that uses the Cyclic Best First Search (CBFS) strategy, for the  1|ri | Ui scheduling problem, a single machine scheduling problem, where the objective is to find a schedule with the minimum number of tardy jobs. The search space is reduced using new and improved dominance properties (as described in Sects. 2 and 3) and tighter upper bounds based on a new dynamic programming algorithm (as described in Sect. 4). A BB&R algorithm using the CBFS exploration strategy [12] is described and compared to the traditional depth-first search (DFS) and best-first search (BFS) exploration strategies. The computational results reported indicate that the BB&R algorithm outperforms the current best known algorithms. The paper is organized as  follows. Section 2 describes three nonmemory-based dominance rules for the 1|ri | Ui scheduling problem: the Early Job Rule (EJR),

New dominance rules and exploration strategies

1255

the Nearly Due Date Order Rule (NDDOR), and the Idle Time Rule (ITR). Section 3 describes a new memory-based dominance rule as well as a proof showing that the dominance rules presented in this paper can be combined to form an exact algorithm. Section 4 provides details of the BB&R algorithm with the CBFS exploration strategy. Computational results are reported in Sect. 5, followed by concluding comments in Sect. 6.

2 Dominance rules This section formally presents three dominance rules, two of which are extensions of dominance rules introduced in Baptiste et al. [2] and Dauzère-Pérès and Sevaux [8], while the third was introduced by several authors (see for example [24]). A brief introduction to dominance rules, as well as the necessary notation are provided. Dominance rules are properties that exploit the structure of optimal solutions, and hence, can be used as pruning strategies. More specifically, these rules identify properties that at least one optimal solution must satisfy. Therefore, these dominance rules can prune many solutions, including optimal ones. However, they will not prune all optimal solutions. Baptiste et al. [1, 2] present several dominance rules that they incorporated into their B&B algorithm. Dauzère-Pérès and Sevaux [7, 8] also suggest a dominance rule incorporated into both their B&B algorithm and their Lagrangian relaxation method for a mixed integer programming formulation. These dominance rules are designed to provide a significant reduction of the search space. To describe these dominance rules, the following notation and assumptions are needed. Jobs are assumed to be sorted by due-date (i.e., i < j → di < dj ∨ (di = dj ∧ ri ≤ rj )). Let σ = (σ1 , σ2 , . . . , σm ) be a sequence of on-time jobs, where σi ∈ J for i = 1, 2, . . . m. • • • • • • • • •

cσ denotes the completion time of the sequence of on-time jobs, cσi denotes the completion time of job σi (define cσ0 = 0), i = 1, 2, . . . , m, sσi = max(cσi−1 , rσi ) denotes the starting time of job σi (define sσm+1 = cσ ), Sσ = {σ1 , σ2 , . . . , σm } denotes the set of jobs that have been scheduled on time, Tσ denotes the set of jobs that must be tardy, given that jobs σ1 , σ2 , . . . , σm have been scheduled on time, Fσ = J \ (Sσ ∪ Tσ ) denotes the set of unscheduled free jobs, Eσ (⊆ Fσ ) denotes the set of free jobs that must be on-time, rˆσ = max{cσ , mini∈Fσ ri } denotes the earliest starting time for the next possible job that can be scheduled, TPσ = m i=1 pσi denotes the sum of the processing times of the scheduled jobs.

Baptiste et al. [2] present a dominance rule that identifies jobs that must be on time; the enhanced version of this dominance rule will be referred to as the Early Job Rule (EJR). The original dominance rule proposed by Baptiste et al. [2] considers only static parameters, such as job processing times, release times and due-dates. A dynamic EJR has been developed which can be applied when constructing the sequence of on-time jobs. It is dynamic in that it involves job starting times and completion times, which are sequence dependent variables. The EJR is now formally defined.

1256

G.K. Kao et al.

Definition 2.1 (Early Job Rule (EJR)) A sequence of on-time jobs σ = (σ1 , σ2 , . . . , σm ) satisfies the Early Job Rule if the following condition holds: For all i ∈ Tσ , there does not exist σj , j = 1, 2, . . . , m such that (pi < pσj ∨ (pi = pσj ∧ i < σj )) ∧ max(cσj −1 , ri ) + pi ≤ min(di , sσj +1 ). Dauzère-Pérès and Sevaux [8] present a dominance rule that is based on the duedates of the jobs; the enhanced version of this dominance rule will be referred to as the Nearly Due Date Order Rule (NDDOR). The NDDOR dominance rule is motivated by the observation that among the on-time jobs, those with earlier due-dates should be scheduled first. The NDDOR is a stronger version of the dominance rule proposed in Dauzère-Pérès and Sevaux [8]. The NDDOR is more restrictive since it considers the starting times of scheduled jobs as opposed to only the release times. Like the EJR, it is dynamic and provides greater pruning. The NDDOR is now formally defined. Definition 2.2 (Nearly Due Date Order Rule (NDDOR)) A sequence of on-time jobs σ = (σ1 , σ2 , . . . , σm ) satisfies the Nearly Due Date Order Rule if the following condition holds: for j = 2, . . . , m (σj −1 < σj ) ∨ (sσj −1 < rσj ). In addition to the EJR and NDDOR, a simple Idle Time Rule (ITR) can further reduce the number of solutions that need to be examined. The ITR is now formally defined. Definition 2.3 (Idle Time Rule (ITR)) A sequence of on-time jobs σ = (σ1 , σ2 , . . . , σm ) satisfies the Idle Time Rule if the following condition holds: For all j = 1, 2, . . . , m − 1, there does not exist k ∈ J \ Sσ such that max(rk , cσj ) + pk ≤ min(dk , sσj +1 ). The ITR eliminates unnecessary idle time from sequences of on-time jobs. The motivation behind this rule suggests that jobs should be scheduled as soon as possible. Idle time places more time constraint on unscheduled jobs, and hence, should be eliminated. All three dominance rules introduced in this section can be used simultaneously to reduce the solution space while not pruning out all optimal solutions. This is formally stated in Theorem 1. The following definitions are needed prior to presenting this result. Definition 2.4 Let z be the number of on-time jobs in an optimal schedule. Let  1 if the machine is idle during (t − 1, t), I (σ, t) = 0 otherwise. Let •  denote the set of all optimal sequences, • 1 = {σ ∈  : T Pσ ≤ T Pδ  ∀δ ∈ }, • 2 = {σ ∈ 1 : i∈Sσ i ≤ i∈Sδ i ∀δ ∈ 1 },

New dominance rules and exploration strategies

1257

n n • 3 = {σ ∈ 2 : dt=1 tI (σ, t) ≥ dt=1 tI (δ, t) ∀δ ∈ 2 },   z z • 4 = {σ ∈ 3 : i=1 iσi ≥ i=1 iδi ∀δ ∈ 3 }. By definition  ⊇ 1 ⊇ 2 ⊇ 3 ⊇ 4 . 1 restricts the set of optimal schedules to those with minimum total processing time. 2 further restricts 1 in such a way that schedules in 2 satisfy the EJR, as will be shown in the proof of Theorem 1. 3 restricts the schedules in 2 to those with maximum total weighted idle time. The weights increase as a linear function of time. Therefore, 3 prefers schedules with idle time near the end over schedules with idle time near the beginning. The proof of Theorem 1 shows that schedules in 3 satisfy the ITR. Finally, 4 is defined in such a way that its schedules satisfy the NDDOR. Theorem 1 If  σ = ( σ1 , σ2 , . . . , σz ) ∈ 4 , then  σ m = ( σ1 , σ2 , . . . , σm ) satisfies the EJR, the NDDOR, and the ITR, for m = 1, 2, . . . , z. Proof Suppose  σ m violates the EJR. Then there exists a tardy job t ∈ T σ m and an on-time job  σj ∈ S σ m such that (pt < p σj )) ∧ (max(c σj ∨ (pt = p σj ∧ t <  σj −1 , rt ) + pt ≤ min(dt , s σj +1 )). This implies that a new sequence  σ = ( σ1 , σ2 , . . . , σj −1 , t, σj +1 , . . . , σz ) of on-time jobs can be created by replacing job  σj with job t. This new sequence has the same number of on-time jobs as  σ , and is therefore optimal. If pt < p σj , then T P σ, σ < T P 4 which contradicts the assumption that  σ ∈  . If  pt ≥ p σj , σj , then pt = p σj ∧ t <  which implies that T P i < i∈Sσ i, which in turn contradicts σ and σ = T P i∈S σ  σ ∈ 4 . Therefore,  σ m must satisfy the EJR. Now suppose  σ m violates the ITR. Then there exists a job k ∈ J \S σ m and j , 1 ≤ j ≤ m − 1, such that max(rk , c ) + p ≤ min(d , s ). This implies that k can σj k k  σj +1 be scheduled between  σj and  σj +1 without changing the starting times of any of the other jobs. If k ∈ / { σm+1 , . . . , σz }, then the sequence ( σ1 , σ2 , . . . , σj , k, σj +1 , . . . , σz ) has z + 1 on-time jobs, which contradicts the optimality of  σ . Therefore, k ∈ { σm+1 , . . . , σz }. Suppose k =  σt for some m + 1 ≤ t ≤ z and let  σ = ( σ1 , σ2 , . . . , σj , k, σj +1 , . . . , σt−1 , σt+1 , . . . , σz ). Then  σ has the same number of on-time jobs as    σ and is therefore optimal. Furthermore, T P i = i, but σ and σ = T P i∈S i∈S σ σ dn dn , t) > 4 . Therefore,  m must sattI ( σ tI ( σ , t), which contradicts  σ ∈  σ t=1 t=1 isfy the ITR. Now suppose  σ m violates the NDDOR. Suppose two consecutive jobs,  σj −1 and  σj , violate the NDDOR (i.e.,  σj −1 >  σj ∧ s σ = ( σ1 , σ2 , . . . , σj −i ≥ r σj ). Let   σj −2 , σj , σj −1 , σj +1 , . . . , σz ) be the schedule obtained by interchanging these two jobs. Then  σj −1 >  σj implies d σj −1 ≥ d σj which then implies that both jobs will be on time. Furthermore, s σj satisfies its release date in  σ . σj −1 ≥ r σj implies that  Therefore, the interchange creates a new optimal schedule.  σ and  σ contain the same set of jobs and the machine is idle during precisely the same moments in time,   n n hence T P i = i∈Sσ i, and dt=1 tI ( σ , t) = dt=1 tI ( σ , t). But σ, σ = T P i∈S σ z z 4 m σi > i=1 i σi , which contradicts  σ ∈  . Therefore,  σ must satisfy the i=1 i NDDOR. 

1258

G.K. Kao et al.

3 Memory-based dominance rule This section describes the General Memory Dominance Rule (GMDR), used in the BB&R algorithm presented in Sect. 4. This type of rule has been previously defined by several authors (see for example [24]). A proof is provided showing that there exists an optimal solution that satisfies all three dominance rules (i.e., GMDR can be used with the EJR, the NDDOR, and the ITR). Similar to the dominance rules described in Sect. 2, memory-based dominance rules (MBDR) are also used to reduce the search space. Unlike the other dominance rules, they do not exploit the structure of optimal solutions, but rather compare partial sequences of on-time jobs and determine whether a particular partial sequence is guaranteed to lead to a solution that is at least as good as other solutions found by the other partial sequences. The GMDR is now formally defined. Definition 3.1 (General Memory Dominance Rule (GMDR)) Let σ = (σ1 , σ2 , . . . , σm ) and δ = (δ1 , δ2 , . . . , δq ) be partial sequences of on-time jobs. Then σ dominates δ if (Fσ ⊇ Fδ ) ∧ (ˆrσ ≤ rˆδ ) and one of the following holds: 1. m > q 2. (m = q) ∧ (T Pσ < T Pδ )   3. (m = q) ∧ (T Pσ = T Pδ ) ∧ ( i∈Sσ i < i∈Sδ i)   n n 4. (m = q)∧(T Pσ = T Pδ )∧( i∈Sσ i = i∈Sδ i)∧( dt=1 tI (σ, t) > dt=1 tI (δ, t))   dn 5. (m = q) ∧ (T Pσ = T Pδ ) ∧ ( i∈Sσ i = i∈Sδ i) ∧ ( t=1 tI (σ, t) = dn m q tI (δ, t)) ∧ ( iσ > iδ ) i=1 i t=1 i=1 i Given the assumptions in the definition of the GMDR, it is clear that if σ contains more on-time jobs than δ (i.e., m > q), then σ dominates δ. The remaining alternatives (2)–(5) correspond to 1 , 2 , 3 , 4 and are used as tie-breaking rules. The GMDR suggests that given two partial sequences of on-time jobs σ and δ, if σ dominates δ, then it is unnecessary to evaluate full sequences of on-time jobs that are constructed by scheduling more jobs onto the end of δ, and that it is sufficient to only evaluate full sequences of on-time jobs that are constructed by scheduling more jobs onto the end of σ . Theorem 2 formally states that the GMDR can be used simultaneously with the EJR, the NDDOR, and the ITR without pruning out all optimal solutions. Theorem 2 If  σ = ( σ1 , σ2 , . . . , σz ) ∈ 4 , then  σ q = ( σ1 , σ2 , . . . , σq ) is not dominated by any other sequence, for q = 1, 2, . . . , z. Proof Suppose σ m = (σ1 , σ2 , . . . , σm ) dominates  σ q = ( σ1 , σ2 , . . . , σq ) for some m q m q such that 1 ≤ q ≤ z. Fσ ⊇ F rσ ≤  r σ and  σ q imply that the sequence ( σq+1 , σq+2 , . . . , σz ) of remaining jobs can be appended to σ m to obtain a new feasible sequence σ = (σ1 , σ2 , . . . , σm , σq+1 , σq+2 , . . . , σz ). The remainder of the proof consists in showing that if any of the five conditions in the GMDR holds true, then it contradicts  σ ∈ 4 .

New dominance rules and exploration strategies

1259

Case 1 m > q. Then σ is a feasible sequence that contains more on-time jobs than  σ, which contradicts the optimality of  σ. Case 2 (m = q) ∧ (T Pσ m < T P σ q ). Then σ is a feasible sequence that contains the same number of on-time jobs as  σ , hence σ is an optimal sequence. This also holds true in all the following cases. T Pσ m < T P σ q implies T Pσ < T P σ ,which contradicts that  σ ∈ 4 .   Case 3 (m = q) ∧ (T Pσ m = T P i). Then T Pσ m = σ q ) ∧ ( i∈Sσ m i <   i∈Sσ q  q T P implies T P = T P . Furthermore, i < i implies i∈Sσ i < σ σ  σ q i∈Sσ m i∈S σ  i, which contradicts that  σ ∈ 4 . i∈S σ   n Case 4 (m = q) ∧ (T Pσ m = T P i) ∧ ( dt=1 tI (σ m , t) > σ q ) ∧ ( i∈Sσ m i = i∈S σq   dn q tI ( σ , t)). Then T Pσ = T P i = i. Furthermore, σ and i∈S σ t=1 dn dn i∈Sσ  dn dn m q σ , t) implies σ , t), which t=1 tI (σ , t) > t=1 tI ( t=1 tI (σ, t) > t=1 tI ( contradicts that  σ ∈ 4 .   n Case 5 (m = q) ∧ (T Pσ m = T P i) ∧ ( dt=1 tI (σ m , t) = σ q ) ∧ ( i∈Sσ m i = i∈S σq     dn q σ q , t)) ∧ ( m i, σ, i∈Sσ i = i∈S i=1 iσi > t=1 tI ( i=1 iδi ). Then T Pσ = T P σ dn dn m q q m and tI (σ, t) = t=1 tI ( σ , t). Furthermore, i=1 iσi > i=1 iδi implies m t=1 q  iσ > iδ , which contradicts that  σ ∈ 4 . i=1 i i=1 i 4 Branch, bound, and remember algorithm  This section introduces the BB&R algorithm for solving the 1|ri | Ui scheduling problem. Section 4.1 describes the bounding scheme, including a dynamic programming algorithm that produces tighter upper bounds compared to other known heuristics. Section 4.2 describes the branching scheme with two different exploration strategies, illustrates how the dominance rules described in Sects. 2 and 3 are used, and provides pseudo-codes for the BB&R algorithm. In addition, Sect. 4.3 describes an extension to the BB&R algorithm that results in enhanced computational speed up. Branch and bound (B&B) algorithms are a common technique for solving large NP-hard combinatorial optimization problems. B&B algorithms implicitly search the entire solution space to find an optimal solution. Various parameters and components of a B&B algorithm must be tailored based on the specific definition of each combinatorial optimization problem. The B&B algorithm presented in this paper incorporates memory-based dominance properties to prune a subproblem if it is dominated by another subproblem that has already been generated. To implement this, it is necessary to store (remember) the subproblems that have already been generated (and hence the name Branch, Bound, and Remember). Memorizing previously visited nodes has been inspired from existing search techniques. For example, in the scheduling domain, Jouglet et al. [11] uses memory to record “no-good recording” and “better sequence” to prune dominated solutions in

1260

G.K. Kao et al.

the solution space. Pèridy et al. [22]  also introduce the use of short term scheduling memory for solving the 1|ri | wi Ui scheduling problem. Dynamic programming techniques [4, 21] share a similar concept. Morin and Marsten [20] combines dynamic programming and B&B strategies to improve computational efficiency of dynamic programming. Tabu Search [9] stores previously visited solutions for guiding the local search process. There are also other similar concepts in the artificial intelligence planning communities. Heuristic searches [30, 31] used to solve large planning problems store previously visited nodes in the search tree to avoid revisiting previously explored paths. 4.1 Bounding scheme This section provides an overview of the algorithms which were used to compute lower and upper bounds on the number of tardy jobs. A dynamic programming algorithm [13] is used to compute a lower bound at every subproblem of the search tree. An extended dynamic programming algorithm based on Kise et al. [13] and the Minimizing Late Job (MLJ) heuristic [6] are used to compute upper bounds at the root of the search tree. Kise et al. [13]  propose a dynamic programming algorithm for solving a special case of the 1|ri | Ui scheduling problem, where the jobs are similarly ordered (i.e., ri < rj → di ≤ dj ). Let Jk be the set of jobs {1, 2, . . . , k}, Mk denote the maximum number of jobs in Jk that can be scheduled on time (for k = 0, . . . , n), and Ckm denote the minimum completion time of a schedule of m on-time jobs from Jk (for k = 0, . . . , n and m = 0, . . . , n). The variables are initialized as M0 = 0  0 if k = m = 0 Ckm = ∞ o.w. Then Mk can be computed via the recurrence relation  Mk−1 + 1 if max(Ck−1,Mk−1 , rk ) + pk ≤ dk Mk = Mk−1 o.w. and Ckm can be computed via the recurrence relation Ckm = min(Ck−1,m , max(Ck−1,m−1 , rk ) + pk ) for m = 1, . . . , Mk . This dynamic programming algorithm is incorporated into the BB&R algorithm to generate lower bounds. Since the instances solved in this paper are generally not similarly ordered, the jobs’ release times and due-dates are relaxed to generate the lower bound. Two separate lower bounds are computed based on either relaxing the release times or relaxing the due-dates (see [8]), where the maximum of the two lower bounds is retained. If the jobs are not similarly ordered, then the dynamic program by Kise et al. [13] produces a schedule that is not guaranteed to be optimal, but which can be used as

New dominance rules and exploration strategies

1261

 an upper bound for the 1|ri | Ui scheduling problem. Let  km be the sequence of on-time jobs corresponding to Ckm . Examination of the recurrence relations reveals that  km is created by considering two possibilities: (1) excluding job k from the set of on-time jobs, in which case  km is the same as  k−1,m , or (2) appending job k to  k−1,m−1 . It is possible to obtain a better schedule (and hence a better upper bound) by extending the number of possibilities considered. An extended dynamic program (EDP) was developed that considers two additional types of schedules: partial sequences created by inserting job k into  k−1,m−1 , and partial sequences where job k replaces some job in  k−1,m . The pseudo-code illustrated in Fig. 1 outlines the new EDP algorithm. The function REPLACE(σ, k), returns the shortest (i.e., minimum completion time) feasible schedule among all schedules that replace a job in σ with job k. If no feasible schedule exists, the function REPLACE(σ, k) returns σ . The function INSERT(σ, k) returns the shortest feasible schedule among all schedules that insert job k into σ . If no feasible schedule exists, the function INSERT(σ, k) returns σ . Dauzère-Pérès [6] introduced the MLJ constructive heuristic, which consists of attempting to schedule new jobs with release dates earlier than the current completion time of the last scheduled job. Jobs are also chosen in a way that minimizes the completion time of the last scheduled job. The MLJ heuristic is also used to compute the upper bound for the number of tardy jobs. This heuristic runs in O(n2 ) time. 4.2 Branching and dominance scheme This section describes how all the dominance rules are used in conjunction with the branching scheme in the BB&R algorithm. The BB&R algorithm using the CBFS exploration strategy is described. The pseudo-code for the BB&R algorithm is also presented. Given a particular subproblem (σ, Fσ , Tσ , Eσ ), a new subproblem is created by adding a new job to the partial sequence σ , (i.e., a new sequence σ ⊕ f ≡ (σ1 , σ2 , . . . , σm , f ) where m is the length of σ and f ∈ Fσ ). The new subproblem is denoted by (σ , Fσ , Tσ , Eσ ). As described below, the NNDOR and the ITR dominance rules are used to filter Fσ to find the set of free jobs that can be appended to σ as the new job, while the EJR and the GMDR are used to prune new sequences. The NDDOR and the ITR are initially used to filter Fσ . Only jobs that are in Fσ and satisfy the NDDOR and the ITR are considered for branching. Formally, let P Fσ = {f ∈ Fσ : σ ⊕ f satisfies the NNDOR and the ITR} be the set of jobs that could possibly be scheduled first among the free jobs. If no such jobs can be found, then the current branch is pruned. Scheduling a new job modifies the previous Fσ , Tσ , and Eσ , where Tσ is modified by checking each job in Fσ for tardiness, and Eσ is computed based on the EJR, (see Sect. 3). The new set of tardy jobs and early jobs are then checked for consistency with the EJR. If any of the late jobs becomes an early job, or if a tardy job does not satisfy the EJR, then the branch is pruned. Note that in [1], the dominance rule is used as a preprocessor to identify unscheduled jobs to be considered for branching, which must be either on-time or tardy. The EJR embedded in the BB&R algorithm is used to actively prune further branching. If the new subproblem (after branching) satisfies the EJR, the NDDOR, and the ITR, then the GMDR is applied. The set of free jobs Fσ is used as the hash key to

1262

G.K. Kao et al.

EDP Mk = 0 for k = 1, . . . , n, Ck,m = ∞ for k = 1, . . . , n, m = 1, . . . , n M1 = 1, C0,0 = 0 C1,1 = r1 + p1  1,1 = (1) for k = 2 to n do Mk = Mk + 1 for m = Mk down to 2 do if Ck−1,m < ∞ then σ = REPLACE( m,m , k) else cσ = ∞ end if δ = INSERT( m−1,m−1 , k) if cσ ≤ cδ then Ck,m = cσ if cσ < ∞ then  m,m = σ end if else Ck,m = cδ  m,m = δ end if end for if Mk > 0 then if Ck−1,1 ≤ max(0, rk + pk ) then Ck,1 = Ck−1,1 else Ck,1 = max(0, rk + pk )  1,1 = (k) end if end if Mk = max{j : Ck,j < ∞} end for Fig. 1 Extended dynamic programming algorithm for generating upper bounds

find the corresponding entry in the hash table. If this entry in the hash table is empty, then the current subproblem is stored; otherwise, the GMDR is used to compare the current subproblem and the previously stored one(s). If it dominates the previously stored one(s), then the new subproblem replaces the old subproblem(s) in the hash table. If, on the other hand, any old subproblem stored in the hash table dominates the new subproblem, then the current branch is pruned.

New dominance rules and exploration strategies

1263

The combination of the EJR, the NDDOR, and the ITR, with the addition of the GMDR significantly reduces the search space for the BB&R algorithm. The algorithm with the CBFS exploration strategy is now presented. CBFS is a hybrid between DFS and BFS. (CBFS was formerly called distributed best first search in [12].) In CBFS, subproblems are explored based on the length of the sequence of on-time jobs and a best-measure, a heuristic function that evaluates the potential of a subproblem leading to an optimal solution. CBFS explores subproblems by sequentially considering subproblems with longer and longer sequence of on-time jobs. Let level 0 be the root of the BB&R search tree, which corresponds to the original problem. Let level 1 subproblems be all subproblems with a sequence of on-time jobs of length 1, and let level 2 subproblems be all subproblems with a sequence of on time jobs of length 2, and so forth. The CBFS starts by choosing a subproblem at level 0 to explore. It then chooses a subproblem at level 1 to explore and continues until it reaches the deepest level (i.e., level n), at which time it returns to level zero. It then repeatedly cycles through the levels of the search tree. When the CBFS chooses a node at level k, it chooses the one with the highest best-measure value (to be defined below). The children of the chosen subproblem are generated and added to level k + 1. BFS and CBFS both use a heuristic to measure “best”. The heuristic function assigns a number to each subproblem. Ideally, this function should assign larger numbers to subproblems that are more likely to lead to the optimal solution. Two heuristics are considered in this paper. The first, denoted by DD, is based on due-date order. That is, if σ is a sequence of on-time jobs in the current subproblem with m jobs, then Best = −1 ∗ dσm . This measure favors subproblems with sequences of on-time jobs with earlier due-dates. The second, denoted by RP, is more sophisticated and takes earlier release times as well as the processing times of the free jobs into consideration. Define wi = di − max(ˆrσ , ri )  for i ∈ Fσ to be the time window for each job i. The measure is defined as Best = i∈Fσ wi /pi . This second measure prefers schedules with smaller value for rˆσ as well as schedules with shorter free jobs in longer time windows. Note that BB&R-DFS also has an implicit measurement, which is based on exploring P Fσ in due-date order. An outline of the CBFS exploration strategy is given in Fig. 2. Note that there may be iterations in the search process where some levels may not have any unexplored subproblems. In such cases, no new subproblems are explored for that iteration, and no new subproblems are added to the next level. Cyclic best first search Initialize level 0 by storing the root problem (σ = (), Fσ = J, Tσ = ∅, Eσ = ∅) while unexplored subproblems exist do for k = 0 to n do Explore the best subproblem in level k Store all the children of the best subproblem in level k + 1 end for end while Fig. 2 Outline of CBFS

1264

G.K. Kao et al.

CBFS is a hybrid between DFS and BFS. Similar to DFS, CBFS is designed to produce complete solutions quickly. Similar to BFS, CBFS uses the best measure to jump from one part of the search tree to another more promising part of the search tree. This ability to jump to a more promising part of the search tree is CBFS’s primary advantage over DFS, allowing it to usually find an optimal solution earlier than DFS. For some discrete optimization problems, BFS has a propensity to choose subproblems in the middle levels of the search tree before subproblems that are either high or low in the search tree. This phenomenon can cause BFS to generate relatively few complete solutions until it has exhausted the middle levels. In contrast, CBFS is designed to choose a subproblem from every level of the search tree every time it cycles through the levels. Hence it often finds the optimal solution sooner than BFS. In the BB&R-CBFS pseudo-code, a heap structure is needed to store subproblems for each level of the search tree. When a subproblem is expanded by scheduling each of the jobs in P Fσ , each new subproblem is verified to satisfy the EJR and the GMDR prior to being added into the next level heap. Note that there may exist subproblems in the heap that are dominated by the GMDR after they have been added to the heap. For example subproblem B may dominate subproblem A by GMDR, but the predecessor of subproblem A may have been explored before the predecessor of subproblem B, which results in adding subproblem A to the heap before subproblem B. A simple dominance bit (i.e., an indicator that indicates a subproblem is dominated if set), can be used to keep track of such subproblems to avoid unnecessary exploration of subproblem A. The pseudo-code for the BB&R algorithm with the CBFS (BB&RCBFS) implementation is given in Fig. 3. 4.3 Enhancements to the BB&R algorithm This section describes an enhancement to the BB&R algorithm presented above. The look-ahead NDDOR (LA-NDDOR) is based on the NDDOR. Suppose that job i ∈ P Fσ is appended to σ to obtain σ = (σ1 , . . . , σm , σm+1 ) where σm+1 = i. Let k = min{h : h ∈ Fσ \ {σm+1 }}. If σm+1 > k and sσm+1 ≥ rk , then k cannot be scheduled in position m + 2 because it would violate the NDDOR. Furthermore, it cannot be scheduled in any later position since it would violate the EJR. To see this, let σ = (σ1 , . . . , σm , σm+1 , . . . , σq ). σq > k since σq ∈ Fσ \ {σm+1 } and k = min{h : h ∈ Fσ \ {σm+1 }}. In addition, rk ≤ sσm+1 ≤ sσq . Therefore, the NDDOR will be violated if k is scheduled in position q +1. Consequently, the NDDOR will prevent job k from being scheduled on time in any super-sequence of σ . Thus job k should be added to Tσ instead of Fσ . This test can be repeated for each job in Fσ \ {σm+1 }, in due-date order, until one is found that can be scheduled in position m + 2. The LA-NDDOR enhances the algorithms in two ways. First it produces a tighter lower bound earlier in the branching process, and second, if any job added to Tσ is later added to Eσ , then the entire branch will be pruned by the EJR. Figure 4 provides the pseudo-code for this enhancement. The discussion above yields the following theorem which states that the LANDDOR may be used in the BB&R algorithm in conjunction with the other dominance rules such that the BB&R algorithm remains exact.

New dominance rules and exploration strategies

1265

BB&R-CBFS(U B, hash_table, heap(0, . . . , n)) while unexplored subproblems exist do for k = 1 to n do Choose the best subproblem (σ, Fσ , Tσ , Eσ ) in level k by popping heap(k) LB = |Tσ |+ Lower_Bound(Fσ , rˆσ ) if LB < U B then P Fσ = {f ∈ Fσ : σ ⊕ f satisfies the NNDOR and the ITR} for each f ∈ P Fσ do σ = σ ⊕ f if n − k − 1 < U B then UB = n − k − 1 end if Compute Fσ , Tσ , and Eσ if σ satisfies the EJR and the GMDR then Store (σ , Fσ , Tσ ) in hash_table best = Best_measure(σ , Fσ , rˆσ ) Add (σ , Fσ , Tσ ) to heap(k+1) end if end for end if end for end while Fig. 3 BB&R-CBFS pseudo-code

LA-NDDOR(Fσ , σ = (σ1 , . . . , σm ), σm+1 ) Sort Fσ in Due-Date order, F = {}, T = Tσ for k ∈ Fσ \ {σm+1 } do if cσm+1 + p k > dk then T = T {k} else if F = {} and  (σm+1 > k ∧ sσm+1 ≥ rk ) then T = T {k} else  F = F {k} end if end if end for Fig. 4 LA-NDDOR pseudo-code

Theorem 3 The Branch, Bound, and Remember Algorithm using the look-ahead NDDOR is an exact algorithm.

1266

G.K. Kao et al.

5 Computational results Computational results are presented that demonstrate the effectiveness of the BB&R algorithm. Several variations of the algorithm are investigated, including two different best-measures, several exploration strategies, the LA-NDDOR, and the relative effectiveness of the various dominance rules. Computational results comparing the EDP and MLJ heuristics described in Sect. 4.1 are also presented. The effectiveness of the BB&R algorithm is evaluated over 7,200 randomly generated test instances. These test instances were generated using the same generation scheme described in Baptiste et al. [1], based on four parameters: number of jobs, processing time range, maximum slack margins, and machine load, denoted as (n, [pmin , pmax ], slackmax , load). The processing times pi are generated from a uniform distribution defined by [pmin , pmax ]. The slack margins mi = di − ri − pi are generated from a uniform distribution defined by [0, slackmax ]. The release times ri are generated from a normal distribution defined by N (0, σ ), where σ is determined by the equation load = n(pmin + pmax )/2(4σ + pmax + slackmax ). Note that the distributions for these parameters can be chosen differently, though the impact of such distribution changes would be difficult to assess without additional experimentation. For the distributions used, two are uniform, and hence, are defined over a compact set of values. Based on the possible values for (n, [pmin , pmax ], slackmax , load), the value for σ ranged from 350 to 7456.25, which provides a very wide and diverse range of possible release time values generated. The machine load is defined to be the ratio between the sum of the jobs’ processing times and the difference of the maximum due-date and the minimum release time. Given ri , pi , and mi , the duedate di can be computed by di = mi + ri + pi . The parameters used for generating the test instances are n = {80, 100, . . . , 300}, [pmin , pmax ] = {[25, 75], [0, 100]}, slackmax = {50, 100, . . . , 500}, and load = {0.5, 0.8, 1.1, 1.4, 1.7, 2.0}. For each combination of parameter settings, five random instances are generated for a total of 7,200 instances. The parameters used in generating the test instances in this paper are identical to the parameters used in generating the instances in Baptiste et al. [2] and Dauzère-Pérès and Sevaux [8]. The BB&R algorithm, including the EDP, was implemented in C++. The experiments in this paper were executed on a 3 GHz Pentium D PC with 2 GB RAM. Two different best-measures, described in Sect. 4.2, were tested in conjunction with the CBFS exploration strategy. These two variations are denoted as BB&RCBFS-DD and BB&R-CBFS-RP. The DD best-measure favors jobs with earlier duedates, while the RP best-measure favors jobs with earlier release times and shorter processing times. Table 1 reports the average, median, and maximum running times for the BB&RCBFS-DD and BB&R-CBFS-RP algorithms. The test set is organized by n − pmin − pmax , with each instance in the test set restricted to a one hour total (3600 sec) CPU time limit. Both variations of the BB&R-CBFS were able to solve all instances to optimality. The overall performance of the two best-measures is very similar. For some of the instances, BB&R-CBFS-DD was faster, while for other instances BB&RCBFS-RP was faster. The BB&R-CBFS-RP was able to solve all instances in under fifteen minutes, with the exception of the 260 − 0 − 100 and 300 − 0 − 100 instances.

New dominance rules and exploration strategies

1267

Table 1 Average, median, and maximum CPU time (sec) n

pmin

pmax

BB&R-CBFS-DD Avg.

Med.

BB&R-CBFS-RP Max

Avg.

Med.

Max

80

0

100

0.5

0.4

5.4

0.6

0.4

7.6

80

25

75

0.4

0.4

1.8

0.4

0.4

1.2

100

0

100

1.9

0.4

393.0

1.6

0.4

281.8

100

25

75

0.5

0.4

4.6

0.5

0.4

2.7 22.6

120

0

100

0.9

0.5

15.0

1.3

0.5

120

25

75

0.7

0.5

7.1

0.7

0.5

4.8

140

0

100

1.2

0.7

10.7

1.7

0.7

52.3

140

25

75

1.0

0.7

20.3

0.8

0.6

10.7

160

0

100

1.9

0.9

33.6

2.7

0.8

73.0

160

25

75

1.3

0.9

11.0

1.0

0.7

9.2

180

0

100

2.6

1.1

109.4

3.5

0.8

135.7

180

25

75

1.9

1.0

19.0

1.4

0.8

11.8

200

0

100

5.1

1.4

237.6

5.5

1.1

248.5

200

25

75

3.3

1.5

149.1

2.3

1.1

112.3

220

0

100

5.5

2.0

145.7

8.3

1.4

496.6

220

25

75

4.0

1.7

38.6

2.7

1.3

32.5

240

0

100

12.4

2.5

515.3

10.7

1.6

414.0

240

25

75

5.9

2.4

62.5

3.7

1.7

38.4 959.6

260

0

100

15.8

3.2

447.2

18.2

2.4

260

25

75

7.8

2.6

127.2

5.1

2.0

49.8

280

0

100

26.1

4.0

734.3

26.5

2.5

633.5

280

25

75

13.1

3.9

284.7

7.6

2.5

162.5

300

0

100

26.4

5.1

510.5

45.7

3.3

2924.3

300

25

75

19.6

4.7

439.7

11.5

3.1

234.5

For the remainder of the paper, the RP best-measure is used for evaluating the variations and extension of the BB&R algorithm. Tables 2 summarizes the results of the test set with the LA-NDDOR extension. Table 2 reports the average, median, maximum, and the standard deviation of the running times for the BB&R algorithm using the RP best measure with different exploration strategies. The CBFS exploration strategy is compared with the DFS and the BFS exploration strategies. The BB&R-CBFS-RP and the BB&R-BFS-RP were able to solve all instances to optimality; however, BB&R-DFS was unable to solve 17 of the 7,200 instances. The numbers in parentheses associated with some of the entries in Table 2 report the number of instances that were incomplete. The average, median, and standard deviation of the running times reported in Table 2 include those instances that were incomplete (note: the maximum time limit is set at 3600 CPU seconds). By using the LA-NDDOR, for the larger instances, BB&R-CBFS-RP was an order of magnitude faster on average then BB&R-DFS. All instances were solved to optimality in less than eight minutes. On average over the 7,200 instances, BB&R-BFS-

pmin

0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25

n

80 80 100 100 120 120 140 140 160 160 180 180 200 200 220 220 240 240 260 260 280 280 300 300

100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75

pmax

0.5 0.4 1.5 0.5 0.9 0.8 1.4 1.4 2.4 1.4 4.2 2.8 9.6 12.9 13.3 9.5 2.4(2) 15.2 69.6(1) 32.8 25.4(5) 72.7(2) 47.5(5) 123.2(2)

BB&R-DFS Avg.

0.4 0.4 0.4 0.4 0.5 0.5 0.6 0.5 0.8 0.7 1.0 0.9 1.5 1.4 2.4 2.4 2.8 3.7 5.2 6.0 6.9 6.5 11.0 13.3

Med. 6.6 1.7 272.1 7.2 11.7 17.0 43.8 58.6 104.4 18.5 209.5 46.4 519.7 2315.3 589.7 235.8 3600.0 195.8 3600.0 1955.7 3600.0 3600.0 3600.0 3600.0

Max 0.4 0.1 15.7 0.5 1.4 1.6 3.2 4.7 7.1 2.0 16.0 5.9 42.2 133.9 46.2 25.2 319.3 30.3 344.8 138.7 498.5 330.9 556.0 434.8

Stdv 0.9 0.5 0.9 0.6 2.5 0.9 1.6 1.1 2.1 1.2 2.5 1.6 4.7 1.9 6.0 2.3 5.7 2.7 7.3 3.3 10.3 4.2 14.1 5.1

0.4 0.4 0.4 0.4 0.5 0.4 0.5 0.5 0.5 0.5 0.6 0.6 0.6 0.6 0.8 0.7 0.8 0.8 1.1 1.0 1.1 1.1 1.3 1.3

BB&R-BFS-RP Avg. Med.

Table 2 Average, median, maximum, and standard deviation CPU time (sec) with LA-NDDOR

29.6 5.7 41.8 6.7 272.9 17.7 70.8 38.0 55.8 13.1 81.9 19.4 332.5 44.1 311.0 46.7 306.5 33.3 676.5 42.1 1170.3 75.4 815.0 57.8

Max 2.6 0.5 2.7 0.5 16.7 1.7 4.9 2.5 5.3 1.8 7.6 2.7 25.3 3.9 26.1 4.5 21.8 4.4 41.0 5.6 68.8 8.7 64.9 8.5

Stdv 0.4 0.4 0.6 0.4 0.6 0.5 0.8 0.7 1.1 0.8 1.3 1.0 2.2 1.5 2.6 1.8 3.9 2.4 5.5 3.2 9.1 4.7 11.5 6.5

0.4 0.4 0.4 0.4 0.5 0.4 0.5 0.5 0.6 0.6 0.8 0.7 0.9 0.9 1.2 1.0 1.4 1.3 1.9 1.6 2.1 2.1 2.8 2.5

BB&R-CBFS-RP Avg. Med. 2.7 0.8 39.4 1.3 4.4 3.1 4.7 6.4 13.8 4.7 16.0 6.7 72.1 56.5 29.7 18.1 99.6 17.0 60.5 25.9 178.0 79.5 499.8 85.4

Max

0.7 0.1 2.3 0.1 0.5 0.3 0.6 0.5 1.2 0.5 1.6 0.9 6.1 3.4 3.9 2.1 8.0 2.8 9.7 4.0 22.0 7.9 34.0 10.9

Stdv

1268 G.K. Kao et al.

New dominance rules and exploration strategies

1269

RP requires 32% more CPU time than BB&R-CBFS-RP, moreover, Table 2 shows that for most of the instances, BB&R-CBFS-RP has a standard deviation that is less than half of the standard deviation of BB&R-BFS-RP. By design, the LA-NDDOR extension was able to reduce the number of branches in the BB&R algorithm. M’Hallah and Bulfin [18] report the best computational results to date for solving the 1|ri | Ui scheduling problem. On average, their algorithm took 193.4 seconds for solving instances with size n = 200 on a 1 GHz Pentium IV PC. (The 193.4 seconds average actually is for 44 instances that Baptiste et al. [2] were unable to solve, but they reported that the results were similar for all the problems.) The BB&R-CBFS-DD and the BB&R-CBFS-RP algorithms were also tested on the instances used in Baptiste et al. [2]. Both BB&R-CBFS-DD and BB&R-CBFS-RP were able to solve all test instances from Baptiste et al. The BB&R-CBFS-DD on average took 1.3 seconds to solve all instances with n = 200, while the maximum time was 12.3 seconds. The BB&R-CBFS-RP algorithm is slightly faster than BB&R-CBFSDD, and on average took 1.1 seconds to solve all instances with n = 200, while the maximum time was 9.9 seconds. Although the experiments in these papers were executed on different platforms using different programming languages (FORTRAN vs. C++), the average running time of the BB&R algorithm was two orders of magnitude faster, which clearly dominates the results in M’Hallah and Bulfin [18]. Table 3 reports the average and maximum running times for the BB&R-CBFS algorithm with RP best measure when each of the dominance rules and the EDP upper bound described in Sects. 2, 3, and 4.1 is removed individually. The number in parenthesis in Table 3 reports the number of unsolved instances. The average and maximum running time for the w/o GMDR column ignores the unsolved instances. The table provide insights into the relative impact of each dominance rule and the EDP. The GMDR has the largest impact on the performance of the BB&R-CBFS algorithm. Without GMDR, the algorithm has difficulty solving all the test instances. At size n = 80, 100, 120, it was only able to solve 98.5%, 92.5%, and 83% of the test instances respectively. By using the GMDR (versus not using GMDR), the computational time for the BB&R-CBFS algorithm improved by two orders of magnitude. Despite the overwhelming impact of the GMDR, the other dominance rules also have a significant impact on the performance of the BB&R-CBFS algorithm as well. On average, the BB&R-CBFS algorithm takes two times longer when the EJR or the NDDOR is not used. For the larger instances, the BB&R-CBFS algorithm takes up to five times longer when ITR is not used. Examining the maximum running time in Table 3 shows that for the difficult instances, each of the individual dominance rules can have a significant impact on the degradation in the performance of the BB&R-CBFS algorithm. Table 3 shows that on average, the ITR rule has a stronger impact than the EJR and NDDOR on the performance of the BB&R-CBFS algorithm. However, in the worst cases both NDDOR and ITR have a significant impact on the performances of the BB&R-CBFS algorithm. In addition to the computational results for the BB&R algorithm, the test set was also used to assess the effectiveness of the EDP described in Sect. 4.1. The column labeled EDP in Table 4 reports the number of instances for which EDP provided a tighter upper bound than MLJ. The column labeled MLJ reports the number of instances for which MLJ provided a tighter upper bound than EDP. Moreover, the

pmin

0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25 0 25

n

80 80 100 100 120 120 140 140 160 160 180 180 200 200 220 220 240 240 260 260 280 280 300 300

100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75 100 75

pmax

0.5 0.5 0.8 0.6 0.9 0.8 1.1 1.0 1.6 1.2 2.1 1.7 3.9 3.0 4.5 3.5 7.5 4.9 10.5 6.5 18.3 10.1 24.5 14.7

w/o EJR Avg.

6.4 1.8 75.5 3.9 9.4 7.8 10.4 13.5 26.8 8.5 25.8 14.1 161.5 177.0 65.6 43.8 309.7 49.0 1156.0 67.0 397.6 195.6 1787.1 299.2

Max 0.5 0.5 1.1 0.6 1.4 1.0 2.3 1.6 3.7 2.3 5.5 3.4 10.1 5.9 13.4 7.9 20.9 11.4 30.6 15.6 49.4 22.7 61.8 30.9

w/o ITR Avg. 4.6 1.3 78.7 2.7 9.6 6.0 21.7 16.9 48.9 12.4 56.2 23.7 283.7 167.7 156.8 66.8 474.7 83.3 349.7 118.4 1027.1 291.0 1813.5 165.8

Max

Table 3 Average and maximum CPU time (sec) with different dominance rules and EDP

0.5 0.4 2.6 0.5 1.1 0.7 1.4 1.0 2.4 1.1 3.5 1.6 7.6 2.8 7.6 3.2 14.8 4.5 24.3 6.2 45.7 9.6 41.8 14.8

6.0 1.4 590.8 4.6 27.6 6.5 21.6 11.1 45.5 15.0 153.3 16.1 457.5 146.9 190.6 43.7 905.6 53.5 597.3 70.0 1563.8 185.9 1126.4 405.6

w/o NDDOR Avg. Max 0.5 0.4 0.6 0.5 0.7 0.6 0.8 0.7 1.1 0.8 1.4 1.1 2.2 1.5 2.7 1.9 4.3 2.4 5.9 3.1 8.4 4.2 9.4 5.7

w/o EDP Avg. 2.2 0.9 28.8 1.1 3.5 2.6 4.1 5.5 11.2 4.0 13.8 6.2 58.3 42.1 26.3 16.9 81.0 15.6 82.6 23.6 139.2 60.9 300.6 60.3

Max 13.6 (7) 12.3 (2) 67.6 (30) 41.1 (15) 84.3 (60) 64.5 (42)

w/o GMDR Avg.

849.9 1653.4 1834.6 2755.4 1784.5 2096.0

Max

1270 G.K. Kao et al.

New dominance rules and exploration strategies

1271

Table 4 EDP vs. MLJ comparison n

EDP

MLJ

EDP optimal

Avg. Gap

pmin

pmax

80

0

100

228

8

190

0.41

80

25

75

174

7

186

0.41

100

0

100

236

9

162

0.56

100

25

75

194

10

174

0.45

120

0

100

251

7

133

0.77

120

25

75

218

10

149

0.57

140

0

100

270

7

126

0.78

140

25

75

221

7

148

0.64

160

0

100

280

4

114

0.93

160

25

75

242

7

118

0.8

180

0

100

271

6

103

1.06

180

25

75

247

4

111

0.92

200

0

100

282

1

82

1.22

200

25

75

257

6

100

0.99

220

0

100

282

3

85

1.29

220

25

75

259

6

88

1.17

240

0

100

286

4

88

1.33

240

25

75

264

3

87

1.21

260

0

100

290

1

73

1.49

260

25

75

264

11

77

1.35

280

0

100

292

2

68

1.65

280

25

75

275

4

64

1.5

300

0

100

293

4

66

1.88

300

25

75

269

4

71

1.57

column labeled EDP Optimal in Table 4 also reports the number of times the upper bound estimated by the EDP is equal to the optimal number of tardy jobs, and also the average gap between the optimal number of tardy jobs and the estimated upper bound. For each set of instances reported, the average gap is calculated by taking the average over the difference between the optimal value and the upper bound generated by the EDP. The average gap calculation includes those instances where the EDP upper bound is equal to the optimal value (i.e., gap of 0). The average gap is a performance indicator showing how close the upper bound generated by EDP is to the optimal value. The EDP heuristic clearly outperformed the MLJ heuristic. The EDP was also able to consistently find tighter upper bounds. For more than half of the smaller instances, EDP was able to find the optimal solution. For the smaller instances, the tighter upper bound contributed to the overall average effectiveness of the BB&R algorithm. However, as the problem size increased, the EDP found fewer optimal bounds for the larger instances compared to the results for the smaller instances. The average and maximum running time without using EDP in Table 3 shows that the EDP has less of an impact compared with the dominance properties. Some instances have slightly

1272

G.K. Kao et al.

faster running times when the EDP was not used compared with when it was used. Table 3 shows that on average, the EDP did improve the performances of the BB&RCBFS-RP algorithm for the smaller instances (up to n = 260 jobs). However for the larger instances, the EDP, on average, incurred some small additional running time. The cause of such a phenomenon may be due to the computational trade-offs in performing the EDP (i.e., taking the extra effort to compute the EDP upper bound), or because the EDP was just less effective on the larger instances, as Table 4 shows. It is likely that the result is a combination of both these factors.

6 Conclusion This paper presents the BB&R algorithm using the CBFS exploration strategy to  solve the 1|ri | Ui scheduling problem. The paper provides enhancements to two previously known dominance rules (reported by Baptiste et al. [2] and Dauzère-Pérès and Sevaux [8], respectively) and describes a new memory-based dominance rule. This paper describes how these dominance rules can be embedded in a new B&B algorithm using an effective CBFS exploration strategy. The resulting new algorithm, BB&R, is proven to be exact. The BB&R-CBFS solved all 7200 randomly generated test instances to optimality, outperforming the current best known exact algorithms. Furthermore, the LA-NDDOR extension provided additional computational improvement. The running time for the LA-NDDOR extension in conjunction with the CBFS exploration strategy is an order of magnitude faster than the BB&R-DFS variation. The ITR rule and the GMDR have the greatest impact on the performances of the BB&R-CBFS algorithm. Like all B&B algorithms, improving the lower and upper bounds likely reduces its execution time. An extended dynamic programming algorithm is also presented and is shown to significantly improve the upper bound estimation. The combination of all the dominance rules, the new exploration strategy, and the improved upper bound computation all demonstrate the efficiency of the BB&R algorithm. The BB&R algorithm has been successfully applied to the 1|ri | Ui scheduling problem. The BB&R algorithm has also been effectively applied to other  scheduling problems, including the total tardiness scheduling problem, 1|ri | ti [12] and the single machine scheduling problem with sequence dependent setup times,  where the objective is to find a schedule with minimum total tardiness, 1|ST | ti [29]. sd  There are also practical military applications of the 1|ri | Ui scheduling problem that involve limited, highly valued assets that process certain tasks within a given time window (e.g., a surveillance satellite that must photograph as many locations as possible within its overpass time window.) Another military application of a limited, high value asset is the Air Force Airborne laser (ABL) system, which employs a 100 ton system of chemical lasers encased within a Boeing 747 aircraft designed for theater ballistic missile (TBM) defense. In particular, the ABL system is designed to detect the launch of a TBM, track its trajectory, and then destroy the missile using a high powered (megawatt class) laser (which is achieved by heating the TBM’s own fuel supply until the fuel explodes and destroys the missile.) Therefore, once the TBM’s boost phase is complete, the ABL system is no longer effective. The monetary cost and critical military mission of the ABL system make its optimal utilization

New dominance rules and exploration strategies

1273

 a strategic military priority. Work is in progress to modify the 1|ri | Ui scheduling problem such that it models the ABL system, and hence, can be optimized using the BB&R algorithm approach. Acknowledgements The authors wish to thank the editor and three anonymous referees for their insightful comments and suggestions, resulting in a significantly improved manuscript. The computational results reported were obtained using the Simulation and Optimization Laboratory. This research has been supported in part by the Air Force Office of Scientific Research (FA9550-07-1-0232, FA9550-10-1-0387). The views expressed in this paper are those of the authors and do not reflect the official policy or position of the United States Air Force, Department of Defense, or the United States Government.

References 1. Baptiste, P., Le Pape, C., Peridy, L.: Global constraints for partial CSPs: a case-study of resource and due date constraints. In: Constraint Programming 98. Lecture Notes in Computer Science, vol. 1520, pp. 87–101 (1998) 2. Baptiste, P., Peridy, L., Pinson, E.: A branch and bound to minimize the number of late jobs on a single machine with release time constraints. Eur. J. Oper. Res. 144(1), 1–11 (2003) 3. Bedworth, D., Bailey, J.: Integrated Production Control Systems: Management, Analysis, Design. Wiley, New York (1987) 4. Bellman, R.: Dynamic Programming. Princeton University Press, Princeton (1957) 5. Brucker, P.: Scheduling Algorithms, 2nd edn. Springer, Heidelberg (2007) 6. Dauzère-Pérès, S.: Minimizing late jobs in the general one machine scheduling problem. Eur. J. Oper. Res. 81(1), 134–142 (1995) 7. Dauzère-Pérès, S., Sevaux, M.: Using Lagrangean relaxation to minimize the weighted number of late jobs on a single machine. Nav. Res. Logist. 50(3), 273–288 (2003) 8. Dauzère-Pérès, S., Sevaux, M.: An exact method to minimize the number of tardy jobs in single machine scheduling. J. Sched. 7(6), 405–420 (2004) 9. Glover, F.: Future paths for integer programming and links to artificial intelligence. Comput. Oper. Res. 13(5), 533–549 (1986) 10. Graham, R., Lawler, E., Lenstra, J.K., Rinnooy Kan, A.: Optimization and approximation in deterministic sequencing and scheduling: a survey. Ann. Discrete Math. 4, 287–326 (1979) 11. Jouglet, A., Baptiste, P., Carlier, J.: Branch-and-bound algorithms for total weighted tardiness. In: Leung, J.Y.-T. (ed.) Handbook of Scheduling: Algorithms, Models, and Performance Analysis. CRC Press, Boca Raton (2004)  12. Kao, G.K., Sewell, E.C., Jacobson, S.H.: A Branch, Bound, and remember algorithm for the 1|ri | ti scheduling problem. J. Sched. 12(2), 163–175 (2009) 13. Kise, H., Ibaraki, T., Mine, H.: A solvable case of the one-machine scheduling problem with ready and due times. Oper. Res. 26(1), 121–126 (1978) 14. Koulamas, C.: The total tardiness problem: review and extensions. Oper. Res. 42(6), 1025–1041 (1994) 15. Lasserre, J., Queyranne, M.: Generic scheduling polyhedra and a new mixed integer formulation for single machine scheduling. In: Proceedings of the 2nd Integer Programming Conference, Pittsburgh, PA, pp. 136–149 (1992) 16. Lawler, E.: Knapsack-like scheduling problems, the Moore-Hodgson algorithm and the “tower of sets” property. Math. Comput. Model. 20(2), 91–106 (1994) 17. Lenstra, J.K., Rinnooy Kan, A., Brucker, P.: Complexity of machine scheduling problems. Ann. Discrete Math. 1, 342–362 (1977) 18. M’Hallah, R., Bulfin, R.L.: Minimizing the weighted number of tardy jobs on a single machine with release dates. Eur. J. Oper. Res. 176(2), 727–744 (2007) 19. Moore, J.M.: An n job, one machine sequencing algorithm for minimizing the number of late jobs. Manag. Sci. 15(1), 102–109 (1968) 20. Morin, T., Marsten, R.: Branch-and-bound strategies for dynamic programming. Oper. Res. 24(4), 611–627 (1976) 21. Nemhauser, G.: Introduction to Dynamic Programming. Wiley, New York (1966)

1274

G.K. Kao et al.

22. Péridy, L., Pinson, E., Rivreau, D.: Using short-term memory to minimize the weighted number of late jobs on a single machine. Eur. J. Oper. Res. 148(3), 591–603 (2003) 23. Pinedo, M.L.: Planning and Scheduling in Manufacturing and Services. Springer, Heidelberg (2005) 24. Potts, C.N., Van Wassenhove, L.N.: A branch and bound algorithm for the total weighted tardiness problem. Oper. Res. 33, 363–377 (1985) 25. Rinnooy Kan, A.: Machine Scheduling Problem: Classification, Complexity and Computations. Nijhoff, Hague (1976) 26. Sadykov, R.: A Hybrid Branch and Cut for the One Dimensional Machine Scheduling Problem. Lecture Notes in Computer Science, vol. 3011, pp. 409–414 (2004) 27. Sellers, D.W.: A survey of approaches to the job shop scheduling problem. In: 28th Southeastern Symposium on System Theory, Baton Rouge, LA, pp. 396–400 (1996) 28. Sevaux, M., Dauzère-Pérès, S.: Genetic algorithms to minimize the weighted number of late jobs on a single machine. Eur. J. Oper. Res. 151(2), 296–306 (2000) 29. Sewell, E.C., Kao, G.K., Jacobson, S.H.: Minimizing total tardiness for the single machine with sequence dependent setup time problem using the BB&R algorithm. Technical Report, University of Illinois, Urbana, Illinois 30. Zhou, R., Hansen, E.A.: Structured duplicate detection in external-memory graph search. In: Proc. of 19th National Conference on Artificial Intelligence, San Jose, CA, pp. 683–689 (2004) 31. Zhou, R., Hansen, E.A.: Beam-stack search: integrating backtracking with beam search. In: Proc. of 15th International Conference on Automated Planning and Scheduling, Pittsburgh, PA, pp. 90–98 (2005)