Two-Agent Single-Machine Scheduling of Jobs with Time-Dependent Processing Times and Ready Times

Abstract

Scheduling involving jobs with time-dependent processing times has recently attracted much research attention. However, multiagent scheduling with simultaneous considerations of jobs with time-dependent processing times and ready times is relatively unexplored. Inspired by this observation, we study a two-agent single-machine scheduling problem in which the jobs have both time-dependent processing times and ready times. We consider the model in which the actual processing time of a job of the first agent is a decreasing function of its scheduled position while the actual processing time of a job of the second agent is an increasing function of its scheduled position. In addition, each job has a different ready time. The objective is to minimize the total completion time of the jobs of the first agent with the restriction that no tardy job is allowed for the second agent. We propose a branch-and-bound and several genetic algorithms to obtain optimal and near-optimal solutions for the problem, respectively. We also conduct extensive computational results to test the proposed algorithms and examine the impacts of different problem parameters on their performance.

1. Introduction

In many scheduling models researchers assume that the job processing times are known and fixed parameters. However, the job processing times can be prolonged due to deterioration or shortened due to learning over time in real-life situations. Browne and Yechiali [1] present fire-fighting as an example of job deterioration while Biskup [2] cites workers’ skill improvement as an example of job learning. Both examples and their corresponding situations are referred to as “time-dependent scheduling” in the literature.

Time-dependent scheduling was first introduced by J. N. D. Gupta and S. K. Gupta [3] and Browne and Yechiali [1] for deterioration jobs, whereas by Biskup [2] for the learning effect. Since then, a lot of scheduling models involving job time-dependent processing times have been proposed from a variety of perspectives. For more detailed reviews of scheduling problems with deteriorating jobs, we refer the reader to Alidaee and Womer [4] and Cheng et al. [5], and for a detailed review of scheduling problems with learning effects, we refer the reader to Biskup [6]. More recently, scheduling research that considers both deteriorating jobs and learning effects has become popular. For details on this stream of scheduling research, the reader may refer to Wang [7], Wang and Cheng [8, 9], Wang and Liu [10], Wang and Guo [11], Zhang and Yan [12], Yang [13], and Zhu et al. [14], among others.

In the past, the scheduling literature was dominated by studies that deal with a single criterion. In reality, jobs might come from several agents (customers) that have different requirements to meet. However, scheduling research in the multiple-agent setting involving jobs with time-dependent processing times is relatively unexplored. Among the few studies on this topic, Liu and Tang [15] studied multiagent scheduling with deteriorating jobs in which they assumed that the actual processing time of job 𝐽_𝑗 is 𝛿_𝑗𝑡, where 𝛿_𝑗>0 and 𝑡 denote the deteriorating rate and starting time of 𝐽_𝑗, respectively. Liu et al. [16] considered two two-agent problems with position-dependent processing times. In the aging-effect model, they assumed that the actual processing time of 𝐽_𝑗 is 𝑝_𝑗+𝑏𝑟 (𝑝_𝑗+𝑏𝑣) if it belongs to agent 𝐴(𝐵). Meanwhile, in the learning-effect model, they assumed that the actual processing time of 𝐽_𝑗 is 𝑝_𝑗−𝑏𝑟 (𝑝_𝑗−𝑏𝑣) if it belongs to agent 𝐴(𝐵), where 𝑟 (or 𝑣) denotes the job position and 𝑏,𝑏>0, is the aging or learning effect. Cheng et al. [17] considered a two-agent scheduling problem in which they assumed that, given a schedule, the actual processing time of a job of the first agent is a function of position-based learning while the actual processing time of a job of the second agent is a function of position-based deterioration. The objective is to minimize the total weighted completion time of the jobs of the first agent with the restriction that no tardy job is allowed for the second agent. Wu et al. [18] studied two-agent scheduling in which the actual processing time of 𝐽_𝑗 is 𝑝_𝑗(1+∑^𝑟−1_𝑙=1𝑝_[𝑙])^𝑎 (𝑝_𝑗(1+∑^𝑟−1_𝑙=1𝑝_[𝑙])^𝛽) if it is a job of AG₀ (AG₁) scheduled in the 𝑟th position of a sequence. Their objective function is to find an optimal schedule to minimize ∑^𝑛_𝑗=1𝑤_𝑗𝐶_𝑗(𝑆)(1−𝐼_𝑗), subject to max_{1≤𝑗≤𝑛}{𝐿_𝑗(𝑆)𝐼_𝑗}≤0. They proposed branch-and-bound and ant colony algorithms to solve the problem. However, they ignored job ready times. Wu et al. [19] considered a single-machine problem with the sum-of-processing time based learning effect and release times, where the objective is to minimize the total weighted completion time. They assumed that the actual processing time of job 𝑗 is 𝑝_𝑗𝑟=𝑝_𝑗(1−∑^𝑟−1_𝑙=1𝑝_[𝑙]/∑^𝑛_𝑙=1𝑝_𝑙)^𝑎 if it is scheduled in the 𝑟th position, where 𝑎≥1 is a learning ratio common to all the jobs. They proposed a branch-and-bound algorithm and a genetic heuristic-based algorithm to treat the problem. Wu et al. [18] used a branch-and-bound and a ant colony algorithm to solve a two-agent scheduling with learning and deteriorating jobs. Lun et al. [20] and Zhang et al. [21] gave applications of multiagent scheduling of jobs with ready times in the shipping industry. Specifically, ships belonging to shipping companies (multiple agents) call at a port at different times. The port needs to find a suitable schedule to serve the ships. In this context, the port is the single machine and the arriving ships from different shipping companies are jobs belonging to different agents with ready times. Inspired by this and other applications, we study in this paper a two-agent single-machine scheduling problem in which the jobs have both time-dependent processing times and ready times. We consider the model in which the actual processing time of a job of the first agent is a decreasing function of its scheduled position while the actual processing time of a job of the second agent is an increasing function of its scheduled position. The objective is to minimize the total completion time of the jobs of the first agent with the restriction that no tardy job is allowed for the second agent.

The remainder of this paper is organized as follows. We present the problem formulation in the next section. In Section 3 we discuss the computational complexity of the problem. In Section 4 we develop some dominance properties and a lower bound to enhance the search efficiency for the optimal solution, followed by introducing a branch-and-bound and several genetic algorithms. In Section 5 we present the results of computational experiments conducted to assess the performance of the proposed algorithms. We conclude the paper and suggest some topics for future research in the last section.

2. Model Formulation

We formulate the scheduling problem under study as follows. There are 𝑛 jobs for processing on a single machine. Each job 𝐽_𝑗 becomes available for processing at time 𝑟_𝑗≥0. Each job belongs to one of two agents, namely, AG₀ and AG₁. For job 𝐽_𝑗, there is a normal processing time 𝑝_𝑗 and an agent code 𝐼_𝑗, where 𝐼_𝑗=0 if 𝐽_𝑗∈AG₀ and 𝐼_𝑗=1 if 𝐽_𝑗∈AG₁. We assume that all the jobs of AG₀ have a position-based learning rate 𝑎 with 𝑎≤0, while all the jobs of AG₁ have a position-based deteriorating rate 𝑏 with 𝑏≥0. Under the proposed model, the actual processing time of 𝐽_𝑗 is 𝑝_𝑗𝑟^𝑎 (𝑝_𝑗𝑟^𝑏) if it belongs to AG₀ (AG₁) and is scheduled in position 𝑟 of a sequence.

For a given schedule 𝑆, let 𝐶_𝑗(𝑆) be the completion time of 𝐽_𝑗, and 𝑈_𝑗(𝑆)=1 if 𝐶_𝑗(𝑆)>𝑑_𝑗 and zero otherwise. The objective is to find an optimal schedule to minimize ∑^𝑛_𝑗=1𝐶_𝑗(𝑆)(1−𝐼_𝑗), subject to ∑^𝑛_𝑗=1𝑈_𝑗(𝑆)𝐼_𝑗=0. Adopting the three-field notation scheme 𝛼|𝛽|𝛾^𝐴∶𝛾^𝐵 introduced by Agnetis et al. [22], we denote the problem as 1|𝑟_𝑗,𝑝_𝑗𝑟=𝑝_𝑗𝑟^𝑥,𝑥∈{𝑎,𝑏}|∑^𝑛_𝑗=1𝐶_𝑗(𝑆)(1−𝐼_𝑗)∶∑^𝑛_𝑗=1𝑈_𝑗(𝑆)𝐼_𝑗=0.

As for the major results of research on multiagent scheduling without learning effects or deteriorating jobs, the reader may refer to Baker and Smith [23], Agnetis et al. [22], Yuan et al. [24], Cheng et al. [25, 26], Ng et al. [27], Agnetis et al. [28], Mor and Mosheiov [29, 30], Yin et al. [31, 32], and so forth.

3. Branch-and-Bound Algorithm

Due to the fact that our proposed problem is an NP-hard one (see [33]), in this section we apply the branch-and-bound technique to search for the optimal solution. In order to facilitate the searching process, we first develop some dominance properties, followed by presenting a lower bound to fathom the searching tree. We then present the procedures of branch-and-bound algorithm and suggest some heuristics.

3.1. Dominance Rules

Assume that schedule 𝑆 has two adjacent jobs 𝐽_𝑖 and 𝐽_𝑗 with 𝐽_𝑖 immediately preceding 𝐽_𝑗. Perform a pairwise interchange of 𝐽_𝑖 and 𝐽_𝑗 to derive a new sequence 𝑆^′. In addition, assume that 𝐽_𝑖 and 𝐽_𝑗 are in the 𝑟th and (𝑟+1)th positions of 𝑆 and that the starting time to process job 𝐽_𝑖 in 𝑆 is 𝑡.

Lemma 1. If 𝐽_𝑖,𝐽_𝑗∈𝐴𝐺₀,𝑟_𝑗≥max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑎, then 𝑆 dominates 𝑆^′.

Proof. The completion times of jobs 𝐽_𝑖 and 𝐽_𝑗 in 𝑆 and 𝑆^′ are, respectively, 𝐶_𝑖(𝑆)=max𝑟_𝑖,𝑡+𝑝_𝑖𝑟^𝑎,𝐶_𝑗(𝑆)=maxmax𝑟_𝑖,𝑡+𝑝_𝑖𝑟^𝑎,𝑟_𝑗+𝑝_𝑗(𝑟+1)^𝑎,𝐶_𝑗𝑆^′=max𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑎,𝐶_𝑖𝑆^′=maxmax𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑎,𝑟_𝑖+𝑝_𝑖(𝑟+1)^𝑎, (1)
From 𝑟_𝑗≥max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑎, we have 𝐶_𝑖𝑆^′>𝐶_𝑗𝑆^′=max𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑎>𝑟_𝑗+𝑝_𝑗(𝑟+1)^𝑎=𝐶_𝑗(𝑆)>𝐶_𝑖(𝑆). (2) It follows that 𝐶_𝑖(𝑆^′)+𝐶_𝑗(𝑆^′)>𝐶_𝑗(𝑆)+𝐶_𝑖(𝑆), so 𝑆 dominates 𝑆^′.

Lemma 2. If 𝐽_𝑖,𝐽_𝑗∈𝐴𝐺₀, max{𝑟_𝑖,𝑡}≤𝑟_𝑗<max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑎 and 𝑝_𝑖<𝑝_𝑗, then 𝑆 dominates 𝑆^′.

Proof. By the assumption and Lemma 1, the completion times of jobs 𝐽_𝑖 and 𝐽_𝑗 in 𝑆 and 𝑆^′ can be reformulated as 𝐶_𝑖(𝑆)=max𝑟_𝑖,𝑡+𝑝_𝑖𝑟^𝑎,𝐶_𝑗(𝑆)=max𝑟_𝑖,𝑡+𝑝_𝑖𝑟^𝑎+𝑝_𝑗(𝑟+1)^𝑎,𝐶_𝑗𝑆^′=max𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑎,𝐶_𝑖𝑆^′=max𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑎+𝑝_𝑖(𝑟+1)^𝑎, (3) respectively. From max{𝑟_𝑖,𝑡}≤𝑟_𝑗 and 𝑝_𝑖<𝑝_𝑗, it is easy to see that 𝐶_𝑖(𝑆^′)>𝐶_𝑗(𝑆) and 𝐶_𝑗(𝑆^′)>𝐶_𝑖(𝑆). It follows that 𝑆 dominates 𝑆^′.

Lemma 3. If 𝐽_𝑖,𝐽_𝑗∈𝐴𝐺₀, max{𝑟_𝑗,𝑡}≤𝑟_𝑖<max{𝑟_𝑗,𝑡}+𝑝_𝑗𝑟^𝑎, and (𝑝_𝑗−𝑝_𝑖)(𝑟^𝑎−(𝑟+1)^𝑎)≥𝑟_𝑖−max{𝑟_𝑗,𝑡}, then 𝑆 dominates 𝑆^′.

Proof. The proof is similar to that of Lemma 2.

Lemma 4. If 𝐽_𝑖,𝐽_𝑗∈𝐴𝐺₀, max{𝑟_𝑖,𝑟_𝑗}≤𝑡, and 𝑝_𝑖<𝑝_𝑗, then 𝑆 dominates 𝑆^′.

Proof. The proof is similar to that of Lemma 2.

Lemma 5. If 𝐽_𝑖,𝐽_𝑗∈𝐴𝐺₁,max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑏≤𝑑_𝑖<max{max{𝑟_𝑗,𝑡}+𝑝_𝑗𝑟^𝑏,𝑟_𝑖}+𝑝_𝑖(𝑟+1)^𝑏, and max{max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑏,𝑟_𝑗}+𝑝_𝑗(𝑟+1)^𝑏≤𝑑_𝑗, then 𝑆 dominates 𝑆^′.

Proof. The completion times of jobs 𝐽_𝑖 and 𝐽_𝑗 in 𝑆 and 𝑆^′ are, respectively, 𝐶_𝑖(𝑆)=max𝑟_𝑖,𝑡+𝑝_𝑖𝑟^𝑏,𝐶_𝑗(𝑆)=maxmax𝑟_𝑖,𝑡+𝑝_𝑖𝑟^𝑏,𝑟_𝑗+𝑝_𝑗(𝑟+1)^𝑏,𝐶_𝑗𝑆^′=max𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑏,𝐶_𝑖𝑆^′=maxmax𝑟_𝑗,𝑡+𝑝_𝑗𝑟^𝑏,𝑟_𝑖+𝑝_𝑖(𝑟+1)^𝑏. (4)
The given conditions lead to 𝐶_𝑖(𝑆)≤𝑑_𝑖<𝐶_𝑖(𝑆^′) and 𝐶_𝑗(𝑆)≤𝑑_𝑗, implying that schedule 𝑆^′ is infeasible. Hence, 𝑆 dominates 𝑆^′.

Lemma 6. If 𝐽_𝑖,𝐽_𝑗∈𝐴𝐺₁ and max{max{𝑟_𝑗,𝑡}+𝑝_𝑗𝑟^𝑏,𝑟_𝑖}+𝑝_𝑖(𝑟+1)^𝑏<max{max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑏,𝑟_𝑗}+𝑝_𝑗(𝑟+1)^𝑏≤min{𝑑_𝑖,𝑑_𝑗}, then 𝑆 dominates 𝑆^′.

Proof. The given condition implies that 𝑈_𝑖(𝑆^′)+𝑈_𝑗(𝑆^′)=𝑈_𝑖(𝑆)+𝑈_𝑗(𝑆)=0 and 𝐶_𝑖(𝑆^′)>𝐶_𝑗(𝑆), so 𝑆 dominates 𝑆^′.

The proofs of Lemmas 7 to 9 are omitted since they are similar to those of Lemmas 1 and 2.

Lemma 7. If 𝐽_𝑖∈𝐴𝐺₀,𝐽_𝑗∈𝐴𝐺₁,𝑟_𝑖<max{𝑟_𝑗,𝑡}+𝑝_𝑗𝑟^𝑏, and max{max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑎,𝑟_𝑗}+𝑝_𝑗(𝑟+1)^𝑏≤min{max{𝑟_𝑗,𝑡}+𝑝_𝑗𝑟^𝑏+𝑝_𝑖(𝑟+1)^𝑎,𝑑_𝑗}, then 𝑆 dominates 𝑆^′.

Lemma 8. If 𝐽_𝑖∈𝐴𝐺₁,𝐽_𝑗∈𝐴𝐺₀ and max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑏≤𝑑_𝑖<max{max{𝑟_𝑗,𝑡}+𝑝_𝑗𝑟^𝑎,𝑟_𝑖}+𝑝_𝑖(𝑟+1)^𝑏, then 𝑆 dominates 𝑆^′.

Lemma 9. If 𝐽_𝑖∈𝐴𝐺₁,𝐽_𝑗∈𝐴𝐺₀ and max{𝑟_𝑖,𝑡}+𝑝_𝑖𝑟^𝑏≤min{𝑑_𝑖,𝑟_𝑗}, then 𝑆 dominates 𝑆^′.

Next, we present two lemmas to determine the feasibility of a partial sequence. Let (𝜋,𝜋^′) be a sequence of jobs where 𝜋 is the scheduled part with 𝑘 jobs and 𝜋^′ is the unscheduled part. Moreover, let 𝐶_[𝑘] be the completion time of the last job in 𝜋.

Lemma 10. If there is a job 𝐽_𝑗∈𝐴𝐺₁∩𝜋^′ such that max{𝐶_[𝑘],𝑟_𝑗}+𝑝_𝑗(𝑘+1)^𝑏>𝑑_𝑗, then sequence (𝜋,𝜋^′) is not a feasible solution.

Lemma 11. If all the unscheduled jobs belong to 𝐴𝐺₀ and there exists a job 𝐽_𝑗∈𝜋^′ such that max{𝐶_[𝑘],𝑟_𝑗}+𝑝_𝑗(𝑘+1)^𝑎≤𝑟_𝑘 for all job 𝐽_𝑘∈𝜋^′⧵{𝐽_𝑗}, then job 𝐽_𝑗 may be assigned to the (𝑘+1)th position.

Lemma 12. If all the unscheduled jobs belong to 𝐴𝐺₀ and max{𝑟_𝑗}_{𝐽𝑗∈𝜋′}≤𝑡, then the shortest processing time (SPT) rule gives an optimal sequence for the remaining unscheduled jobs.

3.2. A Lower Bound for 1|𝑟_𝑗,𝑝^𝐴_𝑗𝑟=𝑝^𝐴_𝑗𝑟^𝑎,𝑝^𝐵_𝑗𝑟=𝑝^𝐵_𝑗𝑟^𝑏|∑𝐶^𝐴_𝑗∶∑𝑈^𝐵_𝑗≤0

The efficiency of the branch-and-bound algorithm depends greatly on the lower bounds for the partial sequences. In this subsection we propose a lower bound. Let PS be a partial schedule in which the order of the first 𝑘 jobs is determined and US be the unscheduled part with (𝑛−𝑘) jobs, where there are 𝑛₀ jobs belonging to AG₀ and 𝑛₁ jobs belonging to AG₁ with 𝑛₀+𝑛₁=𝑛−𝑘. Moreover, let 𝑝_[𝑗],𝑟_[𝑗], and 𝐶_[𝑗] denote the normal processing time, release time, and completion time of the 𝑗th job in a sequence, respectively, where 𝑗={1,2,…,𝑛}. A lower bound for the partial sequence PS is obtained by scheduling the jobs belonging to AG₀ first in the SPT order and then scheduling the jobs belonging to AG₁ in any order. Then the completion time of the (𝑘+1)th job is 𝐶_[𝑘+1]=max𝑟_[𝑘+1],𝐶_[𝑘]+𝑝_[𝑘+1](𝑘+1)^𝑎≥𝐶_[𝑘]+𝑝_[𝑘+1]𝑛^𝑎. (5)

Similarly, the completion time for the (𝑘+2)th job is 𝐶_[𝑘+1]=max𝑟_[𝑘+2],𝐶_[𝑘+1]+𝑝_[𝑘+2](𝑘+2)^𝑎≥𝐶_[𝑘+1]+𝑝_[𝑘+2]𝑛^𝑎. (6)

Continuing in this fashion, the completion time of the (𝑘+𝑙)th job is 𝐶_[𝑘+𝑙]=max𝑟_[𝑘+𝑙],𝐶_{[𝑘+𝑙−1]}+𝑝_[𝑘+𝑙](𝑘+𝑙)^𝑎≥𝐶_{[𝑘+𝑙−1]}+𝑝_[𝑘+𝑙]𝑛^𝑎. (7)

Based on the above analysis, a lower bound for partial sequence PS can be calculated as follows.

Algorithm 13. Step  1. Sort the jobs of AG₀ in nondecreasing order of their processing times, that is, 𝑝₍₁₎≤𝑝₍₂₎≤⋯≤𝑝_(𝑛0).
Step  2. Calculate 𝐶_[𝑘+𝑙]=𝐶_[𝑘]+𝑛^𝑎∑^𝑙_𝑗=1𝑝_[𝑘+𝑗] for 1≤𝑙≤𝑛₁.

Therefore, a lower bound for the partial sequence PS is LB₁=_𝑗∈PS𝐶_[𝑗]1−𝐼_𝑗+^𝑛1_𝑙=1𝐶_[𝑘+𝑙]. (8)

However, this lower bound may not be tight if the release times are large. To overcome this situation, we propose a second lower bound by taking account of the ready times. By definition, the completion time of the (𝑘+1)th job is 𝐶_[𝑘+1]=max𝑟_[𝑘+1],𝐶_[𝑘]+𝑝_[𝑘+1](𝑘+1)^𝑎≥𝑟_[𝑘+1]+𝑝_[𝑘+1]𝑛^𝑎. (9)

Similarly, the completion time for the (𝑘+2)th job is 𝐶_[𝑘+1]=max𝑟_[𝑘+2],𝐶_[𝑘+1]+𝑝_[𝑘+2](𝑘+2)^𝑎≥𝑟_[𝑘+2]+𝑝_[𝑘+2]𝑛^𝑎. (10)

Continuing in this fashion, the completion time of the (𝑘+𝑙)th job is 𝐶_[𝑘+𝑙]=max𝑟_[𝑘+𝑙],𝐶_{[𝑘+𝑙−1]}+𝑝_[𝑘+𝑙](𝑘+𝑙)^𝑎≥𝑟_[𝑘+𝑙]+𝑝_[𝑘+𝑙]𝑛^𝑎. (11)

Based on the above analysis, another lower bound for the partial sequence PS can be calculated as follows: LB₂=_𝑗∈PS𝐶_[𝑗]1−𝐼_𝑗+^𝑛1_𝑙=1𝑟^𝐴_[]𝑘+𝑙+𝑝^𝐴_[]𝑘+𝑙𝑛^𝑎. (12)

In order to make the lower bound tighter, we choose the maximum value between (8) and (12) as the lower bound for PS. That is, LB=maxLB₁,LB₂. (13)

3.3. Genetic Algorithms

Genetic algorithm (GA) is a meta-heuristic method that is commonly used to tackle combinatorial optimization problems [34]. A genetic algorithm starts with a set of feasible solutions (population) and iteratively replaces the current population by a new population. It requires a suitable encoding for the problem and a fitness function measures the quality of each encoded solution (chromosome or individual). The reproduction mechanism selects the parents and recombines them using a crossover operator to generate offspring that are submitted to a mutation operator in order to alter them locally [35]. The main steps of the GA are summarized in the following.

3.3.1. Representation of Structure

In this paper we adopt a structure as a sequence of the jobs of the problem based on the method by Etiler et al. [36].

3.3.2. Initial Population

To get the final solution more quickly, we construct the initial population by using three heuristics [37]. We propose the use of three initial sequences. We generate the first initial sequence by arranging the jobs of AG₁ in the earliest due date (EDD) order, followed by arranging the jobs of AG₀ in the smallest SPT order (recorded as GA₁), followed by arranging the jobs of AG₀ in the earliest ready times (ERT) first order (recorded as GA₂), and followed by arranging the jobs of AG₀ in the EDD order (recorded as GA₃).

3.3.3. Population Size

Following Chen et al. [38], we use an initial population as one schedule and create other members by applying interchange mutation until the number of members is equal to the population size. We set the population size (say, 𝑁) equal to the number of jobs (i.e., 𝑁=𝑛) based on preliminary tests.

3.3.4. Fitness Function

Given that the objective of the problem is to minimize the total completion time, we define the fitness function of the strings as follows: 𝑓𝑆_𝑖(𝑣)=max_{1≤𝑙≤𝑁}^𝑛_𝑗=1𝐶_𝑗𝑆_𝑙(𝑣)−^𝑛_𝑗=1𝐶_𝑗𝑆_𝑖(𝑣), (14) where 𝑆_𝑖(𝑣) is the 𝑖th string chromosome in the 𝑣th generation, ∑^𝑛_𝑗=1𝐶_𝑗(𝑆_𝑖(𝑣)) is the total completion time of 𝑆_𝑖(𝑣), and 𝑓(𝑆_𝑖(𝑣)) is the fitness function of 𝑆_𝑖(𝑣). Therefore, the probability of selection of a schedule 𝑃(𝑆_𝑖(𝑣)) is to ensure that the probability of selection of a sequence with a lower value of the objective function is higher, which is defined as follows: 𝑃𝑆_𝑖(𝑣)=𝑓𝑆_𝑖(𝑣)∑^𝑁_𝑙=1𝑓𝑆_𝑙(𝑣). (15)

3.3.5. Crossover

Crossover is used to generate a new offspring from two parents. We adopt the partially matched crossover method, which is commonly used in GA [36]. In order to preserve the best schedule that has the minimum total completion time in each generation, we keep it to the next population with no change. This operation enables us to choose a higher crossover with the crossover rate 𝑃_𝑐=1.

3.3.6. Mutation

Mutation is used to prevent premature falling into a local optimal in the GA procedure. It can be considered as a transition from a current solution to its neighbourhood solution in a local search algorithm. In this study we set the mutation rate 𝑃_𝑚 at 1.0 based on preliminary experiments.

3.3.7. Selection

In this paper we fix the population sizes at 𝑛 from generation to generation. Excluding the best schedule that has the minimum total completion time, the rest of the offspring are generated from the parent chromosomes by the roulette wheel method.

3.3.8. Stopping Rule

We end the procedure of the GA after 10∗𝑛 generations based on preliminary experiments.

4. Computational Results

We carried out computational experiments to assess the performance of proposed branch-and-bound and genetic algorithms over a range of problem parameters. We coded all the algorithms in FORTRAN using Compaq Visual Fortran version 6.6 and conducted the experiments on a personal computer powered by an Intel Pentium(R) Dual-Core CPU E6300 @ 2.80 GHz with 2 GB RAM operating under Windows XP. We generated the job processing times from a uniform distribution 𝑈(1,100). Following the design of Reeves [37], we generated the ready times of the jobs from another uniform distribution 𝑈(0,20𝑛𝜆), where 𝑛 is the number of jobs and 𝜆 is a control parameter. In our tests we set the value of 𝜆 at 1/𝑛, 0.25, 0.5, 0.75, and 1. In addition, following the design of Fisher [39], we generated the due dates of the jobs of AG₁ from a uniform distribution 𝑇×𝑈(1−𝜏−𝑅/2,1+𝜏+𝑅/2), where 𝑇 is the sum of the normal processing times of the 𝑛 jobs; that is, 𝑇=∑^𝑛_𝑖=1𝑝_𝑖, 𝜏 took the values 0.25 and 0.5, while 𝑅 took the values 0.25, 0.5, and 0.75. We fixed the proportion of the jobs of agent AG₁ at pro=0.5 in the experiments.

For the branch-and-bound algorithm, we recorded the average and maximum numbers of nodes, as well as the average (mean) and maximum of the execution times (in seconds). For the proposed GA algorithms, we recorded the mean and maximum percentage errors. We calculate the percentage error of a solution produced by a heuristic algorithm as 𝑉−𝑉^∗𝑉^∗×100%, (16) where 𝑉 and 𝑉^∗ are the total completion time of the heuristic and the optimal solution of the jobs of the first agent, respectively. We did not record the computational times of the GA algorithms because they all were less one second to obtain a solution.

We carried out the computational experiments in two parts. For the first part of the experiments, we tested instances of the problem at 𝑛=14 and 16. Moreover, we took three different values of the learning effect 70%, 80%, and 90% (corresponding to 𝛼=−0.515,−0.322,and−0.152, resp.) and three different values of the deteriorating effect 70%, 80%, and 90% (corresponding to 𝛽 = 0.515, 0.322, and 0.152, resp.). We randomly tested a set of 100 instances for each case. As a result, we examined 54,000 instances. The instances with numbers of nodes few than 10⁸ were recorded as instance solved or IS. We further extracted the relative results to report in the following.

As regards the performance of the branch-and-bound algorithm, we see from Figures 1, 2, 3, 4, 5, and 6 that the number of nodes declines as the value of 𝜆, 𝜏, or 𝑅 increases no matter whether 𝑛=14 or 16. The reason is due to the fact that our proposed dominance rules and lower bound are more effective at a bigger value of 𝜆, 𝜏, or 𝑅.

Figure 1 

The behavior of 𝜆 at 𝑛=14.

Figure 2 

The behavior of 𝜆 at 𝑛=16.

Figure 3 

The behavior of 𝜏 at 𝑛=14.

Figure 4 

The behavior of 𝜏 at 𝑛=16.

Figure 5 

The behavior of 𝑅 at 𝑛=14.

Figure 6 

The behavior of 𝑅 at 𝑛=16.

We observe from Figures 7 and 8 the performance trend of the learning effect. As shown in Figures 9 and 10, the instances with larger deteriorating values are easier to solve than those with smaller deteriorating values.

Figure 7 

The behavior of 𝑎 at 𝑛=14.

Figure 8 

The behavior of 𝑎 at 𝑛=16.

Figure 9 

The behavior of 𝛽 at 𝑛=14.

Figure 10 

The behavior of 𝛽 at 𝑛=16.

We also see that the branch-and-bound algorithm generates more nodes for instances with a bigger value of 𝜆, 𝜏, or 𝑅. This also implies that the number of IS at a bigger value of 𝜆, 𝜏, or 𝑅 is higher than that at a smaller value (i.e., see Figures 11 and 12).

Figure 11 

The behavior of IS as 𝜆 changes at 𝑛=14.

Figure 12 

The behavior of IS as 𝜆 changes at 𝑛=16.

Moreover, Figures 13 and 14 show that the instances with a weaker learning effect are easier to solve than those with a stronger learning effect, whereas Figures 15 and 16 show that the deteriorating effect keeps the same trend of IS. The performance of the branch-and-bound algorithm in terms of CPU time over the range of problem parameters tested is similar to that in terms of number of nodes generated.

Figure 13 

The behavior of IS as 𝑎 changes at 𝑛=14.

Figure 14 

The behavior of IS as 𝑎 changes at 𝑛=16.

Figure 15 

The behavior of IS as 𝛽 changes at 𝑛=14.

Figure 16 

The behavior of IS as 𝛽 changes at 𝑛=16.

For the performance of the GA heuristics, Figures 17, 18, and 19 show that when 𝑛=14, the mean percentage errors of GA₁, GA₂, and GA₃ are within the ranges 4.3%–4.7%, 3.7%–4.1%, and 3.75%–3.95%, respectively, regardless of value of 𝜆. Since all the GAs only take less than a second of CPU time to obtain a solution, we further take min{GA_𝑖,𝑖=1,2,3} as GA^∗.

Figure 17 

The behavior of GA1 as 𝜆 varies.

Figure 18 

The behavior of GA2 as 𝜆 varies.

Figure 19 

The behavior of GA3 as 𝜆 varies.

We observe from Figure 20 that the mean percentage error of GA* declines to within the range 2.3%–2.7%. When 𝑛=14, Figures 21, 22, 23, and 24 show that at a bigger value of 𝜏 (𝜏=0.5), GA₁, GA₂, GA₃, and GA* yield smaller percentage errors than at a smaller value of 𝜏 (𝜏=0.25); however, Figures 25, 26, 27, and 28 show that at a smaller value of 𝑅, GA₁, GA₂, GA₃, and GA* yield smaller percentage errors than at a bigger value of 𝑅.

Figure 20 

The behavior of GA* as 𝜆 varies.

Figure 21 

The behavior of GA1 as 𝜏 varies.

Figure 22 

The behavior of GA2 as 𝜏 varies.

Figure 23 

The behavior of GA3 as 𝜏 varies.

Figure 24 

The behavior of GA* as 𝜏 varies.

Figure 25 

The behavior of GA1 as 𝑅 varies.

Figure 26 

The behavior of GA2 as 𝑅 varies.

Figure 27 

The behavior of GA3 as 𝑅 varies.

Figure 28 

The behavior of GA* as 𝑅 varies.

As regards the impacts of learning or deteriorating on the proposed GAs, Figures 29, 30, 31, and 32 show that all the GAs perform better at a weaker learning effect than a stronger one, but the performance reverses under the deteriorating effect as shown in Figures 33, 34, 35, and 36.

Figure 29 

The behavior of GA1 as 𝑎 varies.

Figure 30 

The behavior of GA2 as 𝑎 varies.

Figure 31 

The behavior of GA3 as 𝑎 varies.

Figure 32 

The behavior of GA* as 𝑎 varies.

Figure 33 

The behavior of GA1 as 𝛽 varies.

Figure 34 

The behavior of GA2 as 𝛽 varies.

Figure 35 

The behavior of GA3 as 𝛽 varies.

Figure 36 

The behavior of GA* as 𝛽 varies.

Overall, we observe from Figures 37 and 38 that the grand means of the mean error percentages of GA₂ and GA₃ are smaller than those of GA₁ when 𝑛=12 and 16, respectively.

Figure 37 

The behavior of GAs at 𝑛=14.

Figure 38 

The behavior of GAs at 𝑛=16.

The result also shows that GA* performs well and keeps about 3% of the grand means of the mean error percentages, which is clearly lower than those of GA₁, GA₂, and GA₃.

In the second part of the experiments, we further assessed the performance of the proposed GA algorithms in solving instances with large numbers of jobs. We set 𝑛 at 30 and 40 and fixed the parameters as follows: 𝜏 took the values of 0.25 and 0.5, while 𝑅 took the values of 0.25, 0.50, and 0.75. We fixed the proportion of the jobs of agent AG₁ at pro=0.5 in the experiments. We set the learning effect at 70%, 80%, and 90% (corresponding to 𝛼 = −0.515, −0.322, and −0.152, resp.) and the values of the deteriorating effect at 70%, 80%, and 90% (corresponding to 𝛽 = 0.515, 0.322, and 0.152, resp.). We randomly generated a set of 100 instances for each situation. As a result, we examined 270 experimental situations. For each GA heuristic, we calculate its relative percentage deviation as RPD=GA_𝑖−GA^∗GA^∗×100%, (17) where GA_𝑖 is the objective function value generated by the GA heuristic and GA^∗=min{GA_𝑖,𝑖=1,2,3} is the GA heuristic that yields the smallest objective function value among the three GA algorithms. We recorded the average and maximum RPD, and the mean execution time for each heuristic. The results are summarized in the following figures.

As shown in Figures 39, 40, and 41, we observe that the RPD mean of GA₁ is in general smaller than those of GA₂ and GA₃. The effects of 𝑎,𝛽,𝑅, and 𝜏 are similar to those with smaller numbers of jobs.

Figure 39 

The behavior of GA1 as 𝜆 varies.

Figure 40 

The behavior of GA2 as 𝜆 varies.

Figure 41 

The behavior of GA3 as 𝜆 varies.

Overall, we observe from Figures 42 and 43 that the grand mean of the RPD of GA₁ is smaller than that of GA₂ and GA₃. The result also shows that GA₂ and GA₃ slightly outperform GA₁ with smaller numbers of jobs, but the result is reversed with larger numbers of jobs. This implies that there is no absolute dominance relationship among three GAs. Thus, we recommend that the GA* be used in order to attain stability and good quality solutions.

Figure 42 

The behavior of GAs at 𝑛=30.

Figure 43 

The behavior of GAs at 𝑛=40.

5. Conclusions

In this paper we study a two-agent single-machine scheduling problem with simultaneous considerations of deteriorating jobs, learning effects, and ready times. To search for optimal and near-optimal solutions, we propose a branch-and-bound algorithm incorporated with some dominance rules and a lower bound and three genetic algorithms, respectively.

The computational results show that our proposed branch-and-bound algorithm can solve instances with up to 16 jobs with reasonable numbers of nodes and execution times. In addition, the computational experiments reveal that the proposed GA* does well in terms of efficiency and solution quality. Future research may consider other scheduling criteria or study the problem in the multimachine setting.

Acknowledgments

The authors would like to thank the Editor and three anonymous referees for their helpful comments on an earlier version of the paper.