# Scheduling Jobs with Maintenance Subject to Load-Dependent Duration on a Single Machine

Authors: Yawei Qi; Long Wan; Zhigang Yan
Journal: Mathematical Problems in Engineering
 (2015)

---

## Abstract

This paper investigates a scheduling problem on a single machine with maintenance, in which the starting time of the maintenance is given in advance but its duration depends on the load of the machine before the maintenance. The goal is to minimize the makespan. We formulate it as an integer programming model and show that it is NP-hard in the ordinary sense. Then, we propose an FPTAS and point out that a special case is polynomial solvable. Finally, we design fast heuristic algorithms to solve the scheduling problem. Numerical experiments are implemented to evaluate the performance of the proposed heuristic algorithms. The results show the proposed heuristic algorithms are effective.


---

## Body

## 1. Introduction

We consider the following scheduling problem. Given a set of jobsJ
=
{
J
1
,
J
2
,
…
,
J
n
} to be nonpreemptively processed on a single machine, all of which are available at time zero. To prevent the machine breakdown, we must start maintenance at a prefixed time, but the duration of maintenance depends on the load of the machine before the maintenance, that is, the sum of processing times of jobs that is scheduled before the maintenance, which is a nonnegative and nondecreasing function on the load. The goal is to schedule all the jobs to minimize the maximum completion time (makespan).For a given schedule, writep
j for the processing time and C
j for the completion time of job J
j, j
=
1,2
,
…
,
n, respectively. Let s denote the starting time of maintenance, which is given in advance, and let l denote the load of the machine before the maintenance and let d denote the duration of maintenance. Then, d
=
f
(
l
), where f
(
·
) is a nonnegative and nondecreasing function on l (without loss of generality, we assume that function f
(
·
) can be computed in polynomial time). Furthermore, let C
m
a
x
(
=
m
a
x
j
=
1,2
,
…
,
n
C
j
) denote the maximum completion time (i.e., makespan). Using the three-field notation proposed by Graham et al. [1], we denote our problem as 1, L
D
M
∥
C
m
a
x, where “LDM” denotes the maintenance subject to load-dependent duration.As a practical example, consider the casting production in steel-making plant [2], in which the steel slabs used for downstream hot rolling operation are melted by the caster. Each steel slab can be viewed as a job and the caster can be viewed as a machine. At a given time, we must refill the fuels for the caster, which can be regarded as maintenance. The time for refilling the fuels is its duration, which depends on the consumed fuels before the maintenance.The above problem roughly falls into a class of scheduling problem which is referred to as scheduling with machine unavailable constraints. Since 1996, scheduling with machine unavailable constraints has been investigated extensively. For the related surveys, we refer the readers to Schmidt [3] and Ma et al. [4]. In the following, we only review the previous works very related to our problem. Lee [5] considered the scheduling problem with unavailable intervals on a single machine, in which the starting times and the durations of the unavailable intervals are given in advance with the goal to minimize the makespan and showed the problem is NP-hard with one unavailable interval and strong NP-hard with multiple unavailable intervals. He et al. [6] proposed a fully polynomial time approximation scheme with one unavailable interval for the problem proposed by Lee [5]. Breit et al. [7] showed that no polynomial time approximation algorithm with a fixed performance ratio exists with two intervals for the problem proposed by Lee [5]. Wu and Lee [8], Gawiejnowicz [9], and Ji et al. [10] extended the problem proposed by Lee [5] to job deterioration case, where the processing time of a job is a simple linear function of its starting time. For other related problems involving machine unavailable constraints, see Lee [11], Lee et al. [12], Hwang et al. [13], Liao et al. [14], Liao and Sheen [15], Zhong et al. [16], Wan [17], Yin et al. [18], Yin et al. [19], and Yin et al. [20].All of the above reviewing models assume that the duration of maintenance is fixed. But in our model, we assume that the duration is variable, which depends on the load of the machine before the maintenance. As pointed in the practical example, such assumption captures the real setting in steel-making process and our problem extends the previous models.The paper is organized as follows. In Section2, we formulate our problem as a integer programming model. In Section 3, we show that our problem is NP-hard and propose an FPTAS for it. In Section 4, we point out that a special case of our problem is polynomially solvable. Finally, we derive the fast heuristic algorithms and carry out the numerical experiment to evaluate their performance in Section 5. Some concluding remarks are given in Section 6.


## 2. Mathematical Model

In this section, the problem1, L
D
M
∥
C
m
a
x is formulated as an integer programming model. The decision variable x
j is a 0-1 variable, j
=
1,2
,
…
,
n. If x
j
=
1, then job J
j is scheduled before the maintenance, j
=
1,2
,
…
,
n. Otherwise, job J
j is scheduled after the maintenance, j
=
1,2
,
…
,
n. The proposed model is presented as follows.Integer programming model is(1)
O
b
j
e
c
t
i
v
e
f
u
n
c
t
i
o
n


:
M
i
n
i
m
i
z
e
C
m
a
x
(2)
S
u
b
j
e
c
t
t
o


:
∑
j
=
1
n
‍
x
j
p
j
≤
s
(3)
S
u
b
j
e
c
t
t
o
:
C
m
a
x
=
s
+
f
∑
j
=
1
n
‍
x
j
p
j
+
∑
j
=
1
n
‍
1
-
x
j
p
j
(4)
S
u
b
j
e
c
t
t
o
:
x
j
∈
0,1
,
j
=
1,2
,
…
,
n
.The objective function (1) minimizes the makespan, that is, the maximum completion time of the final job. Constraint (2) denotes the sum of processing times of jobs scheduled before the maintenance no larger than the starting time of the maintenance. Constraint (3) denotes the completion time of the final job. Constraint (4) indicates that the range of the decision variables is 0 or 1.


## 3. An FPTAS

In this section, we first state the computational complexity for our problem. Lee [5] showed that the scheduling problem with an unavailable fixed interval on a single machine to minimize the makespan is NP-hard, which can be viewed as a special case of our problem with the fixed-length duration. Therefore, our general problem 1
,
L
D
M
∥
C
m
a
x is also NP-hard. Accordingly, we have the following theorem.Theorem 1.
The problem1, L
D
M
∥
C
m
a
x is NP-hard.Next, we derive a fully polynomial time approximation scheme (FPTAS) for our problem based on the classical 0-1 Min-Knapsack Problem (Min-KP). For completeness, we describe Min-KP in advance here. Given a knapsack and a set of items, the size of the knapsack is given; associated with each item is a given size and a given profit. The problem is to select a subset of items into knapsack so as to minimize the total profit of all unselected items. Kellerer et al. [21] showed that there exists an FPTAS for solving Min-KP.We now propose an FPTAS for problem1, L
D
M
∥
C
m
a
x based on the FPTAS to Min-KP.Algorithm H.Step
1. Let ε
^ be a given positive constant and s
1
=
m
i
n
j
∈
{
1,2
,
…
,
n
}
p
j. Compute a series of s
i such that f
(
s
i
)
=
f
(
s
1
)
(
1
+
ε
^
)
i, i
=
2
,
…
,
k
-
1 with k
-
1
=
l
o
g
1
+
ε
^
f
(
s
)
-
l
o
g
1
+
ε
^
f
(
s
1
). Let s
0
=
0, s
k
=
s.Step
2. For each s
i, i
=
0,1
,
2
,
…
,
k, construct a corresponding Min-KP(i) as follows. Each job in an instance for problem 1, L
D
M
∥
C
m
a
x is corresponding to a item. The size and the profit of each item are the processing time of its corresponding job. The size of the knapsack is s
i.Step
3. Invoke the FPTAS for each constructed Min-KP(i), i
=
0,1
,
2
,
…
,
k [21]; then, we obtain the corresponding items that are selected into the knapsack. Denote them as a corresponding job subset J
b
i. Construct a schedule π
(
i
), where the jobs in J
b
i are scheduled before the maintenance in an arbitrary order, and the remaining jobs J
∖
J
b
i are scheduled after the maintenance in an arbitrary order. Let C
m
a
x
(
π
(
i
)
) denote the corresponding objective value, i
=
0,1
,
2
,
…
,
k.Step
4. From all the constructed schedule π
i, i
=
0,1
,
2
,
…
,
k, we choose the schedule with the minimal objective value as the output. Denote it as π; that is, (5)
C
m
a
x
π
=
m
i
n
i
=
0,1
,
2
,
…
,
k
C
m
a
x
π
i
.Next, we show that AlgorithmH is an FPTAS for problem 1, L
D
M
∥
C
m
a
x.Letπ
∗ denote an optimal schedule and let l
∗ denote the sum of processing times of jobs scheduled before the maintenance in the optimal schedule π
∗. Let P
=
∑
j
=
1
n
‍
p
j. Then, the makespan of the optimal schedule π
∗ is equal to s
+
f
(
l
∗
)
+
P
-
l
∗; that is, C
m
a
x
(
π
∗
)
=
s
+
f
(
l
∗
)
+
P
-
l
∗. We split the interval [
0
,
s
] into a series of subintervals 0
,
s
1
,
s
1
,
s
2
,
…
,
[
s
k
-
1
,
s
k
]. Clearly, there exists a subinterval [
s
i
-
1
,
s
i
] such that s
i
-
1
≤
l
∗
≤
s
i, i
=
1,2
,
…
,
k. Consider the constructed schedule π
(
i
); let l
i denote the sum of processing times of jobs scheduled before the maintenance in the schedule π
(
i
). Then, the makespan of the schedule π
(
i
) is equal to s
+
f
(
l
i
)
+
P
-
l
i; that is, C
m
a
x
(
π
(
i
)
)
=
s
+
f
(
l
i
)
+
P
-
l
i. According to the choice of s
i, we know f
(
l
i
)
≤
(
1
+
ε
)
f
(
l
∗
). Furthermore, we have P
-
l
i
≤
(
1
+
ε
)
(
P
-
l
∗
), because the schedule π
(
i
) is obtained by an FPTAS for Min-KP(i) and π
∗ is corresponding to a feasible solution for Min-KP(i). In the end, we have s
+
f
(
l
i
)
+
P
-
l
i
≤
(
1
+
ε
)
(
s
+
f
(
l
∗
)
+
P
-
l
∗
); that is, C
m
a
x
(
π
(
i
)
)
≤
(
1
+
ε
)
C
m
a
x
(
π
∗
). Consequently, C
m
a
x
(
π
)
≤
C
m
a
x
(
π
(
i
)
)
≤
(
1
+
ε
)
C
m
a
x
(
π
∗
). For the computation for each s
i, since f
(
·
) is nonnegative and nondecreasing and can be computed in polynomial time, by binary search it needs at most l
o
g
2
s time. Thus, in all it needs at most l
o
g
2
f
(
s
)
l
o
g
2
s time. Invoking each Min-KP(i) needs polynomial time. Thus, Algorithm H needs polynomial time.With the above argument, we have the following theorem.Theorem 2.
There exists an FPTAS for problem1
,
L
D
M
∥
C
m
a
x.


## 4. A Special Case

Now, we consider a special case for our problem that the functionf
(
·
) is differential and (
d
f
/
d
l
)
(
·
)
≥
1. From the expression on C
m
a
x in (3), we know(6)
C
m
a
x
=
s
+
f
∑
j
=
1
n
‍
x
j
p
j
+
∑
j
=
1
n
‍
1
-
x
j
p
j
=
s
+
f
∑
j
=
1
n
‍
x
j
p
j
-
∑
j
=
1
n
‍
x
j
p
j
+
P
.Applying the well-known Mean-value Theorem [22], we have C
m
a
x
=
s
+
P
+
f
(
0
)
+
(
(
d
f
/
d
l
)
(
η
)
-
1
)
∑
j
=
1
n
x
j
p
j, where 0
<
η
<
∑
j
=
1
n
x
j
p
j. Because (
d
f
/
d
l
)
(
·
)
≥
1 and s
+
P
+
f
(
0
) is constant, to minimize C
m
a
x, we set all the x
j, j
=
1,2
,
…
,
n, to 0, that is, x
j
=
0, j
=
1,2
,
…
,
n, which implies that we schedule all the jobs after the maintenance. The optimal makespan is equal to s
+
f
(
0
)
+
P.


## 5. Heuristic Algorithms and Numerical Experiments

Although the integer programming model provides the optimal solution, Theorem1 indicates that the existence of a polynomial time algorithm for solving our problem is impossible. So designing fast heuristic algorithm to obtain near-optimal solution is reasonable. In this section, we propose heuristic algorithms to find approximate solutions. Numerical experiments are implemented to evaluate the effectiveness of these proposed heuristic algorithms.Heuristic 1 (H1).
Step
1. Order the jobs as J
1
,
J
2
,
…
,
J
n according to nondecreasing processing time; that is, p
1
≤
p
2
≤
⋯
≤
p
n.
Step
2. Compute the value k such that ∑
j
=
1
k
‍
p
j
≤
s
≤
∑
j
=
1
k
+
1
‍
p
j.
Step
3. Construct a series of schedules π
i, i
=
1,2
,
…
,
k, where the jobs scheduled before the maintenance in π
i are J
1
,
J
2
,
…
,
J
i and the remaining jobs are scheduled after the maintenance. Construct schedule π
0, where all the jobs are scheduled after the maintenance in π
0.
Step
4. From all the schedules π
0, π
i, i
=
1,2
,
…
,
k, choose the best as the output.Heuristic 2 (H2).
Step
1. Order the jobs as J
1
,
J
2
,
…
,
J
n according to nonincreasing processing time; that is, p
1
≥
p
2
≥
⋯
≥
p
n.
Step
2. Compute the value l such that ∑
j
=
1
l
‍
p
j
≤
s
≤
∑
j
=
1
l
+
1
‍
p
j.
Step 3. Construct a series of schedules π
i, i
=
1,2
,
…
,
l, where the jobs scheduled before the maintenance in π
i are J
1
,
J
2
,
…
,
J
i and the remaining jobs are scheduled after the maintenance. Construct schedule π
0, where all the jobs are scheduled after the maintenance in π
0.
Step 4. From all the schedules π
0, π
i
,
i
=
1,2
,
…
,
l, choose the best as the output.The heuristic algorithms H1 and H2 are coded in MATLAB language and executed on the computer with 1 G RAM and 512 KB L2 cache. For the experiments, we choose the following parameters to generate randomly the test problems:number of jobs (n): 50, 100, 200, 400;
the starting time of the maintenance (
s
): 10, 20, 40, 60;
processing times of jobs: generated from the discrete uniform distribution with range [
1,30
];
the duration of the maintenance (d
=
f
(
l
)): 2
+
l
/
2
,
5
+
l
/
3
,
10
+
l
/
4
,
30
+
l
/
8.To evaluate the performance of the heuristic algorithms, we adopt the trivial lower boundf
(
0
)
+
P. Based on the lower bound, define the relative error ratio as E
R
=
[
(
C
m
a
x
H
i
-
f
0
-
P
)
/
(
f
0
+
P
)
]
×
100
%, where C
m
a
x
(
H
i
) denotes the makespan of the schedule generated by the heuristic algorithm Hi, i
=
1, or 2. The Average Error Ratio and the Maximum Error Ratio measured over the lower bound of the makespan are used for the performance evaluation.For each parameter combination, 200 random problems are generated to evaluate the performance of the heuristics algorithms. We do not report CPU times since even the largest problem is solved in a matter of seconds and there are no substantial differences in CPU times between the two algorithms. The evaluation results are showed in Tables1 and 2.Table 1
Computational results of average error (%).
n
s
[
2
+
(
l
/
2
)]
[
5
+
(
l
/
3
)
]
[
10
+
(
l
/
4
)
]
[
30
+
(
l
/
8
)
]
H1
H2
H1
H2
H1
H2
H1
H2
50
10
0.76
1.30
0.59
1.29
0.50
1.28
0.36
1.24
20
1.45
2.59
1.08
2.61
0.86
2.57
0.60
2.50
40
2.82
3.27
2.03
2.61
1.61
2.32
0.99
1.77
60
4.17
3.96
2.94
2.69
2.30
2.05
1.40
1.10
100
10
0.36
0.65
0.27
0.65
0.23
0.64
0.16
0.63
20
0.70
1.30
0.51
1.29
0.40
1.29
0.26
1.27
40
1.38
1.62
0.98
1.29
0.76
1.16
0.45
0.90
60
2.04
1.95
1.42
1.30
1.11
0.98
0.64
0.52
200
10
0.17
0.32
0.13
0.32
0.11
0.32
0.08
0.32
20
0.34
0.65
0.25
0.64
0.19
0.64
0.12
0.64
40
0.67
0.81
0.47
0.65
0.36
0.58
0.20
0.45
60
1.00
0.97
0.69
0.64
0.53
0.48
0.31
0.26
400
10
0.08
0.16
0.06
0.16
0.05
0.16
0.03
0.16
20
0.17
0.32
0.12
0.32
0.09
0.32
0.06
0.32
40
0.33
0.40
0.23
0.32
0.17
0.29
0.09
0.22
60
0.49
0.48
0.34
0.32
0.26
0.24
0.15
0.13Table 2
Computational results of maximum error (%).
n
s
[
2
+
(
l
/
2
)]
[
5
+
(
l
/
3
)
]
[
10
+
(
l
/
4
)
]
[
30
+
(
l
/
8
)
]
H1
H2
H1
H2
H1
H2
H1
H2
50
10
1.03
1.65
0.94
1.64
0.78
1.58
0.72
1.49
20
1.83
3.17
1.60
3.46
1.24
3.27
1.11
3.04
40
3.53
4.01
2.64
3.44
2.14
2.87
1.50
2.26
60
5.08
5.20
3.85
3.65
2.98
2.81
2.06
1.74
100
10
0.45
0.76
0.36
0.79
0.31
0.73
0.24
0.72
20
0.89
1.50
0.68
1.51
0.53
1.51
0.41
1.53
40
1.61
1.89
1.21
1.60
1.04
1.34
0.65
1.16
60
2.43
2.31
1.72
1.50
1.35
1.22
0.84
0.72
200
10
0.21
0.36
0.15
0.36
0.14
0.37
0.10
0.36
20
0.39
0.73
0.28
0.72
0.24
0.70
0.18
0.71
40
0.75
0.90
0.54
0.72
0.43
0.66
0.26
0.51
60
1.15
1.14
0.78
0.73
0.62
0.55
0.38
0.29
400
10
0.11
0.17
0.07
0.17
0.07
0.0017
0.05
0.18
20
0.19
0.36
0.14
0.35
0.10
0.35
0.07
0.35
40
0.36
0.44
0.25
0.36
0.20
0.31
0.12
0.25
60
0.53
0.53
0.38
0.35
0.29
0.26
0.18
0.14The results of numerical experiments indicate that Heuristic1 (H1) dominates Heuristic 2 (H2) in most cases and the performance of Heuristic 1 (H1) is effective in obtaining near-optimal solution. They also display that the error ratios reflect a downward trend when the value of n increases (see Figures 1, 2, 3, and 4). We also observe that the error ratios appear in an upward trend when the value of s increases; that is, the heuristic solutions get worse when the starting time of the maintenance becomes larger (see Figure 5). Furthermore, the heuristic algorithm H1 exhibits minor error ratios when the duration is relatively small (see Figure 6).Figure 1
Average error ratios of algorithm H1 withd
=
f
(
l
)
=
2
+
l
/
2.Figure 2
Average error ratios of algorithm H1 withd
=
f
(
l
)
=
5
+
l
/
3.Figure 3
Average error ratios of algorithm H1 withd
=
f
(
l
)
=
10
+
l
/
4.Figure 4
Average error ratios of algorithm H1 withd
=
f
(
l
)
=
300
+
l
/
8.Figure 5
Average error ratios of algorithm H1 withn
=
400 and d
=
f
(
l
)
=
5
+
l
/
3.Figure 6
Average error ratios of algorithm H1 withn
=
400 and d
=
f
(
l
)
=
5
+
l
/
(
10
-
x
).


## 6. Concluding Remarks

In this paper, we investigate a scheduling problem on a single machine, in which maintenance on the machine must be performed. The starting time of the maintenance is given beforehand but its duration depends on the load of the machine before the maintenance. The goal is to minimize the makespan. We formulate it as an integer programming model and then propose an FPTAS and show that a special case of our problem is polynomially solvable. Finally, we propose fast heuristic algorithms and carry out numerical experiments to evaluate their performance.



---

*Source: 198950-2015-07-27.xml*