Compatibility Graphs in Scheduling On Batch Processing Machines

1
arXiv:2309.02601v1 [cs.DM] 5 Sep 2023
Compatibility graphs in scheduling on batch processing machines
Khaoula BOUAKAZ and Mourad BOUDHAR

RECITS laboratory, Faculty of Mathematics, USTHB University, Algiers, Algeria
khaoulabouakaz19@gmail.com
mboudhar@yahoo.fr
Abstract. We consider the problem of minimizing the makespan on batch processing identical
machines, subject to compatibility constraints, where two jobs are compatible if they can be pro-
cessed simultaneously in a same batch. These constraints are modeled by an undirected graph
G, in which compatible jobs are represented by adjacent vertices. We show that several subprob-
lems are polynomial. We propose some exact polynomial algorithms to solve these subproblems.
To solve the general case, we propose a mixed-integer linear programming (MILP) formulation
alongside with heuristic approaches. Furthermore, computational experiments are carried out to
measure the performance of the proposed methods.
Keywords: batch scheduling, makespan, compatibility graph, complexity, matching
1. Introduction
In classical scheduling theory, it is assumed that machines can only process one job at a time. However,
in reality there is another scheduling model that can be called ”batch machines” and that refers to
batches of jobs to be processed together (material painted together, material rolled together, material
transported together, etc). In these cases, the jobs in the same batch have to be compatible.
The principal motivation for batch scheduling is the scheduling of burn-in operations in the semi-
conductor industry where are exposed to high temperatures in a fixed capacity oven in order to weed
out chips susceptible to premature failure.
In this work, we consider the problem of scheduling a set J = {J1 , ..., Jn } of n jobs non-
preemptively on batch processing identical machines to minimize the makespan Cmax . We assume
Address for correspondence: RECITS laboratory, Faculty of Mathematics, USTHB University, BP 32 El-Alia, Bab Ezzouar,
Algiers, Algeria
2 K. BOUAKAZ and M. BOUDHAR / Compatibility graphs in scheduling on batch processing machines
that the jobs are subject to compatibility constraints modeled by an undirected graph G = (V, E), we
call the compatibility graph, in which each job is represented by a vertex (V = J), and each edge joins
a pair of jobs that can be processed simultaneously in a same batch. By definition, a batch belongs to
a clique of the graph G. The capacity b of a batch and hence the clique size, may be finite b = k, vari-
able, or infinite b = ∞ (it can process all jobs simultaneously). The job Ji has the processing time pi
and the processing time of a batch is equal to the maximum processing time or the sum of processing
times of jobs assigned to it. All the jobs in a batch must be available at the same date, start at the same
date and finish at the same date. We assume that a setup-time s must separate two successive batches
and that the jobs of a batch are processed without setup-time. The setup-time is independent of the
batches sequence, it is identical between each two successive batches on all machines.
A feasible schedule is an assignment of the jobs to the machines where all the jobs in a same
batch are adjacent in the graph G. In a given schedule, the completion time of a batch Bi , de-
noted by Ci , is defined as the time by which the machine completes its processing. The largest one
among them defines the makespan of the schedule Cmax . We denote these batch scheduling prob-
lems with a fixed number of machines m by Bm, max|G = (V, E), b, pi , s|Cmax and Bm, sum|G =
(V, E), b, pi , s|Cmax .
This paper is organized as follows. Section 2 is about the literature review. In section 3, we study
the complexity results. Linear formulation will be given in Section 4. In Section 5, we present two
heuristic approaches. Section 6 reports the computational results. We conclude this article in Section
7.
2. Literature review
The theory of batch scheduling for various scheduling objectives and additional constraints has been
already well established in [1, 2]. Some very special cases of job compatibility, the Incompatible
Families structures [3, 4, 5, 6] and the Compatible Families structures [1, 7, 8, 4] have previously
been treated. Intensive research has subsequently been developed on this subject for various schedul-
ing objectives and additional constraints, see for instance the surveys [1]. [9] provided a survey of
scheduling research in semiconductor manufacturing. In [10], the authors presented the literature on
parallel batching and focused primarily on deterministic scheduling. They provided a taxonomy of
parallel batching problems, distinguishing the compatible case and the incompatible families. They
discussed scheduling approaches for single machine, parallel machines, and other environments such
as flow shops and job shops.
For the case of single batch processing machine with a general compatibility graph G has been
analyzed in [11]. In the same reference the authors have proved that the problem with an arbitrary
compatibility graph G, denoted B1|G = (V, E), b = 2|Cmax can be solved in polynomial time of
order O(n3 ) as a maximum weighted matching problem. Note that the sub-problem with an iden-
tical processing time denoted B1|G = (V, E), b = 2, pi = 1|Cmax can be solved in polynomial
time of order O(n2.5 ) as a maximum cardinality matching problem. The special cases with bipartite
compatibility graph and split compatibility graph have been analyzed respectively in [12, 13, 14]. In
[13], each job has a release date and a processing time equal to 1. [15] studied the scheduling on
a single max-batch machine with variable capacity, each job has a minimal processing time and the
K. BOUAKAZ and M. BOUDHAR / Compatibility graphs in scheduling on batch processing machines 3
compatibility constraint may be represented by an interval graph. They considered several models
with varying batch capacities, processing times or compatibility graphs. They summarized known
results, and presented a min–max formula and polynomial time algorithms.
In [16] is studied the case of the serial batching and parallel batching. They did not introduce the
notion of compatibility graphs. They developed exact algorithms to minimize makespan on single and
parallel batch processing machines for the problem 1|sj , B|Cmax and P m|sj , B|Cmax where each job
j has a size sj and a minimum processing time pj , which does not differ across the machines. Then, a
subset of jobs that can be processed simultaneously forms a batch under the condition that their total
size is no larger than machine capacity S. In [17] is considered the online (over time) scheduling
problem of minimizing the makespan on m unbounded parallel-batch machines with a compatibility
constraint which is represented by an interval compatibility graph. They provided that there exists
no online algorithm with a competitive ratio less than 2 and an online algorithm with a competitive
ratio 2 + (m − 1)/(m + 1), which is optimal for the case m = 1. When all jobs have the same
processing times, they also gave an optimal online algorithm. Based on previous studies that often
combine machine learning algorithms with practical production applications. [18] provided a new
approach to the scheduling process using an advanced genetic algorithm.
For the case of flowshop batching machines, [19] studied the no-wait flowshop problem with
two batching machines, and proposed a polynomial algorithm for the above problem. They also
extended their studies to the case of m batching machines. In [20] is considered a two-stage hybrid
flowshop problem in which the first stage contains several identical discrete machines, and the second
stage contains several identical batching machines. They studied the case of an interval graph when
which jobs have the same processing time on the first stage, for which a polynomial approximation
scheme algorithm is presented. [21] studied the problem of job scheduling in a flowshop with two
machines. The first machine is a discrete machine and the second machine is a batching machine
with the additional feature that the jobs of the same batch have to be compatible. A compatibility
constraint is defined by an interval graph. They studied the complexity of the makespan minimization.
They developed a heuristic approach and evaluated it. Other related results for the case of flowshop
batching machines were presented by [22, 23].
3. Complexity results
We, here, briefly present new results regarding the problems B1, max|G = (V, E), b = 2, s|Cmax
and B1, sum|G = (V, E), b = 2, s|Cmax for the case of a single machine and Bm, max|G =
(V, E), b = 2, pi = p, s|Cmax , Bm, sum|G = (V, E), b = 2, pi = p, s|Cmax and B2, max|G =
(V, E), b = 2, pi = {p, q}, s|Cmax for the case of several machines. These problems with an arbitrary
compatibility graph G can be solved in polynomial time.
3.1. Case of single machine

We show in this section that the problem of scheduling a set of n jobs J1 , ..., Jn non-preemptively on
a single batch processing machine to minimize the makespan is polynomial. Here the jobs are subject
to compatibility constraints modeled by an undirected graph G, each batch has a capacity b = 2, each
job Ji has a processing time pi and there exist a setup-time s between each two successive batches.
Theorem 3.1. The problem B1, max|G = (V, E), b = 2, s|Cmax reduces to the maximum weighted
matching.
Proof:
Let σ be a feasible schedule, it is composed of two-job batches and single-job batches. The two-job
batches correspond to a matching M in graph G and the single-job batches are those P
of the set V \ VM
(VM represents the jobs of the matching M ) and contribute to σ by a time K = p(Jl ).
l/Jl ∈V \VM
Let c(ek ) = max{p(Ji ), p(Jj )} be the cost of the
Pedge ek , if the edge ek is incident to the vertices
Ji and Jj . The makespan is written: Cmax (σ)= c(ek ) + K + s(|V | − |M | − 1), where the
k/ek ∈M
expression s(|V | − |M | − 1) represents the global setup-time of σ.
We have
X X X X
K= p(Jl ) − p(Jl ) = p(Jl ) − (p(Ji ) + p(Jj ))
l/Jl ∈V l/Jl ∈VM l/Jl ∈V k/ek =(Ji ,Jj )∈M
P
Since |M | = k/ek ∈M 1, then we obtain:
X X X
Cmax (σ) = max{p(Ji ), p(Jj )} + p(Jl ) − (p(Ji ) + p(Jj ))
k/ek =(Ji ,Jj )∈M l/Jl ∈V k/ek =(Ji ,Jj )∈M
 
X
+ s n − 1 − 1
k/ek ∈M
X X
= (max{p(Ji ), p(Jj )} − p(Ji ) − p(Jj ) − s) + p(Jl ) + s(n − 1)
k/ek =(Ji ,Jj )∈M l/Jl ∈V
X X
= − (min{p(Ji ), p(Jj )} + s) + p(Jl ) + s(n − 1).
We consider a new weight function α on the graph G such that for each edge ek = (Ji , Jj ),
α(ek ) = min{p(Ji ), p(Jj )} + s, then the makespan is written :
X X
Cmax (σ) = p(Jl ) + s(n − 1) − α(ek )
l/Jl ∈V k/ek ∈M
P
p(Jl ) + s(n − 1) is a constant. Then, minimizing Cmax is equivalent to maximizing
Pl/Jl ∈V
α(ek ).
k/ek ∈M
Hence, the optimal solution of the problem is obtained by finding a maximum weighted matching
M in the valued graph Hα = (G, α). ⊔
⊓
Algorithm 1:
Input: G = (V, E), pi , s
Result: schedule σ
1. From the graph G = (V, E), construct a new valued graph Hα = (G, α) where each edge
e = (Ji , Jj ) ∈ E is valued by α(e) = min{p(Ji ), p(Jj )} + s.
2. Find a maximum weighted matching M in the graph Hα .
3. Form the batches of σ:
• For each edge of the matching M , process the corresponding two jobs in a same batch.
• The other jobs are processed in single job batches. (Schedule the batches in an arbitrary
order).
P P
4. Cmax (σ) = l/Jl ∈V p(Jl ) + s(n − 1) − k/ek ∈M α(ek ).
Algorithm 1 solves the problem B1, max|G = (V, E), b = 2, s|Cmax .

The best known algorithm for the maximum weighted matching is in O(n3 ). Hence, also the
Algorithm 1 runs in O(n3 ).
If all the processing times are identical to p, α(e) = p + s for all e ∈ E. The problem
B1, max|G = (V, E), b = 2, pi = p, s|Cmax is solved by finding a maximum cardinality match-
ing in the graph G with complexity O(n2.5 ).
Theorem 3.2. The problem B1, sum|G = (V, E), b = 2, s|Cmax reduces to the maximum cardinal-
ity matching.
Proof:
Let σ be a feasible schedule, it is composed of two-job batches and single-job batches. The two-job
batches correspond to a matching MPin graph G and the single-job batches are those of the set V \ VM
and contribute to σ by a time K = l/Jl ∈V \VM p(Jl ).
Let c(ek ) = p(Ji ) + p(Jj ) be the cost of the edge
P ek , if the edge ek is incident to the vertices
Ji and Jj . The makespan is written: Cmax (σ)= c(ek ) + K + s(|V | − |M | − 1), where the
k/ek ∈M
expression s(|V | − |M | − 1) represents the global setup-time of σ.
We have
X X X X
K= p(Jl ) − p(Jl ) = p(Jl ) − (p(Ji ) + p(Jj ))
l/Jl ∈V l/Jl ∈VM l/Jl ∈V k/ek =(Ji ,Jj )∈M
P
Since |M | = k/ek ∈M 1, then we obtain:
X X X
Cmax (σ) = (p(Ji ) + p(Jj )) + p(Jl ) − (p(Ji ) + p(Jj ))
k/ek =(Ji ,Jj )∈M l/Jl ∈V k/ek =(Ji ,Jj )∈M
 
X
+ s n − 1 − 1
k/ek ∈M
X X
= (p(Ji ) + p(Jj ) − p(Ji ) − p(Jj ) − s) + p(Jl ) + s(n − 1)
X X
= p(Jl ) + s(n − 1) − s 1
l/Jl ∈V k/ek =(Ji ,Jj )∈M
P P
p(Jl )+s(n−1) is a constant. Then, minimizing Cmax is equivalent to maximizing 1.
l/Jl ∈V k/ek ∈M
Hence, the optimal solution of the problem is obtained by finding a maximum cardinality matching
M in the graph G. ⊔
⊓
Algorithm 2 solves the problem B1, sum|G = (V, E), b = 2, s|Cmax .
Algorithm 2:
Result: schedule σ
1. Find a maximum cardinality matching M in the graph G.
2. Form the batches of σ:
• The other jobs are processed in single job batches. (Schedule the batches in an arbitrary
order).
P
3. Cmax (σ) = l/Jl ∈V p(Jl ) + s(n − |M | − 1).
The best known algorithm for the maximum cardinality matching is in O(n2.5 ). Hence, also the
Algorithm 2 runs in O(n2.5 ).
3.2. Case of several machines

We show in this section that the scheduling problems Bm, max|G = (V, E), b = 2, pi = p, s|Cmax ,
Bm, sum|G = (V, E), b = 2, pi = p, s|Cmax and B2, max|G = (V, E), b = 2, pi = {p, q}, s|Cmax
are solvable in polynomial time. Where the jobs are subject to compatibility constraints modeled by
an undirected graph G, each batch has a capacity b = 2, all the processing times are identical to p or
to two values {p, q} where p < q and there exist a setup-time s between each two successive batches.
The problem Bm|G = (V, E), b = 1|Cmax is equivalent to the parallel machine problem P m||Cmax .
Consequently, these batch scheduling problems are NP-hard for m ≥ 2.
Theorem 3.3. The problem Bm, max|G = (V, E), b = 2, pi = p, s|Cmax reduces to the maximum
cardinality matching.
Proof:
The value of an optimal solution of the problem B1, max|G = (V, E), b = 2, pi = p, s|Cmax devised
l m isma lower
by problem Bm, max|G = (V, E), b = 2, pi = p, s|Cmax that is LB =
l boundmof the
n−|M | n−|M |
m p+ m − 1 s. Since all the processing times are equal to p, then to build an optimal
schedule for the above problem, it suffices to find a maximum
l l M inmthe graph
matching
m G, the value
n−|M | n−|M |
of the corresponding solution of M is equal to Cmax = m p+ m − 1 s which is equal
to LB. ⊔
⊓
Algorithm 3 solves the problem Bm, max|G = (V, E), b = 2, pi = p, s|Cmax .
Algorithm 3:
Input: G = (V, E), p, s
Result: schedule σ
2. Form the following batches of σ:
• The other jobs are processed in single job batches.
3. Schedule the batches at the first available machine.

l m l m
4. Cmax (σ) = n−|M m
|
p + n−|M |
m − 1 s.
The best known algorithm for the maximum cardinality matching is in O(n2.5 ). Hence, also, the
Theorem 3.4. The problem Bm, sum|G = (V, E), b = 2, pi = p, s|Cmax reduces to the maximum
cardinality matching.
Proof:
Since all the processing times are equal to p, then to build an optimal schedule for the above problem,
it suffices to find a maximum matching M in the graph G, to minimize the number of batches for the
above problem and schedule the two-job batches at the first one because its processing time is equal
to 2p and then the batches of single job, at the first available machine.
l m l m l ′m l ′ m
|M | |M | n n
2 m p+ m −1 s m p+ m −1 s
. . .
M1 (J p , J p ) . . . (J p , J p ) (J p ) . . . (J p )
mod(|M |, m)
. . .
. . . . . .
. . . . . . . . . . .
. . . . . .
. . . . .
. . .
. . . . . (J p , J p ) (J p ) . . . (J p )
. . .
. . . . .
. . .
. . . . . (J p ) (J p ) (J p ) . . . (J p )
. . .
k
2
. . .
Mm (J p , J p ) . . . (J p ) (J p ) (J p ) . . . (J p )
. . .
Figure 1. Structure of the schedule ((J p , J p ) is a two-job batch and (J p ) a single job batch).
l m l m
The makespan of the two-job batches is equal to 2 |M |
p + |M |
− 1 s.
l m j k m m
|M |
Let k = 2 m − |M m
|
m − mod(|M |, m) , be the number of the free places (of length p)
( !
h j k
|M |
l m i
|M | 0 if mod(|M |, m) = 0
in the interval 2 m p, 2 m p . k =
2(m − mod(|M |, m)) otherwise
If the number
l m of the l remaining
m jobs (n − 2|M | jobs) is less than or equal to k/2 so the makespan is
|M | |M |
equal to 2 m p + m − 1 s, but if it’s between k/2 and k so the batch number of the previous
solution will increase by one.
If the cardinal matching of M is multiple of m or the number of remaining jobs (n − 2|M |
jobs) is greater than the free places k and mod1 (n′l, m) mless lthanmor equal
l to mmod(|M
l ′ m|, m)where
|M | n ′ |M |
n′ = n − 2|M | − k, so the makespan is equal to 2 m + m p + m + nm − 1 s, but
if it’s greater than mod(|M |, m) or mod(n′ , m) = 0, the batch number of the previous solution will
increase by one. (See Figure 1). ⊔
⊓
Algorithm 4 solves the problem Bm, sum|G = (V, E), b = 2, pi = p, s|Cmax .

The best known algorithm for the maximum cardinality matching is in O(n2.5 ). Hence, also, the
Before stating the next theorem, we start by describing the notations used and the Algorithm 5.
• Bi : the batch i.
• Jip : the job of processing time p of batch i.

1
The function mod(x, y) is the division remainder of x by y
Algorithm 4:
Input: G = (V, E), p, s
Result: schedule σ
3. Schedule the batches at the first available machine starting by the two-job batches.
4. The makespan
l equal
m to:
l m
Cmax = 2 m p + |M
|M |
m
|
− 1 s+
k


 s if < n − 2|M | ≤ k


 l ′m l ′ m 2
n n
 s+ m p+ m −1 s n′ > 0 and (mod(n′ , m) ≤ mod(|M |, m) or


 if
 l ′m l ′ m mod(|M |, m) = 0)

n n
2s + p + − 1 s n′ > 0 and (mod(n′ , m) > mod(|M |, m) or



 m m if


mod(n′ , m) = 0)

• Jiq : the job of processing time q of batch i.
• σ: the solution given by Algorithm 5.
• Z(σ): is the makespan of σ.
• np : the number of batches of processing time p of σ.
• nq : the number of batches of processing time q of σ.
• npq : the number of two-job batches, one of processing time p and the other of processing time
q of σ.
Algorithm 5 described bellow is the equivalent of Algorithm 1 in the case of two machines.
Theorem 3.5. The problem B2, max|G = (V, E), b = 2, pi ∈ {p, q}, s|Cmax is solvable in polyno-
mial time by Algorithm 6 in O(n9 ) time.
Proof:
It is clear that the only possible case to decrease the value of Cmax (σ) is to increase the number of
Algorithm 5: IS
Input: G = (V, E), p, q, s
Result: schedule σ
1. From graph G = (V, E), construct a new valued graph Hα = (G, α) where each edge
e = (Ji , Jj ) ∈ E is valued by α(e) = min{p(Ji ), p(Jj )} + s.
2. Find a maximum weighted matching M in the graph Hα .
4. Schedule the batches according to P 2|pi ∈ {p, q}|Cmax with only two processing times.
batches with processing time p and to decrease the number of batches with processing time q for σ.
To realize the decrease, we process two jobs with processing time q of two different batches in a
same batch. If one of the two batches is a singleton and the other is of type (J p , J q ), then absurd
with σ contains the maximum weighted matching, so to decrease nq , we use at least two batches
Bi = (Jip , Jiq ) and Bj = (Jjp , Jjq ) of σ (See Figure 2).
Jiq Jjq Jiq Jjq
=⇒
Jip Jjp Jip Jjp

nq = 2 and np = 0 nq = 1 and np = 2
Figure 2. Structure of the batches.
1. Case 1: nq even and np even

A lower bound on this problem is given by the value of an optimal solution of the problem on a
nq q + np p + (nq + np − 1)s − s
single machine minus an s and divided by two, LB = . If nq
2
nq np n
q np
and np are even, then Cmax (σ) = q+ p+ + − 1 s = LB. Therefore, σ is an
2 2 2 2
optimal solution.
2. Case 2: nq odd and np odd

Algorithm 6:
Input: G = (V, E), p, q, s
Result: σ ∗
1 Apply the Algorithm 5, let σ be the given solution;
2 σ ∗ := σ;
3 if ( (npq ≥ 2) and (np + nq is odd) and (2p + s ≥ q) ) then
4 for ( Jiq ∈ V and Jjq ∈ V ) do
5 for ( Jkp ∈ V and Jlp ∈ V such that (Jkp , Jiq ) ∈ E and (Jlp , Jjq ) ∈ E) do
E := E \ {(Jkp , J q ) and (Jlp , J q ), J q ∈ V };
′
6
7 for Jeq ∈ V and Jfq ∈ V do
8 if ((Jiq , Jeq ) ∈ E and (Jjq , Jfq ) ∈ E) then
V := V \ {Jiq , Jjq , Jeq , Jfq };
′
9
′ ′
10 Apply Algorithm 5 (G = (V ; E ), p, q, s);
′ ′
11 Let σ be the solution given by the Algorithm 5, add to σ the two batches
(Jiq , Jeq ) and (Jjq , Jfq ) at the time 0 and add q to Cmax (σ ) ;
′
′
12 if Cmax (σ ) < Cmax (σ ∗ ) then
′
13 σ ∗ := σ ;
14 end
15 end
16 end
17 end
18 end
19 else
20 σ is an optimal solution;
21 end
22 end
• Case 2.1: if 2p + s < q, then we cannot find two batches Bi = (Jip , Jiq ) and Bj =
(Jjp , Jjq ) with (Jiq , Jjq ) ∈ E, otherwise we will have a contradiction with σ constructed
by Algorithm 5, corresponding to the maximum weighted matching. So σ is an optimal
solution. (See Figure 3).
• Case 2.2: if 2p + s ≥ q, we suppose that we deleted from σ, a1 batches of processing
time q and we added (a1 + 1) batches of processing time p. Then the matching value
corresponds to these jobs in σ is equal to (2a1 p + 2a1 s), and its matching value in the new
solution σ1 is equal to a1 q +(a1 −1)p+(2a1 −1)s. We have by hypothesis 2a1 p+2a1 s ≥
a1 q + (a1 − 1)p + (2a1 − 1)s, so (a1 + 1)p + s ≥ a1 q, then:
• If a1 is even: suppose nq = 2K + 1 and np = 2Ca1 + 1, then Z(σ) = (K + 1)q +
Cp + (K + C)s and Z(σ1 ) = 2K−a 2
1
q + C + 2 + 2 p + (K + C + 1)s. Thus,
Z(σ) ≤ Z(σ1 ) if, and only if, a21 + 1 q ≤ a21 + 2 p + s. We have by hypothesis
q+s
Jiq Jjq Jiq Jjq
p+s p+s
Jip Jjp Jip Jjp
Case a: 2p + 2s ≥ q + s Case b: 2p + 2s ≤ q + s
Figure 3. Structure of the maximum weighted matching.
a1 q ≤ (a1 + 1)p + s, then a1 q − a21 − 1 q < (a1 + 1)p + s − ( a21 − 1)p because

p < q, so Z(σ) < Z(σ1 ).

• If a1 is odd: then Z(σ) = (K + 1)q + Cp + (K + C)s and Z(σ1 ) = 2K−a 1 +1

2 q+
2C+a1 +3 a1 +1

2
a1 +1
p + (K + C + 1)s. Thus, Z(σ) ≤ Z(σ1 ) if, and only if, a12−1 q ≤
2 + 1 p + s. We have
by hypothesis a1 q ≤ (a1 + 1)p + s, then a1 q − 2 q <
a1 −1
(a1 + 1)p + s − 2 p, so Z(σ) < Z(σ1 ).
Therefore σ is an optimal solution.
3. Case 3: nq even and np odd or nq odd and np even

• Case 3.1: if 2p + s < q, similar to case 2.1.
• Case 3.2: if 2p + s ≥ q, see Lemma 3.6 (here np + nq is odd).
Lemma 3.6. If np + nq is odd and if we delete, from σ, a1 batches of processing time q and we add
(a1 + 1) batches of processing time p, we obtain a new solution σ1 , such that Z(σ) > Z(σ1 ).
Proof:
Let n′q = nq − a1 and n′p = np + a1 + 1 be the new numbers of batches. There are four possible types
of scheduling depending on the parity of n′p and n′q , see Figure 4.
Consider the possible values of σ1 regarding the parity of np , nq and a1 , and we show that Z(σ) >
Z(σ1 ):
• nq is even and np is odd:

2K − a1 2C + a1 + 2
– If a1 is even, σ1 is of type 1 with Z(σ1 ) = q+ p+(K +C)s
2 2
a1 a1
< Kq + (C + 1)p + (K + C)s (because q > p), so Z(σ) > Z(σ1 ).
2 2
2K − a1 + 1 2C + a1 + 1
– If a1 is odd, σ1 is of type 4 with Z(σ1 ) = q+ p+
2 2
a1 − 1 a1 − 1
(K + C)s < Kq + (C + 1)p + (K + C)s (because q > p), so
2 2
Z(σ) > Z(σ1 ).
- Type 1: n′q = 2K and n′p = 2C with Z(σ) = Kq + Cp + (K + C − 1)s

q p
B1q . . . B2k−1 B1p . . . B2C−1
q p
B2q . . . B2k B2p . . . B2C
- Type 2: n′q = 2K and n′p = 2C + 1 with Z(σ) = Kq + (C + 1)p + (K + C)s

q p p
B1q . . . B2k−1 B1p . . . B2C−1 B2C+1
q p
B2q . . . B2k B2p . . . B2C
- Type 3: n′q = 2K + 1 and n′p = 2C with Z(σ) = Kq + (C + 1)p + (K + C)s

q q p
B1q . . . B2k−1 B2k+1 B3p . . . B2C−1
q p
B2q . . . B2k B1p B2p B4p . . . B2C
- Type 4: n′q = 2K + 1 and n′p = 2C + 1 with Z(σ) = (K + 1)q + Cp + (K + C)s

q q p p
B1q . . . B2k−1 B2k+1 B3p . . . B2C−1 B2C+1
q p
B2q . . . B2k B1p B2p B4p . . . B2C
Figure 4. Types of scheduling.
• nq is odd and np is even:

2K − a1 + 2 2C + a1
– If a1 is even, σ1 is of type 4 with Z(σ1 ) = q+ p+(K +C)s
2
2
a1 − 2 a1 − 2
< Kq + (C + 1)p + (K + C)s (because q> p), so Z(σ) > Z(σ1 ).
2 2

2K − a1 + 1 2C + a1 + 1
– If a1 is odd, σ1 is of type 1 with Z(σ1 ) = q+ p+
2 2
a1 − 1 a1 − 1
(K + C)s < Kq + (C + 1)p + (K + C)s (because q > p), so
2 2
Z(σ) > Z(σ1 ).
So ∀a1 , Z(σ) > Z(σ1 ). Therefore, σ is not an optimal solution of the problem. ⊔
⊓
Lemma 3.7. If we apply Algorithm 6 a second time to σ1 , then the makespan increases.
Proof:
If one between nq and np is even and the other is odd, (σ1 be the solution found at iteration 1 of
Algorithm 6, such that, we delete from σ, a1 batches of processing time q and we add (a1 + 1) batches
of processing time p), so, for all value of a1 , the schedule σ1 is the type 1 or the type 4. Let σm be the
P found if we apply the Algorithm 6, (m − 1) times to the solution σ1 . So, we delete from σ,
solution
α= m i=1 ai batches of processing time q and we add (α + m) batches of processing time p. So, for
all value of α and m, the schedule σm is of type 1 or type 2 or type 3 or type 4.
WePhave, 2ai p + 2ai s ≥ ai qP+ (ai − 1)p + (2ai − 1)s for i = 1, . . . , m. Thus, (ai + 1)p + s ≥ ai q.
Then, i=1 ((ai + 1)p + s) ≥ m
m
i=1 ai q. So, (α + m)p + ms ≥ αq.
The possible values for σm are:
• If nq is even and np is odd: if σm is of

2K − α 2C + α + m + 1 m−1
– type 1: Z(σm ) = q+ p+ K +C + s.
2 2 2

2K − α 2C + α + m + 2 m
– type 2: Z(σm ) = q+ p+ K +C + s.
2 2 2

2K − α − 1 2C + α + m + 3 m
– type 3: Z(σm ) = q+ p+ K +C+ s.
2 2 2

2K − α + 1 2C + α + m m−1
– type 4: Z(σm ) = q+ p+ K +C + s.
2 2 2
• If nq is odd and np is even: If σm is of

2K − α + 1 2C + α + m m−1
– type 1: Z(σm ) = q+ p+ K +C + s.
2 2 2

2K − α + 1 2C + α + m + 1 m
– type 2: Z(σm ) = q+ p+ K +C+ s.
2 2 2

2K − α 2C + α + m + 2 m
– type 3: Z(σm ) = q+ p+ K +C + s.
2 2 2

2K − α + 2 2C + α + m − 1
– type 4: Z(σm ) = q+ p+
2 2

m−1
K +C + s.
2
To show that Z(σ1 ) ≤ Z(σm ), we check all the possible cases:
• If nq is even and np is odd:

• σ1 is of type 1 and σm is of type 1 (subcase A11)

2K − a1 2C + a1 + 2 2K − α 2C + α + m + 1
q+ p+(K+C)s ≤ q+ p+
2 2 2 2
m−1 a1 − α − m + 1 m−1 a1 − α
K +C + s if, and only if, p− s≤ q.
2 2 2 2
Pm−1 Pm−1
From the hypothesis: i=1 ((ai +1)p+s) ≥ i=1 ai q, if we apply Algorithm 6 (m−2)
times to σ1 , (α−am +m−1)p+(m−1)s ≥ (α−am )q and we have M ini=1..m {ai } = am ,
then (am − a1 )p > (am − a1 )q, so (α − am + m − 1)p +(am − a1 )p +(m − 1)s >
a1 − α − m + 1 m−1 a1 − α
(α − am )q + (am − a1 )q we obtain p− s< q,
2 2 2
so Z(σ1 ) < Z(σm ).

2K − a1 2C + a1 + 2 2K − α 2C + α + m + 2
q+ p+(K+C)s ≤ q+ p
2 2 2 2
m a1 − α − m m a1 − α
+ K +C + s if, and only if, p− s ≤ q. From the
2 2 2 2
hypothesis: (α + m)p + ms ≥ αq, then (α + m − a1 )p + ms > (α − a1 )q, because
−a1 p > −a1 q,then

a1 − α − m m a1 − α
p− s< q, so Z(σ1 ) < Z(σm ).
2 2 2

2K − a1 2C + a1 + 2 2K − α − 1
q+ p + (K + C)s ≤ q+
2 2 2

2C + α + m + 3 m
p+ K +C + s
2 2
a1 − α − m − 1 m a1 − α − 1
if, and only if, p− s≤ q. From the hypothesis:
2 2 2
a1 − α − m − 1 m a1 − α − 1
(α + m)p + ms ≥ αq, then p− s< q, because
2 2 2
(1 − a1 )p > (1 − a1 )q, so Z(σ1 ) < Z(σm ).

2K − a1 2C + a1 + 2 2K − α + 1 2C + α + m
q+ p+(K + C) s ≤ q+ p
2 2 2 2

m−1
+ K +C+ s
2

a1 − α − m + 2 m−1 a1 − α + 1
if, and only if, p− s≤ q.
2 2 2
a1 − α − m m−1 a1 − α − 1
We have shown that p− s< q, then
2 2 2
a1 − α − m m−1 a1 − α − 1
p+p− s< q + q, so Z(σ1 ) < Z(σm ).
2 2 2

2K − a1 + 1 2C + a1 + 1 2K − α
q+ p + (K + C) s ≤ q+
2 2 2

2C + α + m + 1 m−1
p+ K +C+ s
2 2
a1 − α − m m−1 a1 − α − 1
2 2 2
From the hypothesis, (α − am + m − 1)p + (m − 1)s ≥ (α − am )q, then (α − am +
m − 1)p + (am − a1 + 1)p + (m − 1)s > (α − am )q + (am − a1 + 1)q, because
(am − a1 + 1)p > (am − a1 + 1)q, so Z(σ1 ) < Z(σm ).
• σ1 is of type 4 and σm is of type 2 (subcase A42), similar to subcase A13.


2K − a1 + 1 2C + a1 + 1 2K − α − 1
q+ p + (K + C) s ≤ q+
2 2 2

2C + α + m + 3 m
p+ K +C + s
2 2
a1 − α − m − 2 m a1 − α − 2
2 2 2
From the hypothesis: (α + m)p + ms ≥ αq, then (α + m)p + (2 − a1 )p + ms >
αq + (2 − a1 )q, because (2 − a1 )p > (2 − a1 )q, so Z(σ1 ) < Z(σm ).
• σ1 is of type 4 and σm is of type 4 (subcase A44), similar to subcase A11.
• If nq is odd and np is even:
• σ1 is of type 1 and σm is of type 1, similar to subcase A11.


⊔
⊓
From Lemma 1 and Lemma 2, we conclude that Algorithm 6 gives an optimal solution. As the
three nested loops require a time in O(n6 ) and the matching algorithm a time in O(n3 ), then Algorithm
6 requires a time in O(n9 ) but this complexity, calculated in the worst case, can be reduced. ⊔
⊓
4. Mathematical programming model
In this section, we present a mixed integer programming model (MILP) to solve the scheduling prob-
lem Bm, max|G = (V, E), b = 2, s|Cmax .
Let pbij = max{pi , pj } if the two jobs Ji and Jj are compatible and let A be the adjacency matrix
of the graph G = (V, E) such that:
(
1 if the jobs Ji and Jj are compatible, i, j = 1, . . . , n
aij =
0 otherwise
Decision variables: Define two types of variables,

(
1 if the jobs Ji and Jj are processed in a same batch on machine Mk ,
xijk =
0 otherwise
i < j = 1, . . . , n and k = 1, . . . , m.
(
1 if the job Ji is schedule on machine Mk as a single batch of jobs,
yik =
0 otherwise
i = 1 . . . , n and k = 1, . . . , m.
Linear model: The linear model of the problem Bm/G = (V, E), b = 2, s/Cmax is:
minimize Cmax
subject to
 Pm Pn


 k=1 j>i xijk ≤1 i = 1, . . . , n (1)




 Pm
k=1 xijk ≤ aij i < j = 1, . . . , n



 (2)





 Pm
k=1 yik ≤1 i = 1, . . . , n (3)









 Pm Pn Pm
j>i xijk =1− k=1 yik i = 1, . . . , n (4)



 k=1
 Pn Pn Pn
j>i pbij xijk + pi yik


i=1
Pi=1


 Pn Pn n
+s( i=1 j>i xijk + i=1 yik − 1) ≤ Cmax k = 1, . . . , m (5)










Cmax ≥ 0 (6)










xijk ∈ {0, 1} , yik ∈ {0, 1} i < j = 1, . . . , n





and k = 1, . . . , m (7)

Where
• Equations (1): indicate that each job is, at most, in one batch of two jobs on a single machine.
• Equations (2): ensure that every two compatible jobs are, at most, in one batch of two jobs on a
single machine.
• Equations (3): ensure that each single job batch is in at most one machine.
• Equations (4): indicate that each job is in one batch on one machine.
Pn Pn
• i=1 j>i pbij xijk : the sum of the batch processing times with two jobs on each machine.
Pn
• i=1 pi yik : the sum of the batch processing times with a single job on each machine.
• s( ni=1 nj>i xijk + ni=1 yik − 1): the sum of the batch preparation times on each machine.
P P P
• Equations (6): ensure that the corresponding decision variable must be positive.
• Equations (7): ensure that the corresponding decision variables are binary.
The number of variables and the number of constraints of a linear mathematical model are two
indices by which we can measure the dimension and the efficiency of the given model. The number of
n+1
variables is mn( ) binary variables and one continuous variable. The total number of constraints
2
n+5
is (n( 2 ) + m).
Performance of the linear formulation

We study in this section the performance of the linear formulation that was tested with IBM ILOG
CPLEX solver (20.1.0). For different values of n ∈ {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200}, we
considered 50 of randomly generated instances solved in less than 900 s for each density (low, medium
and high) of the graph G.
time (s)
time (s)
22-
20-
20-
18-
18-
16-
16-
14-
14-
12-
12-
10-
10-
8-
8-
6-
6-
4-
4-
2-
— — — — —
2-
density (%) — — — — — — — — — —
12.5 25 50 75 100 n
10 20 30 40 50 60 70 80 90 100
Figure 5. Performance of the model with n = 50. Figure 6. Performance of the model with low density.
time (s) time (s)

100-
70- -
- 90-
60-
-
80-
- -
50- 70-
- -
60-
40- -
- 50-
-
30- 40-
- -
20- 30-
- -
20-
10- -
- 10-
— — — — — — — — — — —
-
n — — — — — — — —
n
— —
10 50 100 200 10 20 30 40 50 60 70 80 90 100
Figure 7. Performance of the model with medium Figure 8. Performance of the model with high den-
density. sity.
In Figure 5 is pictured the mean time to obtain an optimal solution, for a fixed instance size n = 50,
for each density. In Figures 6, 7 and 8 are pictured the mean time for following density, low, medium
and high respectively. The above linear formulation solved almost all the instances in a reasonable
amount of time in the mean. We can see that in the case of fixed instances size n, the mean time to
obtain an optimal solution increases in parallel with the density of the compatibility graph, see Figure
5. As expected, Figures 6, 7 and 8 indicated that for a fixed density of the graph G, the mean time to
obtain an optimal solution increases in parallel with the number of jobs.
In conclusion, notice that for n = 200, CPLEX solver solves 60% of the generated instances in
900 seconds, for n = 100 it solves 83% and for n = 50 it solves 100% in few time. All the tests
carried out have shown the effectiveness of the model.
5. Heuristics for the problem Bm, max|G = (V, E), b = 2, s|Cmax

In this section, we propose two heuristics H1 and H2 for the sake of obtaining approximate solutions
to the problem Bm, max|G = (V, E), b = 2, s|Cmax . The pseudo-code of each heuristic is preceded
by a brief description of the idea behind it.
5.1. Maximum weighted matching based heuristic (H1)

This heuristic starts with an initial feasible solution corresponding to the maximum weighted matching
in the graph Hα = (G, α), where each edge is valued by the minimum between the processing times
of these corresponding jobs. We schedule the batches at the first available machine according to the
decreasing order of their processing times. At each iteration of the heuristic algorithm, we make a
random permutation between the jobs of the batches respecting the compatibility constraint, we swap
randomly the batches of the machines and we save the best obtained solution.
5.2. Long processing times heuristic (H2)

This heuristic based on the sequence of jobs ordered according to the decreasing order of their pro-
cessing times. We select the job at the top of the list and place it in the first available batch respecting
the compatibility constraint. If the job cannot be processed in any one of the existing batches, create
a new batch. We schedule the batches on the first available machine and for each iteration, we swap
randomly two batches of the two machines. We save the best solution.
6. Experimental results
In this section, we present the results of the computational experiments performed. We first give
details about both software and hardware setup used to run those experiments. Then, we examine the
performance of the heuristic approaches H1 and H2.
We coded the above heuristics in C++ language. The tests were executed on a personal com-
puter with an Intel(R) Core(TM) i3-5010U 2.10GHz processor with 4GB of RAM and run under the
Windows 7 operating system. We constructed problem instances with randomly generated data. We
considered the number of jobs n ∈ {10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400}, the number
of machines m ∈ {2, 3, 4, 5} and we have used the parameter d ∈ {12.5, 25, 50, 75, 100} which is
the density (in percentage) of the compatibility graph. The processing times and the set-up times are
randomly generated in [10, 100] and {2, 3, 4} respectively. For each number n of jobs, we considered
50 of randomly generated instances according to the uniform distribution.
Algorithm 7: H1
Result: σ1
1 Apply the Algorithm 5 (let Cmax be the value of the solution given by Algorithm IS);
k
2 Let C = {Mk , Cmax = Cmax };
3 for each Mk ∈ C do
4 for each two batches Bi = (Ji1 , Ji2 ) and Bj = (Jj1 , Jj2 ) in Mk do
5 if p1i < p2j and p1j < p2i then
l
6 if (Ji2 , Jj2 ) ∈ E and there is a machine Ml where Cmax + M in{p1i , p1j } + s ≤ Cmax then
7 Replace the batches Bi and Bj of Mk by the batch (Ji2 , Jj2 ) and a batch that contains one of
the jobs Ji1 or Jj1 of the maximum processing time, and schedule the other job on the
machine Ml ;
8 end
9 end
10 end
r
11 Select a machine Mr such that Cmax < Cmax and two batches Bi in Mk and Bj in Mr ;
1 2 1 2
12 if pi < pj and pj < pi then
l
13 if (Ji2 , Jj2 ) ∈ E and there is a machine Ml where Cmax + M in{p1i , p1j } + s ≤ Cmax then
14 Replace the batch Bi by a batch that contains one of the jobs Ji1 or Jj1 of the maximum processing
time;
15 Replace the batch Bj by the batch (Ji2 , Jj2 );
16 Add to the machine Ml a batch that contains the other job;
17 Save the best solution;
18 end
19 end
20 end
21 for every two machines Mk and Ml do
22 Select randomly a job Jia ∈ Bi and a job Jjb ∈ Bj ;
23 if (Jia , Jjb ) ∈ E then
24 Select randomly a number r ∈ {k, l}, and add the batch (Jia , Jjb ) to the machine Mr and add to the
other machine a batch which contains the two remaining jobs if they are adjacent, otherwise schedule
each one in a batch;
26 end
27 end
28 Form a batch list of a single job;
29 Arrange the jobs of the list in the decreasing order of their processing times;
30 Select the job at the top of the list and place it at the first available batch. If the job cannot be processed in any one
of the existing batches, create a new batch;
31 Reschedule all batches on the first available machine according to the decreasing order of their processing times;
32 for counter = 1..iter do
33 Select randomly two machines Mk and Ml ;
34 Select randomly a batch Bi ∈ Mk and a batch Bj ∈ Ml ;
35 Swap the two batches of the two machines;
37 end
Table 1 that summarizes the experimental study shows the efficiency of H1 and H2. We recorded
the minimum, mean and maximum errors for the results produced by the heuristics. The performance
Algorithm 8: H2
Result: σ2
1 Arrange the jobs in the decreasing order of their processing times (resulting in jobs
J1 , ..., Jn );
2 h := 1; Bh := J1 ;
3 for i = 2 to n do
4 if (there exists a batch (let Bj )such that |Bj | = 1 and the job of this batch is compatible
with the job Ji ) then
5 Bj := Bj ∪ Ji ;
6 else
7 h := h + 1;
8 Bh := Ji ;
9 end
10 end
11 end
12 for counter = 1 to iter do
13 Select randomly two machines Mk and Ml ;
14 Select randomly a batch Bi ∈ Mk and a batch Bj ∈ Ml ;
15 Swap the two batches of the two machines;
17 end
ratio of a solution σ is denoted by GAP (σ) = (Cmax (σ) − BS) /BS, where Cmax (σ) and BS
are the maximum completion times of the proposed methods and the best solution value obtained
by Cplex, respectively. The running times of the algorithms were reported in minimum, mean and
maximum in seconds, and for each heuristic we calculated the number of best solutions (#sol).
The experimental results presented in Table 1 and Figures 9, 10 and 11, clearly show that H1 and
H2 give near-optimal solutions, and that H1 is more efficient than H2 in the terms of the number of
the best solutions and gap. However, it is clear that H1 consumes much more time, compared to H2,
to provide an approximate solution. Prevented us from using H2.
7. Conclusion
We have considered in this paper the problem of scheduling on batch processing identical machines.
We have established some polynomial results for the problem of minimizing the makespan on a single
and several machines and have presented Polynomial time algorithms to optimally solve the problem
when the capacity of batch equal to two. We have presented a linear formulation and we study their
performance. We also developed two heuristic approaches to solve the general problem. We conducted
numerical experimental tests to study their performance by comparing them to the best solution value
Table 1. The performance of the heuristics.

n Fnct #Sol H1 time(s) H1 GAP1 #Sol H2 time(s) H2 GAP2
10 Min 50 11.201 0 50 2,246 0
Mean 50 15.667 0 50 2,6886 0
Max 50 24.539 0 50 3,229 0
20 Min 49 12.745 0 15 2,761 0
Mean 49 16.542 0.002 15 3,365 0.010
Max 49 35.459 0.020 15 4,352 0.062
30 Min 46 15.257 0 36 3.058 0
Mean 46 36.108 0.001 36 3.727 0.003
Max 46 44.304 0.012 36 4.477 0.020
40 Min 49 33.306 0 2 3,463 0
Mean 49 41.086 0.003 2 4,385 0.011
Max 49 51.121 0.023 2 5,164 0.040
50 Min 49 37.190 0 4 4,181 0
Mean 49 49.613 0.002 4 5,259 0.020
Max 49 61.979 0.007 4 6,536 0.045
60 Min 43 44.866 0 38 4,259 0
Mean 43 58.135 0.001 38 5,662 0.002
Max 43 69.888 0.011 38 7,145 0.014
70 Min 46 30.576 0 12 4,992 0
Mean 46 46.303 0.002 12 6,634 0.007
Max 46 75.067 0.010 12 7,722 0.018
80 Min 49 34.133 0 7 5,678 0
Mean 49 54.321 0.002 7 7,592 0.013
Max 49 80.637 0.010 7 9,391 0.031
90 Min 19 38.423 0 45 5,288 0
Mean 19 49.759 0.002 45 7,813 0.001
Max 19 69.561 0.011 45 9,469 0.005
100 Min 47 41.324 0 8 5,460 0.003
Mean 47 89.283 0.003 8 8,030 0.010
Max 47 109.777 0.010 8 10,312 0.019
200 Min 40 130.962 0.0003 14 9,266 0.0006
Mean 40 309.600 0.002 14 13,772 0.004
Max 40 534.722 0.009 14 19,968 0.012
300 Min 13 554.984 0.0003 48 16,759 0.0002
Mean 13 1305.073 0.002 48 24,172 0.001
Max 13 3929.04 0.005 48 32,869 0.005
400 Min 42 1542,734 0 14 21,746 0.0009
Mean 42 4995,794 0.001 14 33,706 0.003
Max 42 12955,851 0.005 14 47,330 0.004
obtained by Cplex. For future research, we can studied the complexity of the NP-hard problems for
three values of processing times in the case of job multiplicity. One could also explore exact methods
to solve the general case of the problem and compare their performance with the linear formulation
proposed above.
time (s) #Sol

GAP
5000 - H1 50 - 0.02 -
45 - H1
4000 - 40 -
35 - 0.013 -
3000 - 30 - -
25 - 0.01 -
2000 - 20 - 0.007 -
15 - -
1000 - 10 - H2 0.003 -- H2
500 -- 5- 0.001- — — — — — H1
100 - — — — — — — — H2n
— ————— — — —
— — —
n
20 100 200 300 400 n 20 100 200 300 400
20 100 200 300 400
Figure 9. H1 vs. H2 for times. Figure 11. H1 vs. H2 for GAP.

Figure 10. H1 vs. H2 for #Sol.
References
[1] Brucker P, Gladky A, Hoogeveen H, Kovalyov M, Potts C, Tautenhahn T, Van De Velde S. Scheduling a
batching machine. Journal of Scheduling, 1998. 1:31–54.
[2] Potts C, Kovalyov Y. Scheduling with batching, A review. European Journal of Operational Research,
2000. 120:228–249.
[3] Dobson G, Nambinadom R. The batch loading and scheduling problem. Research Report, Simon School
of Business Administration, University of Rochester, NY, 1992.
[4] Kubiak W, Jolai Ghazvini F. Minimizing earliness/tardiness criteria on a batch processing machine with
job families. Proc. Second Annual Internat. Conf. Industrial Engineering, 1997. 2:785–790.
[5] Mehta S, Uzsoy R. Minimizing total tardiness on a batch processing machine with incompatible job
families. IIE Trans. Schedul, Logistics, 1998. 31:165–178.
[6] Uzsoy R. Scheduling batch processing machines with incompatible job familie. International Journal of
Production Research, 1995. 33:2685–2708.
[7] Chandru V, Lee C, Uzsoy R. Minimizing total completion time on batch processing machines. Interna-
tional Journal of Production Research, 1993. 31:2097–2121.
[8] Hochbaum D, Landy D. Algorithms and heuristics for scheduling semiconductor burnin operations. Re-
search Report ESRC 94-8, University of California, Berkeley, USA, 1994.
[9] Mönch L, Fowler J, Dauzère-Pérès S, Mason S, Rose O. A survey of problems, solution techniques, and
future challenges in scheduling semiconductor manufacturing operations. Journal of scheduling, 2011.
14(6):583–599.
[10] Fowler J, Mönch L. A survey of scheduling with parallel batch (p-batch) processing. European Journal
of Operational Research, 2022. 298(1):1–24.
[11] Boudhar M, Finke G. Scheduling on a batch machine with job compatibilities. Belgian Journal of Oper-
ations Research, Statistics and Computer Science, 2000. 40:69–80.
[12] Boudhar M. Scheduling a batch processing machine with bipartite compatibility graphs. Mathematical
Methods of Operations Research, 2003. 57(513–527):3.
[13] Boudhar M. Dynamic scheduling on a single batch processing machine with split compatibility graphs.
Journal of Mathematical Modelling and Algorithms, 2003. 2(1):17–35.
[14] Boudhar M. Scheduling on a batch processing machine with split compatibility graphs. Journal of Math-
ematical Modelling and Algorithms, 2005. 4(4):391–407.
[15] Finke G, Jost V, Queyranne M, Sebo A. Batch processing with interval graph compatibilities between
tasks. Discrete Applied Mathematics, 2008. 156:556–568.
[16] Muter I. Exact Algorithms to Minimize Makespan on Single and Parallel Batch Processing Machines.
European Journal of Operational Research, 2020. 285(2):470–483.
[17] Wang Q, Tian J, Fu R, Yao X. Online algorithms for scheduling on batch processing machines with
interval graph compatibilities between jobs. Theoretical Computer Science, 2017. 700:37–44.
[18] Wang Y. Scheduling Optimization for Batch Processing Machines Using Advanced Genetic Algorithm.
Journal of Physics: Conference Series, 2021. 1883:012016.
[19] Oulamara A, Kovalyov M, Finke G. Scheduling a no-wait flowshop with unbounded batching machines.
IIE Transactions on Scheduling and Logistics, 2005. 37(8):685–696.
[20] Bellanger A, Oulamara A. Scheduling hybrid flowshop with parallel batching machines and compatibili-
ties. Computers & Operations Research, 2008. 36(6):1982–1992.
[21] Oulamara A, Finke G, Kamgaing K. Flowshop scheduling problem with a batching machine and task
compatibilities. Computers & Operations Research, 2009. 36:391–401.
[22] Lin B, Cheng T. Batch scheduling in the no-wait two-machine flowshop to minimize the makespan.
Computers & Operations Research, 2001. 28:613–624.
[23] Oulamara A, Finke G. Flowshop problems with batch processing machines. International Journal of
Mathematical Algorithms, 2001. 2:269–287.
[24] Even S, Kariv O. An O(n2.5 ) Algorithm for maximum matching in general graph. 16th Annual Symposium
on Foundations of Computer Science (sfcs 1975), 13-15 October, USA, 1975.

Compatibility Graphs in Scheduling On Batch Processing Machines

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Compatibility Graphs in Scheduling On Batch Processing Machines

Uploaded by

Copyright:

Available Formats

1

arXiv:2309.02601v1 [cs.DM] 5 Sep 2023

Compatibility graphs in scheduling on batch processing machines

Khaoula BOUAKAZ and Mourad BOUDHAR

Keywords: batch scheduling, makespan, compatibility graph, complexity, matching

3.1. Case of single machine

2. Find a maximum weighted matching M in the graph Hα .

3. Form the batches of σ:

Algorithm 1 solves the problem B1, max|G = (V, E), b = 2, s|Cmax .

Algorithm 2 solves the problem B1, sum|G = (V, E), b = 2, s|Cmax .

2. Form the batches of σ:

3.2. Case of several machines

Algorithm 3 solves the problem Bm, max|G = (V, E), b = 2, pi = p, s|Cmax .

2. Form the following batches of σ:

3. Schedule the batches at the first available machine.

Algorithm 4 solves the problem Bm, sum|G = (V, E), b = 2, pi = p, s|Cmax .

• Jip : the job of processing time p of batch i.

2. Form the following batches of σ:

• Jiq : the job of processing time q of batch i.

• σ: the solution given by Algorithm 5.

• Z(σ): is the makespan of σ.

• np : the number of batches of processing time p of σ.

• nq : the number of batches of processing time q of σ.

2. Find a maximum weighted matching M in the graph Hα .

3. Form the following batches of σ:

Jiq Jjq Jiq Jjq

Jip Jjp Jip Jjp

Figure 2. Structure of the batches.

1. Case 1: nq even and np even

2. Case 2: nq odd and np odd

Jip Jjp Jip Jjp

Figure 3. Structure of the maximum weighted matching.

p < q, so Z(σ) < Z(σ1 ).

3. Case 3: nq even and np odd or nq odd and np even

- Type 1: n′q = 2K and n′p = 2C with Z(σ) = Kq + Cp + (K + C − 1)s

- Type 2: n′q = 2K and n′p = 2C + 1 with Z(σ) = Kq + (C + 1)p + (K + C)s

- Type 3: n′q = 2K + 1 and n′p = 2C with Z(σ) = Kq + (C + 1)p + (K + C)s

- Type 4: n′q = 2K + 1 and n′p = 2C + 1 with Z(σ) = (K + 1)q + Cp + (K + C)s

Figure 4. Types of scheduling.

• nq is odd and np is even:

The possible values for σm are:

• If nq is even and np is odd: if σm is of

• If nq is odd and np is even: If σm is of

To show that Z(σ1 ) ≤ Z(σm ), we check all the possible cases:

• If nq is even and np is odd:

• σ1 is of type 1 and σm is of type 1 (subcase A11)

• σ1 is of type 1 and σm is of type 2 (subcase A12)

• σ1 is of type 1 and σm is of type 3 (subcase A13)

• σ1 is of type 1 and σm is of type 4 (subcase A14)

• σ1 is of type 4 and σm is of type 1 (subcase A41)

• σ1 is of type 4 and σm is of type 2 (subcase A42), similar to subcase A13.

• If nq is odd and np is even:

• σ1 is of type 1 and σm is of type 1, similar to subcase A11.

• σ1 is of type 4 and σm is of type 3, similar to subcase A43.

• σ1 is of type 4 and σm is of type 4, similar to subcase A11.

4. Mathematical programming model

Decision variables: Define two types of variables,

Performance of the linear formulation

time (s) time (s)

5. Heuristics for the problem Bm, max|G = (V, E), b = 2, s|Cmax

5.1. Maximum weighted matching based heuristic (H1)

5.2. Long processing times heuristic (H2)