A Two-Agent Single-Machine Scheduling Problem with Learning and Deteriorating Considerations

Abstract

Recently, interest in scheduling with deteriorating jobs and learning effects has kept growing. However, research in this area has seldom considered the multiagent setting. Motivated by these observations, we consider two-agent scheduling on a single machine involving the learning effects and deteriorating jobs simultaneously. In the proposed model, we assume that the actual processing time of a job of the first (second) agent is a decreasing (increasing) function of the total processing time of the jobs already processed in a schedule. 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. We develop a branch-and-bound and a simulated annealing algorithms for the problem. We perform extensive computational experiments to test the performance of the algorithms.

1. Introduction

In classical scheduling, researchers routinely assume that the job processing time is known and fixed from the processing of the first job to the completion of the last job. This assumption is invalid in situations where the job processing time may be prolonged due to deterioration or shortened due to learning over time. For example, Browne and Yechiali [1] observed that the time and effort required to put out a fire increase if there is a delay in the starting of the fire-fighting effort. In such environments, a job that is processed later consumes more time than the same job when processed earlier. Scheduling in this setting is known as “scheduling deteriorating jobs.” Meanwhile, Biskup [2] points out that the repeated processing of similar tasks improves the workers’ skills; for example, workers are able to perform setups, deal with machine operations or software, or handle raw materials and components at a faster pace. This phenomenon is known as the “learning effect” in the literature.

The deteriorating job scheduling problem was first introduced by J. N. D. Gupta and S. K. Gupta [3] and Browne and Yechiali [1], independently. J. N. D. Gupta and S. K. Gupta [3] considered the problem using the polynomial processing time functions to minimize the makespan and propose branch-and-bound and heuristic algorithms to search for the optimal and near-optimal solutions. Browne and Yechiali [1] studied the problem using the exponential job processing times to minimize the makespan and provide insights into problem solutions. Since then, an abundance of studies of the subject have emerged. For different models of the problem dealing with different criteria, we refer readers to Alidaee and Womer [4] and Cheng et al. [5].

On the other hand, Biskup [2] and Cheng and Wang [6], independently, incorporate the concept of learning into scheduling. Many researchers have since devoted large amounts of effort to this relatively young but booming area of scheduling research. For detailed reviews of motivations, results, and applications of scheduling with learning effects, we refer the reader to a comprehensive review of scheduling research with learning considerations by Biskup [7].

Recently, there is a growing interest in scheduling research that considers deteriorating jobs and learning effects simultaneously. Wang [8] assumes that the job processing times has the following form: 𝑝_𝑗[𝑟]=(𝛼_𝑗+𝛽𝑡)𝑟^𝑎, where 𝑝_𝑗[𝑟] is the actual processing time of a job 𝐽_𝑗 scheduled in the 𝑟th position of a sequence, 𝛼_𝑗 is the basic processing time, and 𝛽 is the common deteriorating rate. Wang [9] studies a model in which the job processing time has the following form: 𝑝_𝑗[𝑟]=𝑝_𝑗(𝛼(𝑡)+𝛽𝑟^𝑎), where 𝑝_𝑗 is the basic processing time and 𝛼(𝑡) is an increasing deterioration function with 𝛼(0)≥0. Wang and Cheng [10] consider a model in which the actual processing time is (𝑝₀+𝛼_𝑗𝑡)𝑟^𝑎, where 𝑝₀ is the common basic processing time, 𝛼_𝑗 is the growth rate, and 𝑎 is the learning index. Cheng et al. [11, 12] study a new scheduling model with deteriorating jobs and learning effects in which the actual processing time of a job 𝐽_𝑗 scheduled in the 𝑟th position of a sequence is modeled as 𝑝_𝑗[𝑟]=𝑝_𝑗((𝑝₀+∑^𝑟−1_𝑙=1𝑝_[𝑙])/(𝑝₀+∑^𝑛_𝑙=1𝑝_𝑙))^𝑎1𝑟^𝑎2, where 𝑝_[𝑙] denotes the normal processing time of the job scheduled in the𝑙th position of the sequence, 𝑝₀>0 is a given parameter, and 𝑎₁ and 𝑎₂ denote the deteriorating and learning indices with 𝑎₁<0 and 𝑎₂<0. Toksari et al. [13] consider several scheduling problems under the assumption of the nonlinear effects of learning and deterioration, where they assume that 𝑝_𝑗[𝑟]=(𝑝_[𝑟]+𝛼𝑡^𝑏_[𝑟])(1+∑^𝑟−1_𝑘=1𝑝_[𝑘])^𝑎, 𝑎<0, 𝛼>0, 𝑏>0, where 𝑡_[𝑟]>0 is the starting time of the job scheduled in position 𝑟. Huang et al. [14] consider the single-machine scheduling problem with time-dependent deterioration and an exponential learning effect, that is, the actual processing time of a job depends not only on the processing times of the jobs already processed but also on its scheduled position. Cheng [15] modeled that the actual processing time of 𝐽_𝑗 is defined as 𝑝_𝑗max{(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝑎,𝛽} if it is scheduled in the 𝑟th position in a schedule, where 𝑎≥1 and 0 < 𝛽 < 1. Li and Hsu [16] modeled that the real processing time 𝑝^𝑋_𝑖𝑟 of job 𝐽^𝑋_𝑖 varies with position 𝑟 based on the learning effect, that is 𝑝^𝑋_𝑖𝑟=𝑝^𝑋_𝑖𝑟^𝑎, where 𝑎 is the learning ratio with 𝑎<0 and 𝑟=1,2,…,𝑛.

In classical scheduling, it is assumed that there is a single customer (i.e., agent) who seeks to minimize a scheduling criterion that is function of the order in which the customer’s orders (i.e., jobs) are processed by the available processing resources (i.e., machines). In many management situations, however, multiple agents compete on the usage of common processing resources. For instance, Agnetis et al. [17] observe that multiple agents compete on the usage of a common processing resource in different application environments and different methodological fields, such as artificial intelligence, decision theory, and operations research. One major stream of research in this context is related to multiagent scheduling, in which different agents interact to perform their respective tasks, negotiating among one another for the usage of the common resources over time. For research on multiagent scheduling without learning or deteriorating jobs or both, the reader may refer to Baker and Smith [18], Agnetis et al. [19], Yuan et al. [20], Cheng et al. [21], Ng et al. [22], Agnetis et al. [17], Cheng et al. [11, 12], Yin et al. [23], Cheng et al. [24], and so forth. Scheduling in the multiagent setting provides the first motivation for this paper.

Another motivation is that research on multiagent scheduling with deteriorating jobs or learning effects is relatively limited. Liu and Tang’s study [25] is probably the only scheduling study that considers deteriorating jobs and multiple agents. They assume that the actual processing time of 𝐽_𝑗 is 𝛿_𝑗𝑡, where 𝛿_𝑗>0 denotes the deterioration rate and 𝑡 is the job’s starting time. Under the proposed model, they consider the scheduling objectives of minimizing the makespan, maximum lateness, maximum cost, and total completion time. In this paper, we assume that the actual processing time of a job of the first agent is a decreasing function of the total processing time of the jobs already processed in a schedule, while the actual processing time of a job of the second agent is an increasing function of the total processing time of the jobs already processed in a schedule. 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.

The remainder of this paper is organized as follows. In Section 2, we present some dominant properties and develop a lower bound to speed up the search for the optimal solution, followed by discussions of branch-and-bound and simulated annealing (SA) algorithm Section 3. We present the results of extensive computational experiments to assess the performance of all of the proposed algorithms under different experimental conditions in Section 4. We conclude the paper and suggest topics for further research in the Section 5.

2. Problem Statement

We formulate the problem under study in the following. There are 𝑛 jobs ready to be processed on a single machine. Each job belongs to one of the two agents, namely, 𝐴𝐺₀ and 𝐴𝐺₁. Associated with job 𝐽_𝑗, there is a normal processing time 𝑝_𝑗, a weight 𝑤_𝑗, a due date 𝑑_𝑗, and an agent code 𝐼_𝑗, where 𝐼_𝑗=0 if 𝐽_𝑗∈𝐴𝐺₀, or 𝐼_𝑗=1 if 𝐽_𝑗∈𝐴𝐺₁. We assume that all the jobs of 𝐴𝐺₀ have a learning rate 𝛼 with 𝛼>1, while all the jobs of 𝐴𝐺₁ have a deteriorating rate 𝛽 with 𝛽<0. Under the proposed model, the actual processing time of 𝐽_𝑗 is 𝑝_𝑗(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝑎 (𝑝_𝑗(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽) if it is a job of 𝐴𝐺₀ (𝐴𝐺₁) scheduled in the 𝑟th position of a sequence, where the subscript [𝑙] denotes the job in the 𝑙th position of a sequence. For a given schedule 𝑆, let 𝐶_𝑗(𝑆) be the completion time of 𝐽_𝑗 and let 𝐿_𝑗(𝑆)=𝐶_𝑗(𝑆)−𝑑_𝑗 be the lateness of 𝐽_𝑗. The objective of the scheduling problem is to find an optimal schedule to minimize ∑^𝑛_𝑗=1𝑤_𝑗𝐶_𝑗(𝑆)(1−𝐼_𝑗) subject to max_{1≤𝑗≤𝑛}{𝐿_𝑗(𝑆)𝐼_𝑗)}≤0. Since the objective function and constraint involve regular scheduling criteria, we use the terms schedule and sequence interchangeably.

3. Branch-and-Bound and Simulated Annealing Algorithms

Ng et al. [22] show that our problem without learning or deteriorating consideration is strongly NP-hard. So, we apply branch-and-bound and SA algorithms to search for the optimal and near-optimal solutions, respectively, in this paper. In order to speed up the searching process, we first develop three adjacent pairwise interchange properties, followed by two dominant rules. We then present the procedures of the branch-and-bound and SA algorithms.

3.1. Dominant Properties

Assume that the schedule (sequence) 𝑆₁ has two adjacent jobs 𝐽_𝑖 and 𝐽_𝑗 with 𝐽_𝑖 immediately preceding 𝐽_𝑗 and that 𝐽_𝑖 and 𝐽_𝑗 are in the 𝑟th and the (𝑟+1)th positions of 𝑆₁, respectively. Perform a pairwise interchange of 𝐽_𝑖 and 𝐽_𝑗 to derive a new sequence 𝑆₂.

Proposition 1. For any two jobs 𝐽_𝑖 and 𝐽_𝑗∈𝐴𝐺₀ to be scheduled consecutively, if 𝑝_𝑗/𝑝_𝑖≥𝑤_𝑗/𝑤_𝑖>1, then 𝑆₁ dominates 𝑆₂.

Proof. Assume that 𝑆₁=(𝜋,𝐽_𝑖,𝐽_𝑗,𝜋^′) and 𝑆₂=(𝜋,𝐽_𝑗,𝐽_𝑖,𝜋^′) denote two sequences in which 𝜋 and 𝜋^′ denote partial sequences. To show that 𝑆₁ dominates 𝑆₂, it suffices to show that [𝑤_𝑖𝐶_𝑖(𝑆₁)+𝑤_𝑗𝐶_𝑗(𝑆₁)]≤[𝑤_𝑗𝐶_𝑗(𝑆₂)+𝑤_𝑖𝐶_𝑖(𝑆₂)] and 𝐶_𝑗(𝑆₁)<𝐶_𝑖(𝑆₂). In addition, let 𝐴be the completion time of the last job in the subsequence 𝜋 with (𝑟−1) jobs. Since 𝐽_𝑖 and 𝐽_𝑗∈𝐴𝐺₀, the completion time of the jobs 𝐽_𝑖 and 𝐽_𝑗 in sequences 𝑆₁ and 𝑆₂ is given by the following: 𝐶_𝑖𝑆₁=𝐴+𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎,𝐶_𝑗𝑆₁=𝐴+𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎+𝑝_𝑗∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]+𝑝_𝑖∑𝑝_𝑖^𝑎,𝐶_𝑗𝑆₂=𝐴+𝑝_𝑗∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎. (1) One also has 𝐶_𝑖𝑆₂=𝐴+𝑝_𝑗∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎+𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]+𝑝_𝑗∑𝑝_𝑖^𝑎. (2) Taking the difference between 𝑆₁ and 𝑆₂, we obtain the following: 𝑤_𝑗𝐶_𝑗𝑆₂+𝑤_𝑖𝐶_𝑖𝑆₂−𝑤_𝑖𝐶_𝑖𝑆₁+𝑤_𝑗𝐶_𝑗𝑆₁=𝑤_𝑖𝑝_𝑗−𝑤_𝑗𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎+𝑤_𝑗𝑝_𝑗∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎−∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]+𝑝_𝑖∑𝑝_𝑖^𝑎−𝑤_𝑖𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎−∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]+𝑝_𝑗∑𝑝_𝑖^𝑎. (3) By substituting 𝜃=(𝑝_𝑗/𝑤_𝑗)/(𝑝_𝑖/𝑤_𝑖), 𝑐=𝑤_𝑗/𝑤_𝑖, and 𝑥=𝑝_𝑖/(∑𝑝_𝑖−∑^𝑟−1_𝑙=1𝑝_[𝑙]), we simplify (3) as follows: 𝑤_𝑗𝐶_𝑗𝑆₂+𝑤_𝑖𝐶_𝑖𝑆₂−𝑤_𝑖𝐶_𝑖𝑆₁+𝑤_𝑗𝐶_𝑗𝑆₁=𝑤_𝑗𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑𝑝_𝑖^𝑎×(𝜃−1)+𝑐𝜃1−(1−𝑥)^𝑎−1𝑐1−(1−𝑐𝜃𝑥)^𝑎, (4) where 𝑐≥1, 𝜃≥1, 𝑎>1, and 0<𝑥<1. Taking the first and second derivatives of (4), we can see that (4) is nonnegative. Hence, we have 𝑤_𝑗𝐶_𝑗𝑆₂+𝑤_𝑖𝐶_𝑖𝑆₂≥𝑤_𝑖𝐶_𝑖𝑆₁+𝑤_𝑗𝐶_𝑗𝑆₁. (5) On the other hand, taking the difference between (1) and (2), we have 𝐶_𝑖𝑆₂−𝐶_𝑗𝑆₁=𝑝_𝑗−𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎+𝑝_𝑖∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]+𝑝_𝑗∑^𝑛_𝑙=1𝑝_𝑙^𝑎−𝑝_𝑗∑1−^{𝑟−1𝑙=1}𝑝_[𝑙]+𝑝_𝑖∑^𝑛_𝑙=1𝑝_𝑙^𝑎. (6) By substituting 𝜃=𝑝_𝑗/𝑝_𝑖, 𝑢=(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙))), and 𝑥=(𝑝_𝑖/∑^𝑛_𝑙=1𝑝_𝑙) into (6), we have 𝐶_𝑖𝑆₂−𝐶_𝑗𝑆₁=𝑝_𝑖𝑢^𝑎(𝜃−1)+(1−𝜃𝑥)^𝑎−𝜃(1−𝑥)^𝑎. (7) Taking the first and second derivatives of (7), and noting that 𝜃>1, 𝑎>1, and 0<𝑥<1, we have 𝐶_𝑖(𝑆₂)−𝐶_𝑗(𝑆₁)>0. Therefore, 𝑆₁ dominates 𝑆₂.

Proposition 2. For any two jobs 𝐽_𝑖 and 𝐽_𝑗∈𝐴𝐺₁ to be scheduled consecutively, if 𝑝_𝑖<𝑝_𝑗, 𝐴+𝑝_𝑖(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽+𝑝_𝑗(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙]+𝑝_𝑖)/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽<𝑑_𝑗, and
𝐴+𝑝_𝑖(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽<𝑑_𝑖, then 𝑆₁ dominates 𝑆₂.

Proposition 3. For job 𝐽_𝑖∈𝐴𝐺₁ and job 𝐽_𝑗∈𝐴𝐺₀ to be scheduled consecutively, if 𝐴+𝑝_𝑖(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽<𝑑_𝑖 and 𝑝_𝑖<𝑝_𝑗[(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝑎−(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙]+𝑝_𝑖)/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝑎]/(1−((∑^𝑟−1_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽, then 𝑆₁ dominates 𝑆₂.

We omit the proofs of Propositions 2 and 3 because they are similar to that of Proposition 1.

We next present two propositions 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 𝜋.

Proposition 4. If there is a job 𝐽_𝑗∈𝐴𝐺₁∩𝜋^𝑐 such that 𝐶_[𝑘]>𝑑_𝑗, then sequence (𝜋,𝜋^𝑐) is not a feasible solution.

Proof. If there is a job 𝐽_𝑗∈𝐴𝐺₁∩𝜋^𝑐 such that 𝐶_[𝑘]>𝑑_𝑗, this violates the constraint that no tardy job is allowed for the second agent.

Proposition 5. If there is a job 𝐽_𝑗∈𝐴𝐺₁∩𝜋^𝑐 such that 𝐶_[𝑘]+𝑝_𝑗(1−((∑^𝑘_𝑙=1𝑝_[𝑙])/(∑^𝑛_𝑙=1𝑝_𝑙)))^𝛽>𝑑_𝑗, then sequence (𝜋,𝜋^𝑐) is not a feasible solution.

Proof. Similar to Proposition 4.

3.2. Lower Bound

In this subsection, we develop a lower bound for the proposed branch-and-bound algorithm. Suppose that PS is a partial schedule in which the order of the first 𝑘 jobs is determined, and, 𝑈𝑆 be the unscheduled part with (𝑛−𝑘) jobs, where there are 𝑛₀ jobs of 𝐴𝐺₀ and 𝑛₁ jobs of 𝐴𝐺₁ with 𝑛₀+𝑛₁ = 𝑛−𝑘. Moreover, let 𝑝_(𝑘+1)≤𝑝_(𝑘+2)≤⋯≤𝑝_(𝑛) denote the normal processing time of the (𝑛−𝑘) unscheduled jobs when arranged in nondecreasing order, and let 𝐶_[𝑘] be the completion time of the last job in 𝑃𝑆. Given that the learning effect can shorten the processing time and that the deteriorating effect can lengthen the processing time, we assign the jobs with the learning effect to the first 𝑛₀ positions and the jobs with the deteriorating effect to the following 𝑛₁ positions of the remaining (𝑛−𝑘) unscheduled positions after the 𝑘th position which contributes in the reduction the total weighted completion time of the jobs of the first agent. The completion time of the (𝑘+1)th job is 𝐶_[𝑘+1]=𝐶_[𝑘]+𝑝_[𝑘+1]∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎𝐼_{[𝑘+1]}+∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝛽1−𝐼_{[𝑘+1]}≥𝐶_[𝑘]+𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎. (8) Similarly, the completion time of the (𝑘+𝑗)th job is 𝐶_[𝑘+𝑗]≥𝐶_[𝑘]+𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎+^𝑗_𝑖=2𝑝_(𝑘+𝑖)∑1−^𝑘𝑙=1𝑝_[𝑙]+∑^𝑗_𝑙=2𝑝_{(𝑛−𝑙+2)}∑^𝑛_𝑙=1𝑝_𝑙^𝑎,2≤𝑗≤𝑛₀. (9) Next, we deriequence by arranging the jobs ofe the completion time of the jobs with the deteriorating effect assigned to the remaining 𝑛₁ positions. The completion time of the (𝑘+𝑛₀+𝑗)th job is 𝐶_{[𝑘+𝑛0+𝑗]}≥𝐶_[𝑘+𝑛0]+^𝑗_𝑖=1𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]+∑^𝑗−1_𝑙=1𝑝_(𝑘+𝑙)∑^𝑛_𝑙=1𝑝_𝑙^𝛽,for1≤𝑗≤𝑛₁. (10) Note that ∑⁰_𝑙=1𝑝_(𝑘+𝑙)=0 and 𝐶_[𝑘+𝑛0]≥𝐶_[𝑘]+𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎+^𝑛0_𝑖=2𝑝_(𝑘+𝑖)∑1−^𝑘𝑙=1𝑝_[𝑙]+∑^𝑗_𝑙=2𝑝_{(𝑛−𝑙+2)}∑^𝑛_𝑙=1𝑝_𝑙^𝑎. (11) Following the same idea of Cheng et al. [26] and Wu et al. [27], we want to assign the job completion time to the jobs of agents 𝐴𝐺₀ and 𝐴𝐺₁. Given the constraint that the jobs of agent 𝐴𝐺₁ cannot be tardy, we assign the completion time to the jobs of agent 𝐴𝐺₁ as late as possible. The procedure is as follows.

3.2.1. Algorithm

Step 1. Set 𝐶_[𝑘+1]=𝐶_[𝑘]+𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎𝐶,for𝑗=1,_[𝑘+𝑗]=𝐶_[𝑘]+𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]∑^𝑛_𝑙=1𝑝_𝑙^𝑎+^𝑗_𝑖=2𝑝_(𝑘+𝑖)∑1−^𝑘𝑙=1𝑝_[𝑙]+∑^𝑗_𝑙=2𝑝_{(𝑛−𝑙+2)}∑^𝑛_𝑙=1𝑝_𝑙^𝑎,for2≤𝑗≤𝑛₀,𝐶_{[𝑘+𝑛0+𝑗]}=𝐶_[𝑘+𝑛0]+^𝑗_𝑖=1𝑝_(𝑘+1)∑1−^𝑘𝑙=1𝑝_[𝑙]+∑^𝑗−1_𝑙=1𝑝_(𝑘+𝑙)∑^𝑛_𝑙=1𝑝_𝑙^𝛽,for1≤𝑗≤𝑛₁. (12)

Step 2. Sort the jobs of agent 𝐴𝐺₀ in a nondecreasing order of their weights and the jobs of agent 𝐴𝐺₁ in a nondecreasing order of their due dates, that is, 𝑤⁰₍₁₎≤𝑤⁰₍₂₎≤⋯≤𝑤⁰_𝑛0,𝑑¹₍₁₎≤𝑑¹₍₂₎≤⋯≤𝑑¹_𝑛1. (13)

Step 3. Set 𝑖𝑐=𝑛, 𝑖𝑎=𝑛₀, and 𝑖𝑏=𝑛₁.

Step 4. If 𝑖𝑐≤𝑛−𝑘, go to Step 7.

Step 5. If 𝐶_[𝑖𝑐]≤𝑑¹_(𝑖𝑏), set 𝐶¹_(𝑖𝑏)=𝐶_[𝑖𝑐] and 𝑖𝑏=𝑖𝑏−1. Otherwise, set 𝐶⁰_(𝑖𝑎)=𝐶_[𝑖𝑐] and 𝑖𝑎=𝑖𝑎−1.

Step 6. Set 𝑖𝑐=𝑖𝑐−1, and go to Step 4.

Step 7. Compute 𝐿𝐵_𝑈𝑆=∑^𝑛0_𝑗=1𝑤⁰_{(𝑛0−𝑗+1)}𝐶⁰_(𝑗). Evidently, a lower bound for the partial sequence 𝑃𝑆 is 𝐿𝐵=_{𝑗∈𝑃𝑆}𝑤_[𝑗]𝐶_[𝑗]1−𝐼_𝑗+𝐿𝐵_𝑈𝑆. (14)

3.3. Simulated Annealing Algorithms

Simulated annealing is one of the most popular metaheuristic methods widely applied to solve combinatorial optimization problems [28–30]. SA has the advantage of avoiding getting trapped in a local optimum because of its hill climbing moves, which are governed by a control parameter. In the following, we apply SA to derive near-optimal solutions for our problem. We apply an SA algorithm with three different initials as follows.

Step 1. Initial sequence.
We use three initial sequences for the three SA algorithms. In SA₁, we use random numbers to generate an initial job sequence; if there is any tardy job in this sequence, we regenerate another job sequence until it is feasible. In SA₂, we create an initial job sequence by arranging the jobs of 𝐴𝐺₁ in the earliest due date (EDD) order, followed by arranging the jobs of 𝐴𝐺₀ in the shortest processing time (SPT) order. In SA₃, we create an initial job sequence by arranging the jobs of 𝐴𝐺₁ in the EDD order, followed by arranging the jobs of 𝐴𝐺₀ in the weighted shortest processing time (WSPT) order. In order to get a good initial solution, we apply the NEH method [31] to the initial sequences produced by SA₂ and SA₃.

Step 2. Neighborhood generation.
Neighborhood generation plays an important role in the efficiency of SA algorithms. We use the pairwise interchange (PI) neighborhood generation method in the algorithms.

Step 3. Acceptance probability.
When a new feasible sequence is generated, it is accepted if its objective value is smaller than that of the original sequence; otherwise, it is accepted with a probability that decreases as the process evolves. The probability of acceptance is generated from an exponential distribution as follows: 𝑃accept=exp−𝜌×Δ𝑊𝑇𝐶, (15) where 𝜌 is a control parameter and Δ𝑊𝑇𝐶 is the change in the objective value. In addition, we use the method suggested by Ben-Arieh and Maimon [32] to change 𝜌 in the 𝑘th iteration as follows: 𝑘𝜌=𝛿, (16) where 𝛿 is an experimental constant. After preliminary trials, we used 𝛿=0.8 in our experiments.
If the total weighted completion time increases as a result of a random pairwise interchange, the new sequence is accepted when 𝑃(accept)>𝑟, where 𝑟 is randomly sampled from the uniform distribution 𝑈(0,1).

Step 4. Stopping condition.
Our preliminary trials indicate that the quality of the schedule is stable after 200𝑛 iterations, where 𝑛 is the number of jobs.

3.4. Details of the Branch-and-Bound Algorithm

We use the depth-first search in the branching procedure and assign jobs in a forward manner starting with the first position. In the searching tree, we adopt a branch and systematically work down the tree until we either eliminate it by virtue of the dominant properties and the lower bounds or reach its final node, in which case this sequence either replaces the initial solution or is eliminated. We summarize the main steps in the following.

3.4.1. The Branch-and-Bound Algorithm

Step 1. Apply the best solution obtained from the three proposed simulated annealing algorithms as the initial solution for the branch-and-bound algorithm.

Step 2. Use the dominant rules 1–5 to eliminate the dominated partial sequences.

Step 3. Compute the lower bound of the total weighted completion time of the first agent for the unscheduled partial sequences or the total weighted completion time of the first agent for the completed sequences. If the lower bound for an unscheduled partial sequence is greater than that of the initial solution, eliminate that node and all the nodes beyond it in the branch. If the value of the completed sequence is less than that of the initial solution, replace it as the new solution. Otherwise, eliminate it.

Step 4. Repeat Steps 2 and 3 until all the branches are explored.

4. Computational Experiments

We conducted extensive computational experiments to evaluate the efficiency of the branch-and-bound algorithm and the performance of the three simulated annealing algorithms. We coded all the algorithms in Fortran using the Compaq Visual Fortran version 6.6 and performed the experiments on a personal computer powered by an Intel Core2 Quad CPU 2.66 GHz with 4 GB of RAM and operating under Windows XP. The job processing times was generated from a uniform distribution over the integers 1–100. The weights of the jobs from the first agent were generated from another uniform distribution over the integers 1–100. In addition, the due date 𝑑_𝑘 of 𝐽_𝑘 of 𝐴𝐺₁ was generated from a uniform distribution over the integers between 𝑇(1−𝜏−𝑅/2) and 𝑇(1−𝜏+𝑅/2), where 𝑇 is the total normal processing time of the 𝑛 jobs, that is, 𝑇=∑^𝑛_𝑖=1𝑝_𝑖 as proposed by Fisher [33]. 𝜏 took the values 0.4, 0.5, and 0.6, while 𝑅 took the values 0.4, 0.5, and 0.6. We fixed the proportions of the jobs of agent 𝐴𝐺₁ at pro = 0.4 and 0.6 in the tests.

For the branch-and-bound algorithm, we recorded the average and standard deviation of the number of nodes as well as the average and standard deviation of the execution time (in seconds). For the SA heuristics, we recorded the mean and standard deviation percentage errors. We calculate the percentage error of a solution produced by a heuristic algorithm as follows: 𝑉−𝑉^∗𝑉^∗, (17) where 𝑉 and 𝑉^∗ are the total weighted completion time of the heuristic and the optimal solutions, respectively. We did not record the computational time of the heuristic algorithms because for all of the algorithms it was less than a second CPU time in generating solutions.

We conducted the computational experiments in two parts. In the first part of the experiments, we fixed the number of jobs at 10 and 15. We set the learning index at 1.001, 1.01, and 1.1, and the deteriorating index at −1.1, −1.01, and −1.001. As a result, we examined 324 experimental situations. We randomly generated a set of 20 instances for each situation. Tables 1, 2, 3, and 4 report the results, which include the CPU time (mean and standard deviation) and the number of nodes for the branch-and-bound algorithm.

Table 1 

Performance of the branch-and-bound and SA algorithms (𝑛=10, pro = 0.4).

Table 2 

Performance of the branch-and-bound and SA algorithms (𝑛=10, pro = 0.6).

Table 3 

Performance of the branch-and-bound and SA algorithms (𝑛=15, pro = 0.4).

Table 4 

Performance of the branch-and-bound and SA algorithms (𝑛=15, pro = 0.6).

As for the performance of the branch-and-bound algorithm, we see from Figure 1 and Table 1 that the number of nodes and the mean CPU time increase when 𝑛 becomes bigger. When the proportion of the jobs of agent 𝐴𝐺₁ is smaller (pro = 0.4), the number of nodes is obviously more than that with a bigger one as shown in Figure 2. In addition, the instances with a bigger value of 𝜏 (e.g., 𝜏 = 0.5 and 0.6) are easier to solve than those with a smaller one. Tables 1–4 also show that the mean error percentages of SA₃ (between 0.104% and 0.335%) are lower than those of SA₁ (between 0.277% and 0.832%) and those of SA₂ (between 0.272% and 0.730%.) Moreover, the standard deviations of the percentage error follow the same pattern. In particular, the standard deviations of the percentage error of SA₁, SA₂, and SA₃ were between 0.870% and 1.464%, 0.841% and 1.253%, and 0.352% and 0.588%, respectively. This indicates that the performance of SA₃ is better than that of the other two. In addition, the means error percentages of SA₃ are affected by the parameters 𝜏 and pro. In particular, it was up to 0.462% when the value of 𝜏 became smaller (at 𝜏 = 0.4) or pro was 0.6 (see Figure 2 and Tables 1–4). However, the mean error percentages of SA₃ were all below 0.5%. The results also indicate that the impact of the learning or deteriorating effect is insignificant.

Figure 1 

Performance of the branch-and-bound algorithm (𝑛=15).

Figure 2 

Performance of SA3 algorithm (𝑛=15).

In the second part of the experiments, we further assessed the performance of the proposed SA heuristics in solving instances with large numbers of jobs. Given the fact that it is not easy to generate a feasible solution when 𝑛 becomes lager, we set 𝑛 at 25 and 30, fixed the parameters at the values as those used for the small job-size design, and set the proportion of the jobs of agent 𝐴𝐺₁ at pro = 0.4 and 0.6 in the tests. We set the learning index at 1.001, 1.01, and 1.1, and the deteriorating index at −1.1, −1.01, and −1.001. As a result, we examined 324 experimental situations. We randomly generated a set of 20 instances for each situation. We obtained the relative percentage with respect to the best known solution among SA₁, SA₂, and SA₃ for each instance. We also recorded the mean execution time and the mean relative percentage deviation for each SA heuristic. We calculate the relative percentage deviation RPD as follows: SA_𝑖−SA^∗SA^∗, (18) where SA_𝑖 is the value of the objective function generated by SA_𝑖, and SA^∗=min{SA_𝑖,𝑖=1,2,3} is the smallest value of the objective function obtained from the three SA heuristics. Tables 5-6 report the results.

Table 5 

RPD of SA algorithms (𝑛=25).

Table 6 

RPD of SA algorithms (𝑛=30).

As shown in Tables 5-6, we see that the mean RPDs of SA₁ and SA₂ become bigger as 𝑛 increases. In general, the mean RPDs of SA₃ are lower than those of SA₁ and SA₂. Furthermore, Figure 3 and Tables 5-6 show that the RDP mean of SA₃ becomes smaller as 𝜏 becomes larger (e.g., 𝜏 = 0.6). However, when 𝜏 = 0.6, the mean RPD of SA₃ at pro = 0.4 was less than that at pro = 0.6. Figure 4 further shows that when 𝑛=30, SA₃ has a smaller RPD value when 𝜏 or 𝑅 becomes larger. In addition, all of the mean RPDs of SA₃ were less than 0.2%. In sum, SA₃ outperforms the other two SA heuristics in terms of both solution accuracy and performance stability.

Figure 3 

Performance of SA3 algorithm (𝑛=30).

Figure 4 

Performance of SA3 algorithms (𝑛=30).

5. Conclusions

In this paper, we study a two-agent single-machine scheduling problem with learning and deteriorating effects simultaneously. 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. We develop a branch-and-bound algorithm incorporating several dominant properties and a lower bound to derive the optimal solution. We also propose three simulated annealing algorithms to obtain near-optimal solutions. The computational results show that with the help of the proposed heuristic initial solutions, the branch-and-bound algorithm performs well in terms of the number of nodes and execution time, when the number of jobs is fewer than or equal to 15. Moreover, the computational experiments also show that the proposed SA₃ performs well since its mean error percentage was less than 0.4% for all the tested cases. Further research lies in the devising of efficient and effective methods to solve the problem with significantly larger numbers of jobs.

Acknowledgment

The author would like to thank the National Science Council of the Republic of China, Taiwan, for financially supporting this paper under the Contract nos. NSC 101-2410-H-264-004 and NSC 102-2410-H-264-003.