A theoretical development for the total tardiness problem and its application in branch and bound algorithms

Computers & Operations Research 40 (2013) 248–252

Contents lists available at SciVerse ScienceDirect

Computers & Operations Research journal homepage: www.elsevier.com/locate/caor

A theoretical development for the total tardiness problem and its application in branch and bound algorithms Shuyu Zhou a,b, Zhaohui Liu a,n a b

Department of Mathematics, East China University of Science and Technology, Shanghai 200237, China Rotterdam School of Management, Erasmus University, Post Box 1738, 3000 DR Rotterdam, the Netherlands

a r t i c l e i n f o

a b s t r a c t

Available online 23 June 2012

This paper deals with the single machine total tardiness problem, and proves that if the job sequences produced by two heuristics, named as Time Forward and Time Backward algorithms, have the same starting and ending job subsequences, then there exists an optimal job sequence with the starting and ending job subsequences. The computation experiments show that there is a significant improvement of the running time of a branch and bound algorithm with the incorporation of the new property. & 2012 Elsevier Ltd. All rights reserved.

Keywords: Scheduling Single machine Total tardiness Branch and bound

1. Introduction The single machine total tardiness problem (TTP) can be stated as follows. There is a set N ¼ f1; 2, . . . ,ng of n jobs to be processed non-preemptively on a continuously available single machine which can handle only one job at a time. Job i ði A NÞ becomes available at time zero, requires a processing time pi ðpi 4 0Þ and has a due date di ð1odi o þ 1Þ. When a sequence s ¼ ðsð1Þ, sð2Þ, . . . , sðnÞÞ of the jobs in N is prescribed, then for each P job sðiÞ, its completion time C sðiÞ ¼ k r i psðkÞ and tardiness T sðiÞ ¼ max f0,C sðiÞ dsðiÞ g can be computed. The task is to find a job sequence s such that the total tardiness TTðsÞ ¼

n X i¼1

T sðiÞ ¼

n X

maxf0,C sðiÞ dsðiÞ g

i¼1

is minimized. TTP is NP-hard in the ordinary sense [5] and most optimization algorithms use a combination of dynamic programming (DP) and branch and bound (BB) methods. They proceed by breaking the problem into subproblems by the decomposition principle introduced by Lawler [11], and strengthened by Potts and Van Wassenhove [16], Szwarc [17] and Chang et al. [2]. At the same time, the dominance conditions derived by Emmons [6] are used extensively to curtail the solution space. The most effective algorithms are by Szwarc et al. [18] and by Tansel et al. [19] that can both solve instances with up to 500 jobs. Szwarc et al. considered several combinations of methods like adding lower bounds, using modified due date in the decomposition position rule, and controlling subproblem list by only storing subproblems n

Corresponding author. Tel.: þ86 21 64252308; fax: þ86 21 64252018. E-mail address: [email protected] (Z. Liu).

0305-0548/$ - see front matter & 2012 Elsevier Ltd. All rights reserved. http://dx.doi.org/10.1016/j.cor.2012.06.005

that need branching. They reported that SDD2 =di which only utilized the last method was the most efficient algorithm among other combinations for 500 job instances. Tansel et al. defined a so-called b-sequence in which the jobs are ordered in nondecreasing order of their modified due dates obtained through the use of Emmons’ conditions, and proved that the b-sequence is optimal under some conditions. Then, for each subproblem, the sequence can be fixed as the b-sequence if the corresponding conditions are fulfilled. The most well-known heuristic for TTP is by Wilkerson and Irwin [21], and then simplified by Baker and Bertrand [1], Lin [13], Panwalkar et al. [15]. Since the heuristic arranges the jobs one by one from time zero onwards using job pairwise interchanges, Yu [24] named it as Time Forward algorithm (TF). Naidu et al. [14] gave a sufficient condition under which TF is optimal. Yu [22] presented a heuristic, named by Time Backward algorithm (TB), which arranges the jobs one by one in the reverse order of time using job pairwise interchange rule. Note that Fadlalla et al. [7] also described another version of TB. Some meta-heuristics for TTP have also been proposed in these years. The recent one is by Cheng et al. [3] that incorporates some elimination rules into an ant colony optimization algorithm. However, as pointed out by Koulamas [9], meta-heuristics do not perform better than those algorithms based on the decomposition principle for TTP, and perhaps they are more suitable to scheduling problems with less structure. Especially, based on the decomposition principle, a fully polynomial time approximation scheme (FPTAS) for TTP has been presented by Lawler [12], and then its computational complexity was improved by Kovalyov [10]. See Koulamas [8,9] and Sen et al. [20] for other researches related to the single machine total tardiness problem. In this paper, we prove that if the job sequences produced by heuristics TF and TB have the same starting and ending job

S. Zhou, Z. Liu / Computers & Operations Research 40 (2013) 248–252

249

subsequences, then there exists an optimal job sequence with the starting and ending job subsequences. Also, we perform the computation experiments and show that there is a significant improvement of the running time of BB algorithms with the incorporation of the new property. The rest of the paper is organized as follows. Section 2 introduces the related work that stimulates our research. Section 3 deals with the property we propose. Section 4 presents a BB algorithm with the incorporation of the new property. The performance of the BB algorithm is evaluated in Section 5. Section 6 includes some concluding remarks.

Yu and Liu [25] proved that TF produces a locally optimal sequence with respect to the forward shifting neighborhood, which implies that no job in the sequence can be moved forward while keeping the other jobs unchangeable to generate a sequence with better performance. They also proved the worstcase performance ratio of TF is n=2, where the bound is tight. Given an instance I of TTP, let TT H ðIÞ represent the total tardiness generated by heuristic H and TT n ðIÞ denote the minimum total tardiness. Then, the worst-case performance ratio associated with heuristic H, is defined as supI fTT H ðIÞ=TT n ðIÞg, for all instances I.

2. Preliminaries

Step1 Step2 Step3

In this section we introduce some previous work that stimulates our research. 2.1. Consistent partial order A partial order on the job set N can be described by a subset Q of N2 ¼ fði,jÞ9i,j A Ng, where ði,jÞ A Q ðia jÞ means that job i precedes job j. Note that ði,iÞ A Q always holds from the reflexivity of partial order, and Q 0 ¼ fði,iÞ9iA Ng is called a null partial order. Q is called a consistent partial order (CPO) of TTP if there is an optimal sequence s such that s1 ðiÞ o s1 ðjÞ holds for any ði,jÞ A Q ði a jÞ, where s1 ðiÞ is defined as the position of job i in s, and s1 ðjÞ is the position of job j. Obviously, appending a strong CPO to N can reduce the computational burden when we solve TTP especially by branch and bound algorithms. Let CPO(N) stand for the collection of all consistent partial P orders on N. Given Q A CPOðNÞ, we define C  i ðQ Þ ¼ ðs,iÞ A Q ps and P þ C iþ ðQ Þ ¼ ði,sÞ=2Q ps þ pi for any job i A N. C  i ðQ Þ and C i ðQ Þ are called the earliest and the latest completion time of job i based on Q. P þ Note that C  i ðQ 0 Þ ¼ pi and C i ðQ 0 Þ ¼ k A N pk . Also, we define three 2 subsets of N as follows: ICðQ Þ ¼ fði,jÞ9ia j, pi rpj ,di r maxfdj ,C  j ðQ Þgg, BSðQ Þ ¼ fði,jÞ9ia j, dj Z min fC iþ ðQ Þ,max fdi ,C iþ ðQ Þpj gg, DCðQ Þ ¼ ICðQ Þ [ BSðQ Þ: Emmons [6] proved that if ði,jÞ A DCðQ Þ, then there exists an optimal sequence s for TTP with s1 ðiÞ o s1 ðjÞ. Assume that Q A CPOðNÞ, R DDCðQ Þ and fðj,iÞ9ði,jÞ A Rg \ Q ¼ |. Let Q  R be the partial order obtained from Q by adding the pairs in R and the pairs implied by transitivity. Q  R is called an augmented partial order from Q. Yu [23] proved that any augmented partial order obtained from the null partial order Q0 by a series of augmentations is a CPO, i.e., the following lemma holds. Lemma 1. Let Rk D DCðQ k Þ and Q k þ 1 ¼ Q k  Rk for k ¼ 0; 1,2, . . .. Then each Qk is a CPO. 2.2. Heuristics The heuristics TF and TB are as follows [1,13,22].

Time Backward Algorithm (TB).

Step 4

P Let t ¼ ni¼ 1 pi , k¼n, S ¼ N ¼ f1; 2, . . . ,ng. Let H ¼ fl9 dl þpl Z t, l A Sg. If H a |, set sðkÞ as the job with largest due date in H; if H ¼ |, set sðkÞ as the job with longest processing time in S. If k¼1, then output the sequence s and stop, else let t ¼ tpsðkÞ , S ¼ S\fsðkÞg, k ¼ k1 and return to Step 2.

Yu [22] proved that TB produces a locally optimal sequence with respect to the backward shifting neighborhood, and its worst-case performance ratio is 2n2 that is tight. Generally, TF performs better than TB. Since TF arranges the jobs from time zero onwards, TB arranges the jobs in the reverse order of time, and they both work according to the job pairwise interchange rule, we guess they are optimal when the resulting sequences are the same. We confirm the guess in the next section. In fact, we prove a stronger property that can be used in a BB algorithm.

3. A theoretical development Let s1 ¼ ab1 g and s2 ¼ ab2 g be the job sequences produced by TF and TB, respectively. That is to say, the first 9a9 jobs in s1 and s2 are the same, and so are the last 9g9 jobs. We will show that TTP has an optimal sequence of the form abg, where b is a permutation of the jobs in b1 (or equivalently in b2 ). Lemma 2. Assume that job i is processed before job j by both TF and TB, P P and Q A CPOðNÞ. If k: s1 ðkÞ o s1 ðiÞ pk r C  j ðQ Þpj and k: s1 ðkÞ o s1 ðjÞ 1 1 2 2 þ pk Z C i ðQ Þpj , then ði,jÞ A DCðQ Þ. Proof. Since i is processed before j by TF, we have 8 9 8 9 < = < = X X pk rmax pj ,dj  pk : max pi ,di  : ; : ; 1 1 1 1 k:s1 ðkÞ o s1 ðiÞ

If pi r pj , then 8 < di r max pj þ :

X 1 ðkÞ o 1

k:s

pk ,dj s

Step3

Let t¼ 0, k¼1, and S ¼ N ¼ f1; 2, . . . ,ng. Determine sðkÞ such that max fpsðkÞ ,dsðkÞ tg ¼ mini A S maxfpi ,di tg. If k ¼n, then output the sequence s and stop, else let t ¼ t þ psðkÞ , S ¼ S\fsðkÞg, k ¼ k þ 1 and return to Step 2.

1 ðiÞ 1

9 = ;

r maxfC  j ðQ Þ,dj g:

Thus, ði,jÞ A ICðQ Þ: If pi 4pj , then di r dj . And by TB 8 < X 1 H ¼ l 9 s1 2 ðlÞ r s2 ðjÞ, dl þ pl Z : 1

pk

k:s2 ðkÞ r s1 ðjÞ 2

Time Forward Algorithm (TF). Step1 Step2

k:, s1 ðkÞ o s1 ðiÞ

9 = ;

a|;

otherwise, job i should be processed on position s1 2 ðjÞ rather than job j since job i has a longer processing time. Then, j A H, and X pk ZC iþ ðQ Þpj : dj Z k:s1 ðkÞ o s1 ðjÞ 2 2

Thus, ði,jÞ A BSðQ Þ:

&

250

S. Zhou, Z. Liu / Computers & Operations Research 40 (2013) 248–252

Theorem 3. Let s1 ¼ ab1 g and s2 ¼ ab2 g be the job sequences produced by TF and TB, respectively. Then, TTP has an optimal sequence of the form abg. Proof. Suppose that either a a| or g a |. Let n1 ¼ 9a9 and n2 ¼ n9g9. We prove this theorem by making a series of CPO augmentations on N as follows: (i) initially, let Q ¼ Q 0 ; (ii) for j ¼ n,n1, . . . ,n2 þ 1 and i ¼ 1; 2, . . . ,j1, let Q ¼ Q  fðs1 ðiÞ, s1 ðjÞÞg; (iii) for i ¼ 1; 2, . . . ,n1 and j ¼ n2 ,n2 1, . . . ,i þ 1, let Q ¼ Q  fðs2 ðiÞ, s2 ðjÞÞg. According to Lemma 1, in order to guarantee that Q constructed above is a CPO, we only need to prove that ðs1 ðiÞ, s1 ðjÞÞ and ðs2 ðiÞ, s2 ðjÞÞ A DCðQ Þ when they are added to Q. We prove this by induction. The induction is divided into two phases. In Phase I, we prove the conclusion holds for those augmentations in (ii), i.e., there exists an optimal sequence ending with g. In Phase II, we further prove the conclusion for augmentations in (iii), i.e., the optimal sequence ending with g starts with a. Phase I. Let g a|. If g ¼ |, i.e., n2 ¼ n, we go to Phase II directly. P  Now we have s1 ðnÞ ¼ s2 ðnÞ. Since s1 ðkÞ o 1 pk ¼ 0, C s1 ðnÞ ðQ 0 Þ 1 ps1 ðnÞ ¼ 0, X X pk ¼ pk ps2 ðnÞ s1 ðkÞ o n 2

kAN

and C sþ1 ð1Þ ðQ 0 Þps1 ðnÞ ¼

X

pk ps1 ðnÞ ,

kAN

according to Lemma 2, we have ðs1 ð1Þ, s1 ðnÞÞ A DCðQ 0 Þ. Suppose that Q ¼ Q 0  fðs1 ðiÞ, s1 ðjÞÞ9j ¼ n,n1, . . . ,mþ 1,i ¼ 1; 2, . . . ,j1g fðs1 ðiÞ, s1 ðmÞÞ9i ¼ 1; 2, . . . ,lg, where n Zm Z n2 þ1 and 1 r l rm1 is a CPO. The induction proceeds by distinguishing three cases. Case1: 1 rl rm2. We need to show ðs1 ðl þ 1Þ, s1 ðmÞÞ A DCðQ Þ. Since fðs1 ðiÞ, s1 ðmÞÞ9i ¼ 1; 2, . . . ,lg DQ , we have C  s1 ðmÞ ðQ Þps1 ðmÞ Z P pk . Since fðs1 ðl þ 1Þ, s1 ðjÞÞ9j ¼ n,n1, . . . ,m þ 1g D Q , we s1 ðkÞ o l þ 1 1 have X X pk  pk C sþ1 ðl þ 1Þ ðQ Þps1 ðmÞ r kAN

¼

X kAN

pk 

X

s1 ðkÞ Z m 1

X

pk ¼

pk ,

s1 ðkÞ o m 2

s1 ðkÞ Z m 2

where the first equality holds because s1 ðiÞ ¼ s2 ðiÞ for i Z n2 þ 1. By Lemma 2, we get ðs1 ðl þ 1Þ, s1 ðmÞÞ A DCðQ Þ. Case2: n Zm Z n2 þ2 and l ¼ m1. We need to prove ðs1 ð1Þ, s1 ðm1ÞÞ A DCðQ Þ. Since fðs1 ð1Þ, s1 ðjÞÞ9j ¼ n,n1, . . . ,mg DQ , we have X X þ pk  pk C s1 ð1Þ ðQ Þps1 ðm1Þ r kAN

¼

X kAN

pk 

X

pk ¼

s1 ðkÞ Z m1 2

s1 ðkÞ Z m1 1

X

pk :

s1 ðkÞ o m1 2

P holds. Again by Also, C  s1 ðm1Þ ðQ Þps1 ðm1Þ Z s1 ðkÞ o 1 pk ¼ 0 1 Lemma 2, we have ðs1 ð1Þ, s1 ðm1ÞÞ A DCðQ Þ. Case3: m ¼ n2 þ 1 and l ¼ m1. The induction turns to Phase II immediately. Phase II. Let a a |. If a ¼ |, i.e., n1 ¼ 0, the induction has finished.

We first prove ðs2 ð1Þ, s2 ðn2 ÞÞ A DCðQ Þ. Since C  s2 ðn2 Þ ðQ Þps2 ðn2 Þ Z P pk ¼ 0 and s1 ðkÞ o 1 1 X X C sþ2 ð1Þ ðQ Þps2 ðn2 Þ r pk ps2 ðn2 Þ ¼ pk , k A ab2

s1 ðkÞ o n2 2

by Lemma 2, we have ðs2 ð1Þ, s2 ðn2 ÞÞ A DCðQ Þ. Suppose that Q ¼ Q 0  fðs1 ðiÞ, s1 ðjÞÞ9j ¼ n,n1, . . . ,n2 þ 1,i ¼ 1; 2, . . . ,j1g fðs2 ðiÞ, s2 ðjÞÞ9i ¼ 1; 2, . . . ,s1,j ¼ n2 ,n2 1, . . . ,i þ 1g fðs2 ðsÞ, s2 ðjÞÞ9j ¼ n2 ,n2 1, . . . ,tg, where 1 rs r n1 and n2 Z t Z s þ 1 is a CPO. The induction proceeds by distinguishing two cases. If n2 Zt Z s þ 2, we prove ðs2 ðsÞ, s2 ðt1ÞÞ A DCðQ Þ. If 1r s rn1 1 and t ¼ s þ1, we prove ðs2 ðs þ 1Þ, s2 ðn2 ÞÞ A DCðQ Þ. Since the argumentations are similar to those in Phase I, we omit details here. & Corollary 4. If the job sequences produced by TF and TB are the same, then they are optimal. 4. A branch and bound algorithm In this section, we present a depth-first BB algorithm, named BBFB, with the incorporation of the property proved in Section 3. BBFB first calls heuristics TF and TB to build two approximate schedules, and hence, by Theorem 3, the positions of some starting and ending jobs are fixed. Then BBFP uses Lawler’s principle to decompose the problem consisting of the other jobs into subproblems, each of which is solved recursively by our finding and Lawler’s principle. Let the jobs be numbered such that d1 r d2 r    r dn , and pi r pi þ 1 when di ¼ di þ 1 (1r i rn1). Let k ¼ maxfj9 pj ¼ max1 r i r n pi ,j A Ng. According to Lawler [11], TTP has an optimal schedule in which the jobs in f1; 2, . . . ,hg\fkg are scheduled in the first h1 positions, where kr hr n, job k is scheduled in position h, and the jobs in fh þ1,h þ2, . . . ,ng are scheduled in the last nh positions. Chang et al. [2] proved that the leftmost decomposition position h should satisfy: (i) Tðk,iÞ 4 Tðk,hÞ for each i ðkr i rh1Þ, (ii) Tðk,h þ1Þ ZTðk,hÞ, where Tðk,iÞ represents the total tardiness of the job sequence obtained from the sequence ð1; 2, . . . ,nÞ by shifting job k to position i. Thus, in BBFB, we restrict the decomposition position h to satisfy conditions (i) and (ii). Also, BBFB maintains a list of already solved subproblems (SP list). Then, when a subproblem is produced by the decomposition principle, BBFB first scans the SP list to check if the subproblem has been solved. If so, its solution is obtained immediately; otherwise, it is solved recursively. Once a subproblem has been solved, it can be stored in the SP list. Though quite memory-consuming, maintaining the SP list is an effective way to prevent solving the same subproblem twice, as shown by Szwarc et al. [18], who store the subproblems that need branching in SDD2 =di algorithm, and Tansel et al. [19] who store the most recent 1000 solved subproblems. We use a different method to maintain the SP list. A BB algorithm for TTP can be described by an enumeration tree, where an internal node is defined as a node includes one or two subproblems that require further decomposition. In BBFB, each time a subproblem is solved, we first calculate the number of internal descendant nodes of the subproblem (not including leaf descendants), and store the recent subproblems that have P or more than P internal descendant nodes. In our computational tests, P is set to 3, 4, 5, 7, 10, 15 for

S. Zhou, Z. Liu / Computers & Operations Research 40 (2013) 248–252

instances with 300, 400, 500, 600, 700, 800 jobs respectively, and the number of subproblems in the list SP is limited to 700,000 for a 2G memory computer. We employ the red-black tree as the inner structure of SP list for its logarithmic search and insertion efficiency (see [4]). Example. We use an instance from Tansel et al. [19] to illustrate the detailed steps of BBFB; the data are given in Table 1. First, applying algorithms TF and TB, we obtain two sequences ð5,1,7,8; 3,2; 4,6,9,10Þ and ð5,1,7,3; 4,2; 8,6,9,10Þ. Thus, the starting subsequence ð5; 1,7Þ and the ending subsequence ð6; 9,10Þ are fixed. For the remaining subproblem f8; 3,4; 2g, job 8 is the longest, and by the leftmost decomposition position rule, it can be put only in the first position. So, we only need to consider the subproblem f3; 4,2g. For this subproblem, algorithms TF and TB generate the same sequence ð3; 2,4Þ. Therefore, the optimal sequence ð5; 1,7; 8,3; 2,4; 6,9; 10Þ is obtained without more branching. 5. Computational results We performed the computational tests on a set of randomly generated instances with 300, 400, 500, 600, 700, 800 jobs, using the procedure in Potts and Van Wassenhove [16]. For each job j, an integer processing time pj was generated from the uniform distribution on ½1; 100, and an integer due date dj was generated from the uniform distribution on ½Pð1TðR=2ÞÞ,Pð1T þ ðR=2ÞÞ, where P is the sum of the processing times of all jobs, T is the tardiness factor, set at 0.2, 0.4, 0.6 and 0.8, and R is the range of due dates, set at 0.2, 0.4, 0.6, 0.8 and 1.0. Each due date is set to zero once its generated value is negative. For each combination of problem size n, and R and T, 50 instances were randomly generated. The computation time limit for each instance was 2 h. The algorithm was coded in Cþþ, and executed on a 2G CPU PC with 2G memory on Linux platform. The detailed computational results are given in Tables 2 and 3. We report not only the average CPU seconds (s) but also ‘‘Fixed Job Percentage’’, which is the average total number of jobs fixed by Theorem 3 in all subproblems divided by the total number of jobs that need consideration in all subproblems. In Example 1, 6þ3 Fixed Job Percentage is 10 þ 3 ¼ 69:2%. As shown in Table 2, BBFB can solve most of instances within 2 h limit. Even for the hardest combination (0.2,0.6) with n¼700, 66% of instances have been solved. In Table 3, we see that for some easier combinations such as (0.6,0.2), (0.8,0.2), (1.0,0.2) and (1.0,0.4), Fixed Job Percentage can be up to 100%, which means we can solve these instances by Theorem 3 without branching. For some harder combinations, we still have about 5% jobs fixed by Theorem 3. In order to further demonstrate the usefulness of the property in Theorem 3, we also made a comparison between BBFB and BB, that is Szwarc et al.’s algorithm SDD2 =di enriched with the new setting for SP list in Section 4. The algorithm SDD2 =di was claimed to be the most effective algorithm for instances with more than 300 jobs. We compare the average CPU second Tavg and the average number Navg of internal nodes of the enumeration trees of 50 instances for each combination of R and T. The comparison results for n¼ 500 are reported in Table 4. For n ¼ 600; 700,800,

Table 1 Example.

251

Table 2 Average CPU seconds for BBFB. R,T

n ¼300

n¼400

n¼500

n¼600

n¼ 700

n¼ 800

0.2,0.2 0.2,0.4 0.2,0.6 0.2,0.8 0.4,0.2 0.4,0.4 0.4,0.6 0.4,0.8 0.6,0.2 0.6,0.4 0.6,0.6 0.6,0.8 0.8,0.2 0.8,0.4 0.8,0.6 0.8,0.8 1.0,0.2 1.0,0.4 1.0,0.6 1.0,0.8

0.1 4.7 14.3 3.4 0.0 0.6 3.7 0.0 0.0 0.0 1.3 0.0 0.0 0.0 0.1 0.0 0.0 0.0 0.0 0.0

0.2 23.5 51.7 16.8 0.0 2.9 19.9 0.2 0.0 0.2 7.2 0.0 0.0 0.0 0.2 0.0 0.0 0.0 0.0 0.0

0.6 66.4 194.9 57.0 0.0 8.6 68.7 0.4 0.0 0.4 17.9 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.1 0.0

1.7 428.7 830.8b 226.4 0.0 30.1 236.2 0.8 0.0 1.1 64.2 0.0 0.0 0.0 1.7 0.0 0.0 0.0 0.3 0.0

3.6 520.9 3212.3c 363.0 0.0 52.4 385.2 1.0 0.0 1.9 111.1 0.1 0.0 0.0 3.9 0.0 0.0 0.0 2.0 0.0

7.9 1912.2a – 1030.6 0.0 136.4 941.5 2.4 0.0 4.1 273.3 0.2 0.0 0.0 6.4 0.1 0.0 0.0 3.9 0.0

a b c

39 instances are solved to optimality. 49 instances are solved to optimality. 33 instances are solved to optimality.

Table 3 Average fixed job percentage for BBFB. R,T

n ¼300

n ¼400

n¼500

n¼600

n¼700

n¼800

0.2,0.2 0.2,0.4 0.2,0.6 0.2,0.8 0.4,0.2 0.4,0.4 0.4,0.6 0.4,0.8 0.6,0.2 0.6,0.4 0.6,0.6 0.6,0.8 0.8,0.2 0.8,0.4 0.8,0.6 0.8,0.8 1.0,0.2 1.0,0.4 1.0,0.6 1.0,0.8

26.0 9.8 8.9 16.7 97.8 21.5 18.2 29.7 100.0 32.6 23.7 31.4 100.0 73.7 25.6 43.8 100.0 100.0 18.8 48.3

23.2 6.6 6.4 12.6 97.0 16.7 12.8 26.7 100.0 30.8 18.9 24.8 100.0 77.1 23.6 36.0 100.0 98.7 16.0 40.6

20.4 5.4 4.8 10.0 98.1 13.7 10.7 24.8 100.0 29.0 16.5 22.6 100.0 75.9 21.9 28.0 100.0 100.0 13.8 33.0

17.8 4.7 4.6b 8.3 98.0 11.1 9.6 24.2 100.0 27.9 15.6 22.8 100.0 78.0 21.9 28.4 100.0 100.0 12.5 31.9

17.8 4.6 5.0c 8.0 98.3 10.8 8.9 24.2 100.0 27.6 15.0 21.0 100.0 83.9 23.3 24.3 100.0 100.0 12.9 31.1

17.6 5.3a – 7.8 97.8 10.8 8.4 24.4 100.0 27.0 15.4 20.7 100.0 78.7 22.7 26.2 100.0 100.0 13.7 30.3

a b c

39 instances are solved to optimality. 49 instances are solved to optimality. 33 instances are solved to optimality.

it is difficult for BB to solve most instances of harder combinations in 2 h. We see that the proposed property can greatly reduce the number of nodes of enumeration tree, and hence, for most combinations, especially for those harder combinations, BBFB is faster than BB. For example, for the hardest combination (0.2,0.6), BBFB requires only about one-tenth of the time BB requires.

6. Conclusions

j

1

2

3

4

5

6

7

8

9

10

pj dj

10 135

29 284

43 271

44 272

57 117

63 336

66 155

73 195

77 322

82 186

The paper deals with the single machine total tardiness problem, and proves that if the job sequences produced by heuristics TF and TB have the same starting and ending job

252

S. Zhou, Z. Liu / Computers & Operations Research 40 (2013) 248–252

Table 4 Performance comparison of BB and BBFB for n¼ 500. R,T

BBFB

0.2,0.2 0.2,0.4 0.2,0.6 0.2,0.8 0.4,0.2 0.4,0.4 0.4,0.6 0.4,0.8 0.6,0.2 0.6,0.4 0.6,0.6 0.6,0.8 0.8,0.2 0.8,0.4 0.8,0.6 0.8,0.8 1.0,0.2 1.0,0.4 1.0,0.6 1.0,0.8 a

BB

Tavg

Navg

Tavg

Navg

0.6 66.4 194.9 57.0 0.0 8.6 68.7 0.4 0.0 0.4 17.9 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.1 0.0

45,474.8 1,001,384.2 1,820,197.5 649,802.4 0.5 214,186.5 799,951.5 15,688.5 0.0 23,027.7 391,200.9 277.2 0.0 14.3 31,531.7 136.0 0.0 0.0 956.4 74.2

0.5 127.0 1866.7 109.8 0.0 6.6 73.3 0.2 0.0 0.3 10.0 0.1 0.0 0.0 0.4 0.1 0.0 0.0 0.0 0.1

91,088.8 6,333,673.0 72,260,677.7a 3,868,385.9 5.1 497,776.4 2,747,196.5 27,587.7 1.0 47,361.5 644,164.4 3316.6 1.0 44.1 51,825.9 4677.6 1.0 1.0 1964.7 5045.2

48 instances are solved to optimality.

subsequences, then there exists an optimal sequence with the starting and ending subsequences. Then, a branch and bound algorithm BBFB which utilizes the property to speed up the solving process is presented. Extensive computational tests indicate that BBFB outperforms its predecessors in the literature, especially in dealing with hard instances, and can solve instances with up to 800 jobs.

Acknowledgments The authors are grateful to the anonymous referees and Prof. Steef van de Velde for their suggestions in improving the presentation of the paper. This research is supported by the National Natural Science Foundation of China under Grant number 11171106 and the Fundamental Research Funds for the Central Universities of China. References [1] Baker KR, Bertrand JWM. A dynamic priority rule for scheduling against due-dates. Journal of Operations Management 1982;3(1):37–42.

[2] Chang S, Lu Q, Tang G, Yu W. On decomposition of the total tardiness problem. Operations Research Letters 1995;17(5):221–9. [3] Cheng TCE, Lazarev AA, Gafarov ER. A hybrid algorithm for the single-machine total tardiness problem. Computers Operations Research 2009;36(2):308–15. [4] Cormen TH, Leiserson CE, Rivest RL, Stein C. Introduction to algorithms. The MIT Press; 2001 [Chapter 13]. [5] Du J, Leung JY-T. Minimizing total tardiness on one machine is NP-hard. Mathematics of Operations Research 1990;15(3):483–95. [6] Emmons H. One-machine sequencing to minimize certain functions of job tardiness. Operations Research 1969;17(4):701–15. [7] Fadlalla A, Evans JR, Lew MS. A Greedy Heuristic for the mean tardiness sequencing problem. Computers and Operations Research 1994;21(3): 329–36. [8] Koulamas C. The total tardiness problem: review and extensions. Operations Research 1994;42(6):1025–41. [9] Koulamas C. The single-machine total tardiness scheduling problem: review and extensions. European Journal of Operational Research 2010;202:1–7. [10] Kovalyov MY. Improving the complexities of approximation algorithms for optimization problems. Operations Research Letters 1995;17:85–7. [11] Lawler EL. A ‘‘pseudopolynomial’’ algorithm for sequencing jobs to minimize total tardiness. Annals of Discrete Mathematics 1977;1:331–42. [12] Lawler EL. A fully polynomial approximation scheme for the total tardiness problem. Operations Research Letters 1982;1:207–8. [13] Lin Y-X. One-machine sequencing problem for minimizing total tardiness (in Chinese). Acta Mathematicae Applicatae Sinica 1983;6(2):228–35. [14] Naidu JT, Gupta JND, Alidaee B. Insights into two solution procedures for the single machine tardiness problem. Journal of the Operational Research Society 2002;53(7):800–6. [15] Panwalkar SS, Smith ML, Koulamas CP. A heuristic for the single machine tardiness problem. European Journal of Operational Research 1993;70(3) 304–10. [16] Potts CN, Van Wassenhove LN. A decomposition algorithm for the single machine total tardiness problem. Operations Research Letters 1982;1(5): 177–82. [17] Szwarc W. Single machine total tardiness problem revisited. In: Ijiri Y, editor. Creative and innovative approaches to the science of management. Westport: Quorum Books; 1993. p. 407–19. [18] Szwarc W, Grosso A, Della Croce F. Algorithmic paradoxes of the singlemachine total tardiness problem. Journal of Scheduling 2001;4(2):93–104. [19] Tansel BC - , Kara BY, Sabuncuoglu I. An efficient algorithm for the single machine total tardiness problem. IIE Transactions 2001;33(8):661–74. [20] Sen T, Sulek JM, Dileepan P. Static scheduling research to minimize weighted and unweighted tardiness: a state-of-the-art survey. International Journal of Production Economics 2003;83:1–12. [21] Wilkerson LJ, Irwin JD. An improved algorithm for scheduling independent tasks. AIIE Transactions 1971;3:239–45. [22] Yu W. An approximation algorithm for the total tardiness problem and its analysis (in Chinese). Journal of East China Institute of Chemical Technology 1992;18:671–7. [23] Yu W. Augmentations of consistent partial orders for the one-machine total tardiness problem. Discrete Applied Mathematics 1996;68(1–2):189–202. [24] Yu W. The two-machine flow shop problem with delays and the one-machine total tardiness problem. PhD thesis. Technische Universiteit Eindhoven; 1996. [25] Yu W, Liu ZH. The performance ratio of the time forward algorithm for the total tardiness problem (in Chinese). OR Transactions 1997;1:89–96.