Int. J.

Production Economics 141 (2013) 14–23

Contents lists available at SciVerse ScienceDirect

Int. J. Production Economics

journal homepage: www.elsevier.com/locate/ijpe

A modified artificial bee colony algorithm for order acceptance in

two-machine flow shops
Xiuli Wang a,n, Xingzi Xie a, T.C.E. Cheng b
a
School of Economics and Management, Nanjing University of Science and Technology, Nanjing 210094, People’s Republic of China
b
Department of Logistics and Maritime Studies, The Hong Kong Polytechnic University, Hung Hom, Kowloon, Hong Kong

a r t i c l e i n f o a b s t r a c t

Article history: We consider a two-stage make-to-order production system characterized by limited production
Received 13 October 2011 capacity and tight order due dates. We want to make joint decisions on order acceptance and
Accepted 2 June 2012 scheduling to maximize the total net revenue. The problem is computationally intractable. In view of
Available online 13 June 2012
the fact that artificial bee colony algorithm has been shown to be an effective evolutionary algorithm to
Keywords: handle combinatorial optimization problems, we first conduct a pilot study of applying the basic
Scheduling artificial bee colony algorithm to treat our problem. Based on the results of the pilot study and the
Order acceptance problem characteristics, we develop a modified artificial bee colony algorithm. The experimental
Artificial bee colony algorithm results show that the modified artificial bee colony algorithm is able to generate good solutions for
Revenue
large-scale problem instances.
& 2012 Elsevier B.V. All rights reserved.

1. Introduction
In many industries product requirements for customers are
customized and unique. As a result, firms in such industries often
adopt the make-to-order approach to production. Given tight
delivery requirements and limits on production capacity, both
order acceptance decision and production scheduling decision
need to be taken into account. Selecting the right orders to accept
depends on the strategic direction of the firm and many other
considerations. From a problem-oriented perspective, order
acceptance should go along with a careful analysis of capacity
utilization so as to maximize the profit to the firm.
In this paper we consider the problem in a two-stage produc-
tion environment. Each order has distinct product characteristics
and is thus described as a job with different processing times in
stages 1 and 2. The model is motivated by many industries where
the process to produce products typically comprises two con-
secutive stages, e.g., a processing stage followed by a testing
stage. An example is a manufacturer of equipment products that
produces large special-purpose pressure vessels. Each order
typically includes only one equipment product with distinct
characteristics in terms of material, size, and shape, technological
process standards, pressure performance index, and so on. It is
common that processing a product is time-consuming at one
stage but not at the other, i.e., the manufacturing bottleneck stage
n
Corresponding author. Tel./fax: þ 86 025 84261056.
E-mail address: wangdu0816@163.com (X. Wang).
is not static but depends on all the processed orders. So schedul-
ing is an important issue. On the other hand, any delay in
delivering an order beyond its due date may incur a penalty cost
to the firm. Operating in such an environment, the firm faces the
problem of order acceptance and scheduling in a two-machine
flowshop to maximize the total net revenue.
The research on taking order acceptance decisions and sche-
duling decisions into account at the same time has received
increasing attention in recent years. The study results mainly
consider order acceptance and production in a single machine
environment with various settings. Slotnick and Morton (1996)
and Ghosh (1997) are regarded as pioneers in studying the order
acceptance and scheduling problem. They consider the order
acceptance and scheduling decisions at the same time so as to
maximize the total revenue. Lewis and Slotnick (2002) extend the
problem to multiple periods for the case where rejecting an order
of a customer will lead to the loss of all the future orders from
that customer. In recent years, research on this topic is further
extended to studying problems with different objectives and in
various settings. In terms of the solution approaches used to
tackle the problem, Slotnick and Morton (2007), Oğuz et al.
(2010), and Nobibon and Leus (2011) develop myopic heuristics
and exact approaches such as branch-and-bound algorithm,
dynamic programming, mixed integer linear programming for-
mulation, and so on. However, the exact algorithms only can solve
the small-scale problem since these problems are NP-hard.
Recently, Rom and Slotnick (2009) and Cesaret et al. (2012)
develop meta-heuristics that apply the techniques of computa-
tional intelligence to tackle the problem. The former team

0925-5273/$ - see front matter & 2012 Elsevier B.V. All rights reserved.
http://dx.doi.org/10.1016/j.ijpe.2012.06.003
 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23
proposes genetic algorithms and the latter team designs a tabu
search algorithm. Both teams show that their meta-heuristics
outperform the myopic heuristics and can obtain optimal or near-
optimal solutions for large-scale problem instances. More details
on this topic can be found in the recent reviews by Keskinocak
and Tayur (2004), and Slotnick (2011).
A special case of our problem where all the orders are accepted
and processed is the two-machine flowshop scheduling problem
to minimize the total weighted tardiness. This case is NP-hard in
strong sense (see, e.g., Pinedo (2002)). For the case of the total
tardiness problem in m-machine flowshops, Onwubolu and
Mutingi (1999) propose a genetic algorithm. For two-machine
flowshops, Schaller (2005) propose a branch-and-bound algo-
rithm to solve small-size problem instances optimally. For the
case of the total weighted tardiness problem in m-machine
flowshops, Parthasarathy and Rajendran (1998), and Rajendran
and Ziegler (2003) propose simulated annealing algorithms and
improving heuristics, respectively. Detail research on the
(weighted) tardiness problem in flowshops can be found in
Vallada et al. (2008).
As the best of our knowledge, only Rom and Slotnick (2009)
and Cesaret et al. (2012) propose meta-heuristics to solve the
order acceptance and scheduling problem. We notice that the
artificial bee colony (ABC) algorithm is a fairly new meta-heuristic
proposed by Karaboga (2005), which is based on simulating the
foraging behavior of honeybee swarms. Using some classic bench-
mark functions, Karaboga and Basturk (2007, 2008, and 2009)
compare the performance of the ABC algorithm with that of other
population-based algorithms such as differential evolution, par-
ticle swarm optimization, and evolutionary algorithm, and so on.
Their research results demonstrate that the ABC algorithm is
comparable to other population-based algorithms and the ABC
algorithm on average shows good performance. Furthermore, Gao
and Liu (2012) propose a modified ABC algorithm and show that it
is superior to the basic ABC algorithm for 28 tested mathematical
benchmark functions. Since its invention in 2005, the ABC algo-
rithm has been applied to deal with practical combinatorial
optimization problems (see, e.g., Singh (2009), Kang et al.
(2009), and Samrat et al. (2010)). Szeto et al. (2011) provide an
enhanced ABC algorithm to treat the capacitated vehicle routing
problem (CVRP). They show that the algorithm performs better
than some of the meta-heuristics (see, e.g., Toth and Vigo (2003),
Berger and Barkoui (2003), and Ai and Kachitvichyanukul (2009)).
Since the problem under study is evidently NP-hard, only
small-size instances can be optimally solved within a reasonable
time. In view of the good performance of the ABC algorithm and
its enhanced version in handling difficult combinatorial optimiza-
tion problems such as the classical CVRP, we design variants of
the ABC algorithm to treat the problem under study.
The paper is organized as follows. In Section 2, we give a
formal description of the problem under study. In Section 3, we
apply the basic ABC algorithm to solve our problem. In Section 4,
we propose a modified ABC algorithm based on investigating the
problem structure and optimal properties. In Section 5, we show
the experimental results of the proposed ABC algorithms. Section
6 concludes our study with a summary.
2. Problem description
We formally describe the problem under study as follows: a
pool of the potential orders, denoted by the set N ¼{1,2,y,n}, is
available for processing at time zero. Each order requires to be
processed first on machine 1 and then on machine 2. The
processing times of order i on machines 1 and 2 are ai and bi,
respectively. Each machine can only process one order at a time
15
and any order can begin processing on machine 2 only after
finishing its processing on machine 1. Associated with order i are
its revenue ri, due date di, and weight wi that represents its unit
time delay penalty beyond di in delivery to the customer.
The decisions are to determine the orders to accept for processing
and how to schedule the accepted orders. The objective is to
maximize the sum of the revenue of each accepted order minus
its weighted tardiness, i.e., the total net revenue. Let xiA{0,1}
be a decision variable. If order i is accepted for processing, then
xi ¼1; otherwise xi ¼0. Let Ci be the completion time of the
accepted order i on machine 2. The objective is expressed as
Pn
max xi ðr i wi maxf0,C i di gÞ.
i¼1
3. Artificial bee colony algorithm
ABC algorithm belongs to the category of evolutionary algo-
rithms that is inspired by the intelligent behavior of honeybees in
finding nectar sources around their hives. In an ABC algorithm, the
problem solutions are represented as food sources. The employed
bees and onlookers exploit new food sources from the current
ones. In the exploiting process, they communicate information on
nectar quality between themselves by performing waggle dances.
When a food source is abandoned by an employed bee, the
employed bee becomes a scout and starts to explore randomly a
new food source in the vicinity of the hive. This class of meta-
heuristics has only started to be applied to solve various combi-
natorial optimization problems recently. To the best of our knowl-
edge, there is no research on applying ABC algorithm to tackle
problems that involve scheduling and other operational decisions.
In this section we first discuss how to apply the basic
components of the ABC algorithm to treat our problem. We then
combine these components to develop the basic ABC algorithm
for treating the problem under study. It is evident that there is an
optimal solution for the problem in which the accepted orders are
processed in the same sequence on both machines. Thus, in the
following we only search for solutions in which the processing of
the accepted orders follows a permutation schedule.
3.1. Solution representation
We represent a solution by a vector in which the kth entry is
the order in the kth position of a sequence. If order i does not
appear in the vector, it is not accepted. Thus, a vector of size no
more than n represents both order acceptance and two-machine
sequencing decisions at the same time. For example, for the
problem with the set of orders {1,2,y,10}, a vector v¼(9, 2, 7,
6, 4, 10, 3) represents a problem solution in which orders 1, 5, and
8 are rejected, and the other orders are accepted and processed on
both machines in the same sequence (9, 2, 7, 6, 4, 10, 3).
3.2. Initial solutions
For the problem with n orders, we first randomly generate n
numbers from a uniform distribution on the interval [0, 1]. We
then sort these n numbers in non-decreasing order. We record a
list S ¼[k1,k2,y,kn] in which the jth position is the kjth generated
number. For example, when n ¼4, we successively and randomly
generate the numbers as 0.11, 0.75, 0.23 and 0.39. Then we create
the list S¼[1, 3, 4, 2] by arranging the jobs in ascending order of
their associated randomly generated number. According to list S,
we generate a solution vector v as follows:
1. Let p ¼ F (empty set) and h¼1.
2. For ‘ ¼ 1 to n, do
16 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23
Put order k‘ in the last position of the sequence p. If the net
revenue of order k‘ is positive, then set the hth entry of the vector
v as k‘ and let h’hþ 1; otherwise, remove order k‘ from p.
Using the above stochastic approach, we can generate some
solution vectors that we will use to constitute the initial popula-
tion for the ABC algorithm.
3.3. Neighborhood operators
For the problem under study, in the search process, we
suppose that the employed bees and onlookers adopt different
behavior modes to get new food sources, which are described as
neighborhood operators in the algorithm. In other words, a
neighborhood operator is a computing procedure used to gen-
erate a new solution vector v from the current solution vector v.
We define some neighborhood operators as follows:
3.3.1. Adjacent exchange (aEX)
The operator randomly selects two adjacent positions k and
kþ1 in the solution vector v and interchanges two jobs in
positions k and kþ1 to generate a new vector v. The cardinality
of the neighborhood is no greater than n 1. However, inter-
changing these two jobs may result in the job in position kþ1 of v
having a non-positive net revenue. If this case occurs, we will
remove the job from v.
3.3.2. Non-adjacent exchange (naEX)
The operator randomly selects non-adjacent positions j and k
(k4jþ 1) in the solution vector v and interchanges the jobs in
positions j and k to generate a new vector v. The neighborhood
cardinality is no greater than (n  1)(n  2)/2. However, the
operator may cause the job in position k of v to have a non-
positive net revenue. If this case occurs, we will remove the job
from v.
3.3.3. Non-adjacent forward shift (naFSH)
The operator randomly selects two positions j and k (k4j þ1)
in the solution vector v, and removes the job from position j and
re-insert it in position k to generate a new vector v. If the selected
job has a non-positive net revenue in the new position, we will
remove it. The neighborhood cardinality is no greater than
(n  1)(n  2)/2.
3.3.4. Non-adjacent backward shift (naBSH)
The operator randomly selects two positions j and k (k4j þ1)
in the solution vector v, and removes the job from position k and
re-inserts it in position j to generate a new vector v. The
neighborhood cardinality is no greater than (n  1)(n  2)/2.
3.3.5. Add a job (ADD)
Let SðvÞ be the complement set of solution vector v. If SðvÞ is
not empty, the operator randomly selects both a position k in v
and a job j from SðvÞ. The job j is inserted in position k of vector v
if it has a positive net revenue to generate a new vector v. The
cardinality of the neighborhood is 9v9(n 9v9).
3.3.6. Drop a job (DROP)
The operator randomly selects a position k in the solution
vector v and removes the job in position k to generate a new
vector v. The cardinality of the neighborhood is 9v9.
Since there is an optimal solution in which each accepted and
processed job has a positive net revenue, executing the operators
aEX, naEX, naFSH, and ADD will not lose the optimal solutions. On
the other hand, these operators may generate better solutions
because they will remove jobs with non-positive net revenues.
For the problem under study, it should be noticed that these
operators cannot replace one another because each operator has its
distinct neighborhood. For example, one solution vector obtained by
operator naEX may not be reached by a series of execution of
operator aEX. However, it is possible that a solution vector can be
reached by a combined execution of some of the operators.
3.4. Food sources selection
After carrying out the exploitation process, the employed bees
will share the nectar information with all the onlookers. Each
onlooker selects a food source randomly. In order to drive the
selection process towards better food sources in the ABC algo-
rithm, we use the roulette wheel selection method to randomly
select a food source. The probability of choosing food source vi is
P
T
proportional in size to its fitness value pi ¼ f ðvi Þ= f ðvj Þ, where
j¼1
f(vi) is the objective function of solution vector vi and T is the
number of the solutions in the current population.
3.5. Basic artificial bee colony algorithm
Based on the initialization scheme and the neighborhood
operators presented above, we formally describe the main steps
of the basic ABC algorithm as follows:
Algorithm A1. (Basic ABC algorithm)
1. Generate a set A¼{v1,v2,y,vT} of solutions as initial food
sources. Assign each of the food sources to an employed bee.
2. Calculate the objective function f(vi) of the food source vi, for
i ¼1, 2, y, T.
3. Set the constants t0 and IR0; set f00 ¼0, t ¼0 and ‘1 ¼ ‘2 ¼    ¼
‘T ¼ 0.
4. Repeat
(1) For i ¼ 1, 2, . . ., T, do
i) Generate a new food source vi from food source vi for
the employed bee by using an operator selected
randomly.
ii) Calculate the objective function f ðvi Þ. If f ðvi Þ 4 f ðvi Þ,
then vi ’vi and let ‘i ¼ 0; otherwise, let ‘i ¼ ‘i þ1.
(2) For i ¼ 1, 2, . . ., T, do
i) Select a food source vj by using the fitness-based
roulette wheel selection method.
ii) Select randomly an operator and use it to produce a
new food source vj from vj.
iii) Calculate the objective function f ðvj Þ. If f ðvj Þ 4 f ðvj Þ,
then vj ’vj and let ‘j ¼ 0; otherwise, let ‘j ¼ ‘j þ 1.
(3) For i ¼ 1, 2, . . ., T, do
If ‘i 4 limit, then replace vi by a new randomly generated
food source.
(4) Record the best solution f0 achieved so far.
(5) Let t ¼t þ1.
00
(6) If t ¼t0 and (f0  f )/f0 rIR0, then, stop; otherwise, if t ¼t0,
00
then set t¼ 0 and f ’f0 .
In Algorithm A1, the employed bees and onlookers select all
the operators with the same probability to search for new food
sources. In subsequent experiments, we show that this strategy is
better than that in which only one of the operators is used in the
whole exploitation process. In addition, in Algorithm A1, we
check and then remove the jobs with non-positive net revenues
when the objective values of the solution vectors are calculated.
This is equivalent to further applying operator DROP to the
solution vectors.
 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23
4. Modified artificial bee colony algorithm
Although ABC algorithm has achieved great success in solving
certain optimization problems, according to our computational
experiments (see Section 5), this is not the case for our problem.
In this section we propose a variant of the basic ABC algorithm to
improve the performance of Algorithm A1 for solving our
problem.
Algorithm A1 is a basic ABC algorithm in which the initial
population is randomly generated and the operators are randomly
selected. In its evolutionary process, any problem-specific struc-
ture or optimal property is not utilized to improve the algorithm’s
performance. In the following we investigate the structure and
some properties of the optimal solution for the problem, and
propose a modified ABC algorithm.
4.1. Initial population
Population initialization affects the convergence speed and
quality of the final solution. Generally speaking, diversity in initial
population helps escape from local optima and good-quality
initial solutions accelerate convergence speed in an evolutionary
algorithm. The random initialization process discussed above is
the most commonly used method to generate candidate solutions.
In order to improve the quality of the initial solutions, we apply
two heuristics to produce some initial solutions in which the job
parameters as due date, revenue per unit load time, and weight
for tardiness penalty are taken into account. Heuristics H1 and H2
work as follows:
Heuristic H1.
Step 1. Initially, set sequence p1 as an empty set. Re-index the
jobs and produce a job list ½1, 2, . . ., n such that
d1 r d2 r    r dn .
Step 2. Starting with the first job on the list, try to assign each job
i in turn to the last position of p1 and calculate its net
revenue. If the net revenue of job i is non-positive, then
discard job i from p1.
Heuristic H2.
Step 1. Initially, generate a schedule p ¼ ði1 , i2 , . . ., in Þ in the
earliest due date (EDD) order. Let B’N.
Step 2. For ikAB, let C ik be the completion time of job ik on
machine 2 and aik be the sum of the processing times of
the jobs on machine 1 that are processed no later than job
ik in schedule p. Let Iik ¼ maxf0, aik C ik1 g be the idle time
just before the processed job ik on machine 2.
Step 3. Select a job ‘ such that r ‘ =ðI‘ þ b‘ Þ ¼ minfr h =ðIh þ bh Þ9h A Bg
and remove it from schedule p to generate a schedule p0
in which the other jobs remain in the same positions as in
schedule p and are processed as early as possible.
Step 4. Calculate the objective values V(p) and V(p0 ) of schedules
p and p0 , respectively. If V(p0 )4V(p), then let p’p0 . Let
B’B\f‘g. If B is not empty, then go to Step 2; otherwise,
take schedule p as the new problem solution.
4.2. Selecting probability adjustment
In Algorithm A1, the operators are selected randomly with
equal chances. For the problem under study, the operators have
different characteristics and effects in searching for a new solution.
The selection of operators should consider these aspects. We may
gain insights by analyzing how the operators change the solutions.
17
It is noticed that the cardinalities of the operator neighbor-
hoods are different. The cardinalities of aEX and DROP are linear
in n, but the others are quadratic in n. It seems that the search
ability of aEX is not as powerful as those of naEX, naFSH,
and naBSH.
We also recognize that aEX, naEX, naFSH, and naBSH have
different effects on the sequence of the accepted jobs. Compared
with naEX, naFSH, and naBSH, the behavior of aEX affects the
performance of the sequence relatively weakly. In other words, it
may keep the original structure more stable and be suitable for
searching for good solutions locally. In most cases, naEX has the same
effect as a combination of naFSH and naBSH in the search process.
They are selected randomly and commonly used for search space
with ergodicity and irregularity in the sequences of the accepted jobs.
ADD and DROP consider both job acceptance and sequence at
the same time. They extend the original solution space by making
decisions mainly on job acceptance. ADD may worsen the revenue
of some jobs but compensate the total revenue by the added job.
DROP may reduce the tardiness penalty of some jobs but lose the
profit of the dropped jobs.
From the above observations, we design the probability for
selecting operators in the exploiting process with the following
considerations.
(1) The selecting probability for aEX, relative to those of the other
operators, may be determined by considering the relation
between the stability and the ergodicity in the search process.
Furthermore, the selecting probability for each of naEX, naFSH
and naBSH is roughly proportional to the cardinality of the
corresponding search neighborhood.
(2) The selecting probability of each operator should be adjus-
table in the evolutionary process. Since stability of the
solution structure is emphasized when the iterative number
becomes larger, aEX should be chosen with more a greater
chance, while naEX, naFSH, and naBSH should have less
chances to be selected.
(3) Since ADD and DROP make job acceptance decisions with
contrary behaviors, we may determine their selecting prob-
abilities in the current iterative step according to their search
effects in the previous steps.
In the modified ABC algorithm, we describe the vary prob-
abilities for selecting operators as follows: the employed bees and
onlookers select currently aEX with probability f(t)(40), where t
is the number of iterations so far. We assume that f(t) is an
increasing function of t. Each of naEX, naFSH, and naBSH is
selected with probability j(t)(40), where j(t) is a decreasing
function of t. Each of ADD and DROP is selected with probability
c(t,s)(40), where s scales the relative performance of the
selected ADD and DROP in the previous iterative step. c(t,s) is
also a decreasing function of t. It is clear that the sum of the
probabilities of selecting all the operators is equal to 1, i.e.,
f(t) þ3j(t)þ 2c(t,s)¼1.
Let M denote the maximum number of iterations permitted in
an algorithm. We define f(t), j(t), and c(t,s), respectively, as
follows:
t
jðtÞ ¼ a1 þ b1 ,
3M þ t
t
fðtÞ ¼ a2 b2 ,
3M þ t
t
cðt,sÞ ¼ a3 b3 þ g3 signðsÞ,
3M þ t
where ai, bi for i¼1, 2, 3, and g3 are pre-determined parameters,
and sign(s)¼1, 0, or 1 if s40, s¼0, or so0, respectively. When
18 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23
c(t,s) is applied to ADD, s is calculated by the number of improved
solutions of ADD minus those of DROP in the previous iterative
step. When c(t,s) is applied to DROP, it is calculated by setting its
s as the opposite number of that in c(t,s) of ADD.
4.3. Modified abandoning mode
In the onlooker stage of Algorithm A1, when a better food
source vi is found, the onlooker i will abandon the original food
source vi. However, since a good food source has more chances to
be selected and further exploited by the roulette selection
method, this abandoning mode may lead to a good food source
with more chances to be given up. We modify this abandoning
mode so as to provide more chances for exploitation in the
neighborhood of this food source and give up another food source
that has the worst fitness among the existing food sources.
Remarks: We have also attempted to impose some restrictions
on the operator neighborhoods by utilizing the specific structure
of the operators. For example, for an adjacent job pair (i, j) in
solution vector v, where job j is processed in position h, if job j is
not tardy and Ik 40, where job k is processed in position h þ1 and
Ik is the idle time just before job k processed in the second stage,
then exchanging jobs i and j will not improve the overall
performance of v. Thus, it is not necessary to process this job
pair (i, j) by aEX. By calculating the tardiness of job j and checking
the idle time Ik 40, the search neighborhood of aEX is limited
within a smaller solution space. We have also investigated some
structural properties of the other operators to restrict their
execution. However, our pilot experiments indicate that these
efforts do not obviously improve the performance of the algo-
rithm. It seems that the benefits from limiting the search space
may be eroded by the computing cost on checking the optimal
properties. So we do not take these aspects into account in our
attempt to improve the performance of the algorithm.
4.4. Modified artificial bee colony algorithm
Based on the discussion in the previous subsections, we use
both heuristics and a stochastic method to generate the initial
food sources. We also assume that the employed bees and
onlookers have partial learning ability from their experience
and that there is a variable environment to choose the searching
operators. Besides, we alter the abandoning mode in the onlooker
stage to intensify the search in the hopeful regions. We apply
these modifications to Algorithm A1 with a view to improving its
performance. We propose a modified ABC algorithm as follows:
Algorithm A2. (Modified ABC algorithm)
1. Generate a solution set A ¼ fv1 ,v2 ,. . .,vT g as initial food sources
by the stochastic approach presented in Section 3.2, and
Heuristics H1 and H2. Assign each food source to an
employed bee.
2. Calculate the function f(vi) of food source vi, for i ¼ 1, 2, . . ., T.
00
3. Set the constants t0 and IR0; Set t ¼0, s ¼0, f ¼0, t~ ¼ 0 and
‘1 ¼ ‘2 ¼ . . . ¼ ‘T ¼ 0.
4. Repeat
(1) Set s0 ¼0. For i ¼ 1, 2, . . ., T, do
i) Generate a new food source vi from vi for the
employed bee by using an operator that is selected
by the probability functions f(t), j(t), and c(t,s).
ii) Calculate the function f ðvi Þ. If f ðvi Þ 4 f ðvi Þ, then vi ’vi
and let ‘i ¼ 0; otherwise, let ‘i ¼ ‘i þ 1.
iii) If the operator is ADD and f ðvi Þ 4 f ðvi Þ, then let
s0 ’s0 þ1. If the operator is DROP and f ðvi Þ 4f ðvi Þ, then
let s0 ’s0  1.
(2) For i ¼ 1, 2, . . ., T, do
i) Select a food source vj by using the fitness-based
roulette wheel selection method.
ii) Select randomly an operator by the probability func-
tions f(t), j(t), and c(t,s), and apply this operator to
produce a new vector vj from vj. Calculate the objective
function f ðvj Þ. If f ðvj Þ 4f ðvj Þ, then let s0 ’s0 þ1 when
the operator is ADD, and let s0 ’s0  1 when the
operator is DROP.
iii) If f ðvj Þ 4 f ðvj Þ, then determine a food source vkAA such
that f(vk)rf(vm) for 8vmAA, and let vk ’vj and ‘k ¼ 0;
otherwise, let ‘j ¼ ‘j þ 1.
(3) For i ¼ 1, 2, . . ., T, do
If ‘i 4 limit, then replace vi by a new randomly generated
food source.
(4) Record the best solution f0 achieved so far.
(5) Let t ¼t þ1, t~ ¼ t~ þ1 and s’s0 .
00
(6) If t~ ¼ t 0 and (f0 f )/f0 rIR0, then, stop; otherwise, if t~ ¼ t 0 ,
00
then set t ¼ 0 and f ’f0 .
~
5. Experimental results
We conducted computational experiments to test the perfor-
mance of the proposed approaches. We coded the algorithms in
Visual Basic 6.0 and ran all the experiments on a PC computer
with 1.8 GHz Pentium processor and 2.0 G RAM. In the following
we present the experimental schemes and discuss the experi-
mental results.
5.1. Data generation
In order to extensively test the performance of the algorithms,
we generated instances of the problem randomly by varying the
parameters and using problem sizes of 30, 50, 100, and 150 jobs.
For each job i, the processing times ai and bi are integer numbers,
which were generated randomly from a uniform distribution in
the interval [1, 10]. The weight wi is also an integer number,
which was generated randomly from a uniform distribution in the
interval [1, 10]. We define two parameters, namely the relative
range factor of due dates R and the average tardiness factor t. R
indicates the relative differences of the due dates among all the
jobs and t depicts the tightness of all the jobs for delivery to
customers. We set the values of R to 0.3, 0.6, and 0.9. We used the
same values for t. For fixed values of R and t, let
Pn
P¼ð ðak þ bk ÞÞ=2. The due date di is an integer number, which
k¼1
was generated randomly from a uniform distribution in the
interval
½maxfPð1tR=2Þ,ai þ bi g,maxfPð1t þ R=2Þ,ai þ bi g
The revenue ri of each job i is an integer number generated
randomly from a uniform distribution in the interval [1, 10]. For
different combinations of R and t, we tested nine situations for
each of problem with 30, 50, 100, and 150 jobs.
5.2. Parameter selection
Selecting the parameters of the ABC algorithm is very impor-
tant as they affect the algorithm’s computational performance.
We set the parameters of the algorithm according to the under-
lying principles of honeybees’ social behavior in foraging for
nectar, in conjunction with experiment trials.
In order to reduce the number of parameters that need to be
tuned, we set the number of onlookers as the same as that of
 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23
employed bees (see Algorithms A1 and A2 in Sections 3 and 4).
Most researchers have adopted this approach (see, e.g., Karaboga
and Basturk (2008), Szeto et al. (2011) and Gao and Liu (2012)). In
the ABC algorithm, employed bees and onlookers carry out the
exploitation process in local neighborhoods. If a solution repre-
senting a food source in the local neighborhood is not improved
by a predetermined number of iterations, then the food source is
abandoned and one of the employed bees is selected as the scout
bee. The scout performs an exploration process to discover new
neighborhoods. The predetermined number of iterations, called
‘‘limit’’, is applied to balance the behaviors in the exploitation and
exploration processes.
It is noticed that the number of employed bees T and the value
of limit are related to problem size. For example, for the problem
with size n¼50 jobs, we chose the suitable values of T and limit
for Algorithm A1 as follows:
(i) Determine a suitable computing time t(R,t) for each situation
of fixed R and t by running two instances generated ran-
domly. For example, when R¼0.9 and t ¼0.3, we temporarily
neglect the differences between the values of T and limit, and
set T¼100 and limit ¼500. We attempt to determine a
computational time cost t0 by an iterative search until the
best solutions of the given number of consecutive iterations
are no longer improved obviously. Fig. 1 depicts the conver-
gence process of Algorithm A1 for a problem instance. In this
example, we took the improving ratio of the best solution in
100 consecutive iterations to be no more than 0.1% as the
terminating criterion and approximately determined the
terminating time t0 ¼10 s. Similarly, we also obtained the
terminating time t00 ¼13.7 s for another instance. Finally, we
set tð0:9, 0:3Þ ¼ maxft 0 ,t 00 g ¼ 13:7s for the situation of R¼ 0.9
and t ¼0.3.
(ii) Identify the intervals of T and limit with better objective
values for each situation of fixed R and t. For a given
terminating time t(R,t), we observe and identify the intervals
of T and limit with the better objective values obtained by
Algorithm A1 for solving the problem instances. We first
select the parameter limit such that the average number of
scouts is within 10% of the total number of employed bees
and onlookers. The underlying principle stems from observa-
tions on the social behavior of honeybees in foraging for
nectar (see Seeley (1995), and Karaboga and Basturk (2008)).
For example, when R¼0.9, t ¼0.3, and t(R, t) ¼13.7 s, Fig. 2
depicts the relations of the objective values with the para-
meter values T and limit. From Fig. 2, we identify that the
better intervals of T and limit for the tested instance are [100,
Fig. 1. The convergence process of the example.
19
Fig. 2. The objective values for different parameters T and limit.
200] and [300, 500], respectively. We can also determine the
intervals of T and limit for other situations.
(iii) Determine the common parameter values T and limit. From
the parameter intervals obtained in (ii), we identify the
common parameter values T and limit with better objective
values for the nine situations. For example, we chose (T,lim-
it)¼(100,300) for the problem with 50 jobs.
Applying the above procedure, we may also choose the
suitable values of T and limit for the problem with other sizes.
The experiments with the tested instances indicate that (T,lim-
it) ¼(30,60), (100,400), and (150,500) are suitable for the problem
with sizes of n ¼30,100, and 150 jobs, respectively.
Once the parameters T and limit were determined for each of
the problem sizes, we set the terminating time (or maximum
number of iterations) for running Algorithm A1 such that the
improving ratio of its best solution in (t0 ¼)100 consecutive
iterations is no more than (IR0 ¼)0.1%. We also applied the
determined parameters T and limit, and the terminating time
criterion to the further experiments conducted to test variants of
the ABC algorithm.
We introduced in Section 4.2 the idea of selecting operators
using varying probabilities and presented the probability func-
tions f(t), j(t), and c(t,s). In order to determine the parameters in
f(t), j(t) and c(t,s), we conduct a great deal of experimental
trials. Here, we set a1 ¼ a2 ¼0.05, a3 ¼0.4, b1 ¼0.65, b2 ¼0.2
b3 ¼0.025, and g3 ¼0.2 for all the problem sizes.
5.3. Discussions
5.3.1. Performance metrics
We measure the performance of the algorithms by the
achieved objective values and the computational time cost. The
minimal, average, and maximal objective values (denoted as Min,
Avg, and Max in Tables 2–6, respectively) are recorded when the
algorithm runs five times for solving an instance. The average
computational time for solving an instance is also recorded,
which is denoted as Time in Tables 2–6.
Since the problem is NP-hard in the strong sense, it is not
possible to obtain optimal solutions for large problem instances
within a reasonable time. So we use an upper bound on the
optimal solution to evaluate the performance of the algorithm.
The deviation of a solution from an upper bound is defined as
upper boundsolution
EachDev ¼ ð%Þ
upper bound
We record the average deviation of the solutions obtained by
running the algorithm five times for solving an instance. The
20 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23

average deviation is defined as From Table 1 we see that all the operators selected with equal
the sum of the EachDev chances obviously produce better solutions than the other six
Dev ¼ ð%Þ modes. The employed bees and onlookers can strengthen their
the number for computing an instance
exploiting abilities by applying a combination of operations and
By analyzing the problem characteristics and the pilot experi- thus probe a larger search space. Therefore, in Section 3, we
ments, we apply some techniques to improve the performance of design Algorithm A1 in which all the operators are selected with
the basic ABC algorithm. The improving effect is scaled by the the same chance.
improving ratios, which is define as
Impr ¼ Dev of the basic ABC algorithmDev of the variant ð%Þ 5.3.3. Effects of the initial solutions
We further tested Algorithm A1 with the problem instances
For the variant of the basic ABC algorithm, the ratio of its time
with 30, 50, 100, and 150 jobs. The experimental results are
cost for solving an instance to that of the basic ABC algorithm is
shown in Table 2. From Table 2 we see that there are only nine
denoted as TimeRatio. For each situation of R and t, we define the
out of 36 situations in which the average deviation from the
average ratio TRa as
P upper bound is under 10%. The other situations have larger
TimeRatio average deviations between 10% and 42%. It seems that the basic
TRa ¼ ð%Þ
the number of the tested instances ABC algorithm may easily get trapped in the local optima for
An upper bound may be calculated by the relaxation assign- solving our problem. Therefore, we develop Algorithm A2 by
ment algorithm which was firstly proposed by Slotnick and utilizing the problem-specific structure and strengthening the
Morton (2007). Here, by setting the negative net profit of an intelligence of the honeybee swarm.
assigned joblet as zero, we apply its variant which reduces the In comparison with Algorithm A1, Algorithm A2 mainly differs
number of the binary variables from 2b  2b to b  b. Our method in the three aspects described in Sections 4.1, 4.2, and 4.3. The
is described as follows. (1) Divide each job i into bi joblets with experimental results obtained by the modification in each aspect
unit processing times on machine 2 and set their processing times are displayed in Tables 3–5, respectively.
on machine 1 as zero. Set the revenue and the weight of each On comparing Tables 2 and 3, we see that when the solutions
joblet of job i as ri/bi and wi/bi, respectively. Set the due dates of bi of Heuristics H1 and H2 are brought into the initial population,
joblets of job i as di,di 1,y,di  bi þ1, respectively. (2) Let the convergence speeds up and the quality of the solutions almost
P
b¼ bi . If a joblet is assigned to a time-slot with the negative improves obviously for the tested instances. Specifically, for the
iAN large-scale problem instances with 100 and 150 jobs, the improv-
net profit, then we set its net profit as zero. Determine an optimal ing effect is much obvious. The average improving ratios of ten
solution for the b joblets by solving a corresponding assignment
problem and take its objective value as an upper bound for the
original problem.
Table 2
Performance of Algorithm A1.
5.3.2. Effects of the combined operator
We used the problem with 50 jobs to evaluate the effective- n R t Min Avg Max UB Time (s) Dev (%)
ness of the neighborhood operators in Algorithm A1. The cases in
which both employed bees and onlookers only use one of six 30 0.3 0.3 126 127.4 128 134 2.2 4.93
0.6 142 143.6 145 151 2.5 4.90
operators in the whole exploiting process are denoted as aEX, 0.9 162 166.4 170 177 3.4 5.99
naEX, naFSH, naBSH, ADD, and DROP in Table 1, respectively. The 0.6 0.3 99 102.2 106 144 2.5 29.03
experimental results are compared with Algorithm A1 (denoted 0.6 113 118.2 124 153 1.3 22.75
as ‘‘Combined’’ in Table 1) in which all the operators are chosen 0.9 119 123.4 126 153 1.7 19.35
0.9 0.3 53 56 58 83 1.9 32.53
with the same chance. For each situation of R and t, an instance
0.6 81 82.4 86 109 1.2 24.40
was generated randomly and run five times for each case and the 0.9 93 97.2 99 126 1.5 22.86
average objective value of the instance was recorded in Table 1. In 50 0.3 0.3 244 246.8 251 259 25.3 4.71
order to compare the effectiveness of the operators, we used the 0.6 260 265.2 274 286 19.8 7.27
same initial population and computing time cost to solve an 0.9 241 245.6 249 266 20.3 7.67
0.6 0.3 169 178.4 185 209 11.1 14.64
instance for seven cases. The computing time for solving an 0.6 188 196.6 203 243 12.5 19.09
instance was set as the smallest time among the seven cases in 0.9 193 200.4 206 242 14.1 17.19
which the improving ratio of the best solution in 100 consecutive 0.9 0.3 82 90.2 98 127 6.1 28.98
iterations is no more than 0.1%. 0.6 131 135.6 141 191 7.4 29.01
0.9 166 174 181 207 14.6 15.94
100 0.3 0.3 477 489.8 503 525 86.8 6.70
0.6 472 477.2 481 525 93.9 9.10
Table 1 0.9 506 521.6 532 562 104.6 7.19
Experimental results on the ABC algorithm with the different operators. 0.6 0.3 328 347.4 361 428 43.9 18.83
0.6 390 394.2 398 512 62.9 23.01
R t Average objective value 0.9 419 427.4 441 538 67.5 20.56
0.9 0.3 187 192 204 329 17.2 41.64
aEX naEX naFSH naBSH ADD DROP Combined 0.6 263 271.2 285 384 32.4 29.38
0.9 347 355 366 465 56.9 23.66
0.3 0.3 231.2 228.2 228.8 230 232.6 227.6 241.2 150 0.3 0.3 711 727.9 740 813 319.1 10.46
0.6 237.6 236.6 235.2 236 248.2 235.8 259.2 0.6 695 710.3 728 796 357.5 10.77
0.9 224.6 217 222.4 218.4 231.8 216.2 245 0.9 758 763.6 772 863 378.2 11.52
0.6 0.3 165.6 166.6 162.2 164.2 165.4 166.4 180.6 0.6 0.3 478 496.6 518 610 219.6 18.59
0.6 170.8 171.8 169.6 171.6 180.4 169.4 195 0.6 572 600.4 623 765 256.5 21.52
0.9 182.6 181.2 184.4 181 188 183 206.8 0.9 579 613.2 654 801 214.1 23.45
0.9 0.3 78.2 76.4 77.2 76.2 76.2 80 89 0.9 0.3 283 299.6 320 480 63.3 37.58
0.6 119 121.4 117.2 119.6 120.2 119 136 0.6 374 389 395 584 193.8 33.39
0.9 151.6 146.8 150.8 149.4 154.4 152.4 171.6 0.9 448 446.4 453 647 243.4 31.00
 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23 21

Table 3 Table 4
Performance of the basic ABC algorithm with Heuristics H1 and H2. Performance of the basic ABC algorithm with varying selecting probabilities.

n R t Min Avg Max Time (s) TRa (%) Dev (%) Impr (%) n R t Min Avg Max Time (s) TRa (%) Dev (%) Impr (%)

30 0.3 0.3 129 129 129 0.9 40.91 3.73 1.20 30 0.3 0.3 128 128.8 130 2.2 100.00 3.88 1.05
0.6 150 150 150 0.9 36.00 0.66 4.24 0.6 142 144.4 148 2.6 104.00 4.37 0.53
0.9 175 175.6 176 0.8 23.53 0.79 5.20 0.9 170 172 176 4.4 129.41 2.82 3.17
0.6 0.3 102 104.6 108 0.6 24.00 27.36 1.67 0.6 0.3 104 106.8 112 2.3 92.00 25.83 3.20
0.6 135 135 135 0.6 46.15 11.76 10.99 0.6 117 123 128 2.1 161.54 19.61 3.14
0.9 136 138.8 141 0.7 41.18 9.28 10.07 0.9 123 127.4 130 2.6 152.94 16.73 2.62
0.9 0.3 54 56.6 59 0.7 36.84 31.81 0.72 0.9 0.3 56 59.2 63 1.6 84.21 28.67 3.86
0.6 91 991.2 92 0.5 41.67 16.33 8.07 0.6 90 90.6 91 1.1 91.67 16.88 7.52
0.9 106 106.4 108 0.5 33.33 15.56 7.30 0.9 94 101.2 105 1.9 126.67 19.68 3.18
50 0.3 0.3 248 248.8 250 5.9 23.32 3.94 0.77 50 0.3 0.3 244 247.4 250 27.5 108.70 4.48 0.23
0.6 280 280.8 282 5.5 27.78 1.82 5.45 0.6 269 271.9 277 21.5 108.59 4.55 2.72
0.9 266 266 266 4.8 23.65 0 7.67 0.9 242 245.8 252 23.3 114.78 7.59 0.08
0.6 0.3 183 184.4 187 3.9 35.14 11.77 2.87 0.6 0.3 182 184 187 18.0 162.16 11.96 2.68
0.6 211 212.2 215 4.6 36.80 12.67 6.42 0.6 196 201.8 209 14.5 116.00 16.95 2.14
0.9 223 223.8 224 4.6 32.62 7.52 9.67 0.9 199 204 211 23.5 166.67 15.70 1.49
0.9 0.3 91 94.6 98 2.1 34.43 25.51 3.47 0.9 0.3 89 91.8 97 5.7 93.44 27.72 1.26
0.6 143 145.8 150 2.6 35.14 23.66 5.35 0.6 135 137.8 140 11.9 160.81 27.85 1.16
0.9 188 190.2 191 3.7 25.34 8.12 7.82 0.9 173 179.4 185 19.1 130.82 13.33 2.61
100 0.3 0.3 506 506.4 508 17.3 19.93 3.54 3.16 100 0.3 0.3 487 492 497 76.1 87.67 6.29 0.41
0.6 520 520 520 18.9 20.13 0.95 8.15 0.6 476 483.6 491 81.2 86.47 7.89 1.21
0.9 562 562 562 16.1 15.39 0 7.19 0.9 524 530.6 542 76.7 73.33 5.43 1.76
0.6 0.3 400 402.6 407 10.9 24.83 5.93 12.90 0.6 0.3 353 361.4 370 66.1 150.57 15.56 3.27
0.6 482 484.2 486 10.9 17.33 5.43 17.58 0.6 366 392.4 425 55.7 88.55 23.36 -0.35
0.9 508 513.6 519 15.7 23.26 4.54 16.02 0.9 401 421.4 442 15.5 22.96 21.67 -1.11
0.9 0.3 197 201.8 204 5.7 33.14 38.66 2.98 0.9 0.3 198 209.6 217 24.8 144.19 36.29 5.35
0.6 302 305.4 310 13.8 42.59 20.47 8.91 0.6 281 285.4 290 52.7 162.65 25.68 3.70
0.9 393 397.2 409 9.6 16.87 14.58 9.08 0.9 342 364.4 383 70.7 124.25 21.63 2.03
150 0.3 0.3 775 777.6 780 68.4 21.44 4.35 6.11 150 0.3 0.3 735 743 751 263.3 82.51 8.61 1.85
0.6 789 789 789 52.2 14.60 0.88 9.89 0.6 715 730 745 371.2 103.83 8.29 2.48
0.9 863 863 863 53.6 14.17 0 11.52 0.9 783 794 807 434.3 114.83 8.00 3.52
0.6 0.3 567 569 571 41.5 18.90 6.72 11.87 0.6 0.3 513 525 537 334.2 152.19 13.93 4.66
0.6 754 754 754 39.9 15.56 1.44 20.08 0.6 618 628.4 642 360.3 140.47 17.86 3.66
0.9 776 777.2 779 66.4 31.01 2.97 20.48 0.9 638 645 658 351.6 164.22 19.48 3.97
0.9 0.3 361 370 382 32.8 51.82 22.92 14.66 0.9 0.3 315 321.4 335 112.4 177.57 33.04 4.54
0.6 469 470.8 475 27.2 14.04 19.38 14.01 0.6 399 418.4 436 209.7 108.20 28.36 5.03
0.9 516 522.4 529 68.1 27.98 19.26 11.74 0.9 440 463.2 487 228.3 93.80 28.41 2.59

out of 18 situations are larger than 10%. We can conclude that
initialization is an important factor to influence the performance
of the ABC algorithm for solving our problem and utilizing
problem-specific structure to generate some initial solutions can
effectively improve the performance of Algorithm A1.
5.3.4. Effects of the dynamic selection probability
Table 4 displays the experimental results of the basic ABC
algorithm with varying probabilities. From Table 4 we see that the
quality of the solutions almost improves for all the tested
problem instances. However, the computational time cost
for solving some instances is slightly larger than that of
Algorithm A1. The increasing computing time may come from
the behavior to escape from local optima. Thus, the strategy of
selecting operators with varying probabilities helps improve the
performance of Algorithm A1.
5.3.5. Effects of the adandoning mode
We introduced in Section 4.3 the idea of modifying the
abandoning mode in the onlooker stage, which partially alters
the structure of the basic ABC algorithm. We evaluate the
performance of the modified algorithm and show the experi-
mental results in Table 5. From Table 5 we see that the quality of
the solutions improves for all the tested problem instances.
However, better objective values are achieved at the expense of
slightly longer computing times. The larger computational time is
incurred for the modified algorithm to escape from local optima.
For example, Fig. 3 shows the results of comparing the conver-
gence performance of this strategy with Algorithm A1 for the
instance with 150 jobs in the situation of R¼0.6 and t ¼0.3. From
Fig. 3, we see that the modified algorithm can escape from the
average local optimum 496.6 and reach the average objective
value 557.6 in an average time of 330 s. Algorithm A1 spends the
same time, the average objective value only increases slightly
from 496.6 to 505.2. Thus, we argue that the new abandoning
mode strengthens the ability of the algorithm to successively
improve the quality of the solutions.
5.3.6. General discussion
According to the experimental evaluations (see Tables 3–5),
we conclude that all the above three strategies are effective in
improving the performance of the basic ABC algorithm. We
integrate these techniques into an enhanced version of ABC
algorithm as Algorithm A2. We tested the performance of the
enhanced algorithm and show the experimental results in Table 6.
Comparing the results in Table 6 with those in the other tables,
we make the following observations.
(1) For all the problem sizes tested, the solutions obtained by
Algorithm A2 are better than those of Algorithm A1. With
larger problem sizes, the improvement is more obvious. The
improving ratios of six out of nine situations are more than
10% for the problem with 100 jobs. The improving ratios of
eight out of nine situations are more than 10% for the problem
with 150 jobs. On the other hand, for all the tested problem
instances, 30 situations are solved by Algorithm A2 with less
computing time cost than Algorithm A1. Therefore, Algorithm
A2 is clearly superior to Algorithm A1.
22 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23

Table 5 Table 6
Performance of the basic ABC algorithm with modified abandoning mode. Performance of Algorithm A2.

n R t Min Avg Max Time (s) TRa (%) Dev (%) Impr (%) n R t Min Avg Max Time (s) TRa (%) Dev (%) Impr (%)

30 0.3 0.3 129 129.2 130 2.1 95.45 3.58 1.35 30 0.3 0.3 129 129.4 130 1.8 81.82 3.43 1.50
0.6 146 148.8 151 3.1 124.00 1.46 3.44 0.6 150 150.2 151 1.9 76.00 0.53 4.37
0.9 165 169.4 173 2.8 82.35 4.29 1.70 0.9 176 176 176 1.8 52.94 0.56 5.43
0.6 0.3 104 105.4 107 2.1 84.00 26.81 2.22 0.6 0.3 117 119.4 121 2.3 92.00 17.10 11.93
0.6 117 121.6 126 2.1 161.54 20.52 2.23 0.6 138 138 138 0.9 69.23 9.76 12.99
0.9 122 128.6 134 2.4 141.18 15.95 3.40 0.9 141 141 141 0.9 52.94 7.84 11.51
0.9 0.3 55 59.6 65 1.3 68.42 28.19 4.34 0.9 0.3 67 68.7 69 1.8 94.74 17.27 15.26
0.6 84 87.6 91 1.1 91.67 19.63 4.77 0.6 93 94.2 95 1.0 83.33 13.57 10.83
0.9 105 107 109 2.0 133.33 15.08 7.78 0.9 110 111.8 115 1.2 80.00 9.06 13.80
50 0.3 0.3 250 252.4 255 29.4 116.21 2.55 2.16 50 0.3 0.3 250 253.6 256 24.4 96.44 2.08 2.63
0.6 268 272.8 275 28.1 141.92 4.62 2.65 0.6 281 282.4 283 13.7 69.19 1.26 6.01
0.9 243 250 255 24.4 120.20 6.02 1.65 0.9 266 266 266 13.1 64.53 0 7.67
0.6 0.3 189 190 192 16.7 150.45 9.09 5.55 0.6 0.3 189 191.4 195 16.5 148.65 8.42 6.22
0.6 216 217.6 220 25.3 202.40 10.45 8.64 0.6 225 226.2 227 24.8 198.40 6.91 12.18
0.9 202 212.4 219 27.5 195.04 12.23 4.96 0.9 224 224 224 12.3 87.23 7.44 9.75
0.9 0.3 96 97 98 8.53 139.84 23.62 5.36 0.9 0.3 101 104.5 108 5.7 93.44 17.68 11.30
0.6 140 146.6 152 12.6 170.27 23.25 5.76 0.6 156 161.2 164 26.3 355.41 15.60 13.41
0.9 173 184 190 19.3 132.19 11.11 4.83 0.9 190 193 196 10.2 69.86 6.76 9.18
100 0.3 0.3 501 506.2 512 98.9 113.94 3.58 3.12 100 0.3 0.3 506 508 513 49.9 57.49 3.24 3.46
0.6 491 499 504 99.5 105.96 4.95 4.15 0.6 519 519.8 520 36.7 39.08 0.99 8.11
0.9 530 540 548 119.1 113.86 3.91 3.28 0.9 562 562 562 40.4 38.62 0 7.19
0.6 0.3 366 381.6 394 73.6 167.65 10.84 7.99 0.6 0.3 400 406.2 412 43.6 99.32 5.09 13.74
0.6 412 438.8 456 108.4 172.34 14.30 8.71 0.6 484 488.4 493 33.9 53.90 4.61 18.40
0.9 434 461 476 131.0 194.07 14.31 6.25 0.9 517 523.4 525 48.8 72.30 2.78 17.78
0.9 0.3 216 223 229 32.6 189.53 32.22 9.42 0.9 0.3 255 257.6 265 50.5 293.60 21.68 19.96
0.6 301 309.4 326 55.7 171.91 19.43 9.95 0.6 330 332.4 335 52.5 162.04 13.44 15.94
0.9 358 382.4 402 76.9 135.15 17.76 5.90 0.9 414 418.8 424 54.2 95.25 9.92 13.74
150 0.3 0.3 763 771.8 777 385.4 120.78 5.07 5.39 150 0.3 0.3 777 781 784 187.8 58.85 3.94 6.52
0.6 752 761.6 777 381.8 106.80 4.32 6.45 0.6 793 794.2 795 346.9 97.03 0.23 10.54
0.9 792 808.2 824 415.6 109.89 6.35 5.17 0.9 863 863 863 92.3 24.41 0 11.52
0.6 0.3 552 557.6 563 330.5 150.50 8.58 10. 01 0.6 0.3 566 569.2 571 89.0 40.53 6.69 11.90
0.6 664 675.2 686 474.5 184.99 11.74 9.78 0.6 754 754 754 60.5 23.59 1.44 20.08
0.9 652 672.6 685 539.2 251.84 16.03 7.42 0.9 776 778.4 780 159.5 74.50 2.82 20.63
0.9 0.3 343 358.4 367 91.2 144.08 25.33 12.25 0.9 0.3 388 394.6 401 79.2 125.12 17.79 19.79
0.6 459 441 452.6 252.7 130.39 22.50 10.89 0.6 486 487.8 490 150.2 77.50 16.47 16.92
0.9 482 503.2 520 261.4 107.40 22.23 8.77 0.9 552 557.6 565 230.8 94.82 13.82 17.18

Fig. 3. Convergence performance of Algorithm A1 and its variant with modified Fig. 4. Convergence performance of Algorithm A2 and the basic ABC algorithm
abandoning mode. with Heuristics H1 and H2.

(2) On comparing the results in Table 6 with those in Tables 4 and
5, we see that Algorithm A2 obtains better solutions in approxi-
mately the same or less computing time costs than variants of
the algorithms modified with varying probabilities or with a
new abandoning mode. Comparing Table 6 with Table 3, we see
that the quality of solutions obtained by Algorithm A2 is better
than that of the solutions obtained by Algorithm A1 with
Heuristics H1 and H2. Algorithm A2 spends more computing
time in solving some situations, but this indicates that
Algorithm A2 has a greater ability to escape from local optima.
For example, Fig. 4 depicts the convergence performance of
Algorithm A2 and Algorithm A1 with Heuristics H1 and H2 for
solving the instance with 100 jobs in the situation of R¼0.6 and
t ¼ 0.9. From Fig. 4, we see that Algorithm A2 achieves an
average objective value of 523.1 in an average running time of
48.8 s, while Algorithm A1 with Heuristics H1 and H2 takes the
same average running time, it yields an average objective value
of 514.3, which is only a slight increase from the original value
of 513.6. Summarizing the above comparisons, we argue that
the solutions obtained by Algorithm A2 are better than all the
solutions obtained by other variants of the algorithm that are
modified in only one of the three aspects. Thus, integrating the
three techniques for improving the basic ABC algorithm is a
potent strategy for solving the problem under study.
 X. Wang et al. / Int. J. Production Economics 141 (2013) 14–23
(3) From Table 6, we see that the deviations of the solutions from
the average values by running Algorithm A2 five times are all
under 5%, with most cases under 1%. Therefore, we conclude
that Algorithm A2 is robust.
(4) Algorithm A2 produces the most solutions whose average
deviations from the upper bound are under 10%. For these
instances, we may say that Algorithm A2 find the optimal or
near-optimal solutions. Only one situation has average devia-
tions above 20%. Note that a gap between the upper bound
and the optimal solutions may exist and the deviations also
include the gap. We can conclude that Algorithm A2 is
successful in obtaining good solutions for solving large
instances of the problem under study.
6. Conclusions
In this paper we develop a modified ABC algorithm for solving
the integrated order acceptance and two-machine flowshop
scheduling problem. The objective is to maximize the total net
revenue. We first conduct a pilot study on applying the basic ABC
algorithm to solve the problem with a view to obtaining clues to
design some improving techniques and to properly set the
parameters. We then develop a modified ABC algorithm for
solving the problem under study. The experimental results show
that the modified ABC algorithm can produce good solutions
quickly. The research results suggest that the enhanced ABC
algorithm is capable of solving large-scale optimization problems
that combine production scheduling with other operational
decisions.
Acknowledgments
We thank an Editor and three anonymous referees for the
helpful comments on an earlier version of our paper. The first
author was supported in part by the National Natural Science
Foundation of China under grant 71171114, and Qing Lan Project
and NUST Research Funding under grant 2011XQTR10. The third
author was supported in part by the Shipping Research Centre of
The Hong Kong Polytechnic University.
References
Ai, T.J., Kachitvichyanukul, V., 2009. Particle swarm optimization and two solution
representations for solving the capacitated vehicle routing problem. Compu-
ters and Industrial Engineering 56, 380–387.
Berger, J., Barkoui, M., 2003. A new hybrid genetic algorithm for the capacitated
vehicle routing problem. Journal of the Operational Research Society 54,
1254–1262.
23
Cesaret, B., Oğuz, C., Salman, F.S., 2012. A tabu search algorithm for order
acceptance and scheduling. Computers and Operations Research 39,
1197–1205.
Gao, W.-F., Liu, S.-Y., 2012. A modified artificial bee colony algorithm. Computers
and Operations Research 39, 687–697.
Ghosh, J.B., 1997. Job selection in a heavily loaded shop. Computers and Opera-
tions Research 24, 141–145.
Kang, F., Li, J., Xu, Q., 2009. Structural inverse analysis by hybrid simplex artificial
bee colony algorithms. Computers and Structures 87, 861–870.
Karaboga, D. 2005. An Idea Based on Honey Bee Swarm for Numerical Optimiza-
tion. Technical Report-TR06, Erciyes University, Kayseri, Turkey, 2005.
Karaboga, D., Basturk, B., 2007. A powerful and efficient algorithm for numerical
function optimization: artificial bee colony (ABC) algorithm. Journal of Global
Optimization 39, 459–471.
Karaboga, D., Basturk, B., 2008. On the performance of artificial bee colony (ABC)
algorithm. Applied Soft Computing 8, 687–697.
Karaboga, D., Basturk, B., 2009. A comparative study of artificial bee colony
algorithm. Applied Mathematics and Computation 214, 108–132.
Keskinocak, P., Tayur, S., 2004. Due date management policies. In: Simchi-Levi, D.,
Wu, S.D., Shen, Z.J. (Eds.), Handbook of Quantitative Supply Chain Analysis:
Modeling in the E-business Era. Kluwer, Boston.
Lewis, H.F., Slotnick, S.A., 2002. Multi-period job selection: planning work loads to
maximize profit. Computers and Operations Research 29, 1081–1098.
Nobibon, F.T., Leus, R., 2011. Exact algorithms for a generalization of the order
acceptance and scheduling problem in a single-machine environment. Com-
puters and Operations Research 38, 367–378.
Oğuz, C., Salman, F.S., Yalcin, Z.B., 2010. Order acceptance and scheduling decisions
in make-to-order systems. International Journal of Production Economics 125,
200–211.
Onwubolu, G.C., Mutingi, M., 1999. Genetic algorithm for minimizing tardiness in
flow-shop scheduling. Production Planning and Control 10, 462–471.
Parthasarathy, S., Rajendran, C., 1998. Scheduling to minimize mean tardiness and
weighted mean tardiness in flowshop and flowline-based manufacturing cell.
Computers and Industrial Engineering 34, 531–546.
Pinedo, M., 2002. Scheduling Theory, Algorithms, and Systems. Prentice Hall,
Upper Saddle River, New Jersey.
Rajendran, C., Ziegler, H., 2003. Scheduling to minimize the sum of weighted
flowtime and weighted tardiness of jobs in a flowshop with sequence-
dependent setup times. European Journal of Operational Research 149,
513–522.
Rom, W.O., Slotnick, S.A., 2009. Order acceptance using genetic algorithms.
Computers and Operations Research 36, 1758–1767.
Samrat, L.S., Siba, K.L., Ajith, A., 2010. Artificial bee colony algorithm for small
signal model parameter extraction of MESFET. Engineering Applications of
Artificial Intelligence 23, 689–694.
Schaller, J., 2005. Note on minimizing total tardiness in a two-machine flowshop.
Computers and Operations Research 32, 3273–3281.
Seeley, T.D., 1995. The Wisdom of the Hive. Harvard University Press, Cambridge.
Singh, A., 2009. An artificial bee colony algorithm for the leaf-constrained
minimum spanning tree problem. Applied Soft Computing 9, 625–631.
Slotnick, S.A., 2011. Order acceptance and scheduling: a taxonomy and review.
European Journal of Operational Research 212, 1–11.
Slotnick, S.A., Morton, T.E., 1996. Selecting jobs for a heavily loaded shop with
lateness penalties. Computers and Operations Research 23, 131–140.
Slotnick, S.A., Morton, T.E., 2007. Order acceptance with weighted tardiness.
Computers and Operations Research 34, 3029–3042.
Szeto, W.Y., Wu, Y.Z., Ho, S.C., 2011. An artificial bee colony algorithm for the
capacitated vehicle routing problem. European Journal of Operational
Research 215, 126–135.
Toth, P., Vigo, D., 2003. The granular tabu search and its application to the vehicle-
routing problem. Journal of Computing 15, 333–346.
Vallada, E., Ruiz, R., Minella, G., 2008. Minimizing total tardiness in the m-machine
flowshop problem: a review and evaluation of heuristics and metaheuristics.
Computers and Operations Research 35, 1350–1373.