# Near-Optimal Heuristics for Just-In-Time Jobs Maximization in Flow Shop Scheduling

^{1}

^{2}

^{3}

^{*}

## Abstract

**:**

## 1. Introduction

_{m}|prmu, d

_{j}|n

_{JIT}, where F

_{m}indicates a generic flow shop environment with m machines, prmu the permutation constraint, d

_{j}the existence of a due date for each job and n

_{JIT}the objective function that maximizes the number of jobs completed just-in-time. In some environments, such as a single-machine problem and permutation flow shop, the schedule is provided by only job sequencing. In others, it is also necessary to allocate jobs to machines, such as in the ones with parallel machines and in hybrid flow shop. Although this research addresses the problem of the permutation flow shop, in addition to sequencing, there is also the possibility of inserting idle time into some jobs to adjust their completions to the due dates (if there is slack). That is, the solution (schedule) comprises sequencing and timing phases; besides an order of jobs, it is also necessary to define the starting and ending stages of each operation. In the literature, it is known as a schedule with inserted idle time [4].

## 2. Literature Review

## 3. A Mixed Integer Linear Programming Model

_{1}, J

_{2}, ..., J

_{n}}), all of which have the same weight or priority, cannot be interrupted, are released for processing at zero time, have to be executed in m machines (M = {M

_{1}, M

_{2}, ..., M

_{m}}) and are physically arranged to follow identical unidirectional linear flows (i.e., all the jobs are processed through the machines at the same sequence). Each job (J

_{j}) requires a processing time (p

_{jk}) in each machine (M

_{k}) and have its due date represented by d

_{j}, both considered known and fixed. The solution consists of finding a schedule that maximizes the number of jobs finished at exactly their respective due dates.

n | number of jobs | |

m | number of machines | |

i, j | job index | i = 0, …, n, j = 0, …, n |

k | machine index | k = 0, …, m |

p_{jk} | processing time of job J_{j} on machine M_{k} | j = 1, ..., n, k = 1, ..., m |

d_{j} | due date of job J_{j} | j = 1, ..., n |

B | very large positive integer, the value considered in Section 5 is: $B=100{\displaystyle {\sum}_{j=1}^{n}{\displaystyle {\sum}_{k=1}^{m}{p}_{ij}}}$ | |

J_{0} | dummy job—the first in the scheduling | |

M_{0} | dummy machine—theoretically considered before the first (physical) machine |

C_{jk} | completion time of job J_{j} on machine M_{k} | j = 0, ..., n, k = 0, ..., m |

U_{j} | equals 1 if job J_{j} is just-in-time or 0 otherwise | j = 1, ..., n |

x_{ij} | equals 1 if job J_{i} is assigned immediately before job J_{j} or 0, otherwise | |

j = 0, ..., n, j = 1, ..., n, $i\ne j$. |

_{i}immediately precedes job J

_{j}(i.e., x

_{ij}= 1), the difference between their completion times on each machine must be at least equal to the processing time of job J

_{j}on the machine considered; otherwise (if x

_{ij}= 0), if there is no relationship between the completion times of this pair of jobs, then the constraints in Equation (2) are redundant. Constraints in Equation (3) require that the kth operation of job J

_{j}be completed after the (k − 1)th operation plus the processing time (p

_{jk}). Generally, the value of B is an upper bound to the makespan.

_{j}equals 1 if job J

_{j}finishes on time or 0 otherwise. When job J

_{j}does not finish on time, i.e., U

_{j}= 0, these two sets of constraints become redundant. The constraints in Equation (6) ensure that only one job is assigned to the first position in the sequence (not considering the dummy job J

_{0}). The expressions in Equation (7) establish that job J

_{j}(j ≠ 0) either occupies the first position (after J

_{0}) or is necessarily preceded by another job. The constraints in Equation (8) ensure that one job, at most, immediately precedes another. The expressions in Equation (9) define that all the jobs are ready to be initiated on machine M

_{1}, that is the completion time for all jobs in the dummy machine (k = 0) is zero, and so ensure the consistency of the restrictions in Equation (3). The expressions in Equations (10)–(12) define the domain of the variables.

## 4. Constructive Heuristics

**Timing adjustment procedure**

- Step 1.
- For the given sequence, considering starting each operation as early as possible, compute the number of just-in-time jobs (n
_{JIT}) and consider J_{initial}= J_{[1]}, where J_{[j]}is the job in position j of the sequence. - Step 2.
- From J
_{initial}, identify the first early job in the sequence (J_{E}) and go to Step 3. If there are no early jobs (from J_{initial}), STOP. - Step 3.
- Move the last operation of job J
_{E}to eliminate earliness and make its conclusion coincide with its due date. Properly reschedule the last operations of the jobs after J_{E}. - Step 4.
- Compute the new number of just-in-time jobs (n
_{JIT}’).If n_{JIT}’ < n_{JIT}(the new solution is worse than the previous one), return both the last operation of J_{E}and the operations of the following jobs to their previous positions, set J_{initial}= J_{[initial]}+ 1 and go to Step 2.Else (the new solution is better than or equal to the previous one), keep the new schedule, set J_{initial}= J_{[E]}+ 1 and go to Step 2.

**Algorithm 1.**Pseudo-code of timing adjustment procedure.

^{2}sequences obtained by removing a job from its place and relocating it to another position. The permutation neighborhood is composed by all n(n − 1)/2 sequences obtained by permuting the positions of two jobs (see Example 1).

**Example 1**. Consider the initial sequence with four jobs: {J

_{3}, J

_{2}, J

_{1}, J

_{4}}. The insertion neighborhood results in (n − 1)

^{2}= 9 sequences:

- -
- Initially, inserting the first job J
_{3}: {J_{2},**J**, J_{3}_{1}, J_{4}}, {J_{2}, J_{1},**J**, J_{3}_{4}}, {J_{2}, J_{1}, J_{4},**J**};_{3} - -
- Then, inserting the second job J
_{2}only in the positions not considered yet: {J_{3}, J_{1},**J**, J_{2}_{4}}, {J_{3}, J_{1}, J_{4},**J**}; for example, it is not necessary to insert J_{2}_{2}in the first position because the sequence resulting was already listed; and - -
- Next, the third job J
_{1}is inserted and, lastly, the fourth one J_{4}: {**J**, J_{1}_{3}, J_{2}, J_{4}}, {J_{3}, J_{2}, J_{4},**J**}, {_{1}**J**, J_{4}_{3}, J_{2}, J_{1}}, {J_{3},**J**, J_{4}_{2}, J_{1}}.

_{3}, J

_{2}, J

_{1}, J

_{4}} of the same example, the permutation neighborhood results in n(n − 1)/2 = 6 sequences:

- -
- First, the first two jobs are permuted: {
**J**,_{2}**J**, J_{3}_{1}, J_{4}}; then the first and third jobs: {**J**, J_{1}_{2},**J**, J_{3}_{4}}; and the first and fourth jobs: {**J**, J_{4}_{2}, J_{1},**J**};_{3} - -
- Next, from the initial sequence, the second and third are permutated: {J
_{3},**J**,_{1}**J**, J_{2}_{4}}; and the second and fourth: {J_{3},**J**, J_{4}_{1},**J**}; and_{2} - -
- Lastly, from the initial sequence, the third and fourth jobs are permutated: {J
_{3}, J_{2},**J**,_{4}**J**}._{1}

**Heuristic H1**

- Step 1.
- Order jobs according to the EDD rule (in the case of a tie, use the lower ∑p
_{jk}). - Step 2.
- For the first two jobs, apply the timing adjustment procedure to find the best partial sequence (between these two possibilities) with the lower n
_{JIT}. - Step 3.
- For h = 3 to n, do:Keeping the relative positions of the jobs of the partial sequence, insert the hth job of the order defined in Step 1 in all possible positions and apply the timing adjustment procedure in each insertion; consider the new partial sequence with the best n
_{JIT}(in the case of a tie, use the upper position).

**Algorithm 2.**Pseudo-code of heuristic H1.

**Heuristic H2**

- Step 1.
- Order jobs by the EDD rule (in the case of a tie, use the lower ∑p
_{jk}). - Step 2.
- For the first two jobs, apply the timing adjustment procedure to find the best partial sequence (between these two possibilities) with the lower n
_{JIT}. - Step 3.
- For h = 3 to n, do:Add the hth job of order defined in Step 1 in the last position of the partial sequence;Considering the insertion neighborhood with (h − 1)2 partial sequences and applying the timing adjustment procedure, determine that with the best n
_{JIT};From the best solution obtained so far, considering the permutation neighborhood with h(h − 1)/2 partial sequences and applying the timing adjustment procedure, determine that with the best n_{JIT}.

**Algorithm 3.**Pseudo-code of heuristic H2.

**Heuristic H3**

- Step 1.
- Order jobs by the MST rule (in the case of a tie, use the lower ∑p
_{jk}). - Steps 2 and 3.
- The same as in heuristic H1.

**Algorithm 4.**Pseudo-code of heuristic H3.

**Heuristic H4**

- Step 1.
- Order jobs by the MST rule (in the case of a tie, use the lower ∑p
_{jk}). - Steps 2 and 3.
- The same as in heuristic H2.

**Algorithm 5.**Pseudo-code of heuristic H4.

**Heuristic H5**

- Step 1.
- Order jobs by the EDD rule (in the case of a tie, use the lower ∑p
_{jk}). - Step 2.
- Apply the timing adjustment procedure.
- Step 3.
- Identify the first tardy job in the sequence (J
_{T}). If there are no tardy jobs, STOP. - Step 4.
- Replace/Place job J
_{T}as the final in the sequence and go to Step 2.

**Algorithm 6.**Pseudo-code of heuristic H5.

**Heuristic H6**

- Step 1.
- Order jobs by the EDD rule (in the case of a tie, use the lower ∑p
_{jk}). - Step 2.
- Apply the timing adjustment procedure.
- Step 3.
- Identify the first tardy job in the sequence (J
_{T}). If there are no tardy jobs, STOP. - Step 4.
- Replace job J
_{T}as the final in the sequence. - Step 5.
- Considering the insertion neighborhood with (h − 1)2 partial sequences and applying the timing adjustment procedure, determine that with the best n
_{JIT}; andFrom the best solution obtained so far, considering the permutation neighborhood with h(h − 1)/2 partial sequences and applying the timing adjustment procedure, determine that with the best n_{JIT}.

**Algorithm 7.**Pseudo-code of heuristic H6.

**Heuristic H7**

- Step 1.
- Order jobs by the MST rule (in the case of a tie, use the lower ∑p
_{jk}). - Steps 2–4.
- The same as in heuristic H5.

**Algorithm 8.**Pseudo-code of heuristic H7.

**Heuristic H8**

- Step 1.
- Order jobs by the MST rule (tie-break by the lower ∑p
_{jk}). - Steps 2–5.
- The same as in heuristic H6.

**Algorithm 9.**Pseudo-code of heuristic H8.

_{JIT}. This corresponds to a diverse way to test neighbor solutions (see Example 2).

**Example 2**. Consider again the sequence: {J

_{3}, J

_{2}, J

_{1}, J

_{4}}. For position h = 1, the first job J

_{3}is replaced in the last position; if the new solution is improved, the new sequence is kept (and also the value of h = 1), otherwise, the previous one is recovered (and the h is incremented). Thus, if the current sequence is {J

_{2}, J

_{1}, J

_{4}, J

_{3}}, then the new first job J

_{2}is replaced in the last position and the test is repeated for {J

_{1}, J

_{4}, J

_{3}, J

_{2}}. Considering now that the new solution is not better than the previous one, the sequence is kept {J

_{2}, J

_{1}, J

_{4}, J

_{3}} and h = h + 1 = 2. In the next step, the second job (i.e., the one in the hth position) is replaced in the last position and the test is redone. This forward procedure is repeated until the (n − 1)th position. Then, a backward procedure is applied, reinserting the last job in all previous positions, and so on.

**Heuristic H9**

- Step 1.
- Order jobs by the EDD rule (in the case of a tie, use the lower ∑p
_{jk}). - Step 2.
- Apply the timing adjustment procedure.
- Step 3.
- Set h = 1. While h < n, do (from position 1 to n − 1):Forward procedure: replace the hth job defined in Step 1 in the last position of the partial sequence and apply the timing adjustment procedure. If the new n
_{JIT}is better than the previous one, keep the new schedule (and the h value); otherwise, go back to the previous one and set h = h + 1. - Step 4.
- Set h = n. While h > 1, do (from the last position to the second):Backward procedure: Replace the hth job in all the previous positions and apply the timing adjustment procedure considering the best solution found. If a new best solution is found, keep the new schedule (and the h value); otherwise, go back to the previous solution and set h = h − 1.
- Step 5.
- STOP.

**Algorithm 10.**Pseudo-code of heuristic H9.

**Heuristic H10**

- Step 1.
- Order jobs by the MST rule (in the case of a tie, use the lower ∑p
_{jk}). - Steps 2–5.
- The same as in heuristic H9.

**Algorithm 11.**Pseudo-code of heuristic H10.

## 5. Computational Experiments and Results

#### 5.1. Problem Instances

- Scenario 1: low tardiness factor (T = 0.2) and small due date range (R = 0.6);
- Scenario 2: low tardiness factor (T = 0.2) and large due date range (R = 1.2);
- Scenario 3: high tardiness factor (T = 0.4) and small due date range (R = 0.6); and
- Scenario 4: high tardiness factor (T = 0.4) and large due date range (R = 1.2).

#### 5.2. Experiment 1: Relative Comparison of the Proposed Heuristics

**Enumeration Method**

- Step 1.
- Enumerate the n! possible sequences and consider the one with the best n
_{JIT}. - Step 2.
- Apply the timing adjustment procedure.

**Algorithm 12.**Pseudo-code of the enumeration method.

#### 5.3. Experiment 2: Quality of the Heuristic Solutions in Relation to the Optimal Solution

#### 5.4. Computational Efficiency

## 6. Final Remarks

## Acknowledgments

## Author Contributions

## Conflicts of Interest

## References

- Pinedo, M.L. Scheduling: Theory, Algorithms and Systems, 5th ed.; Prentice-Hall: Upper Saddle River, NJ, USA, 2016; ISBN 978-3319265780. [Google Scholar]
- Shabtay, D.; Bensoussan, Y.; Kaspi, M. A bicriteria approach to maximize the weighted number of just-in-time jobs and to minimize the total resource consumption cost in a two-machine flow-shop scheduling system. Int. J. Prod. Econ.
**2012**, 136, 67–74. [Google Scholar] [CrossRef] - Lann, A.; Mosheiov, G. Single machine scheduling to minimize the number of early and tardy jobs. Comput. Oper. Res.
**1996**, 23, 769–781. [Google Scholar] [CrossRef] - Kanet, J.J.; Sridharan, V. Scheduling with inserted idle time: Problem taxonomy and literature review. Oper. Res.
**2000**, 48, 99–110. [Google Scholar] [CrossRef] - Baker, K.R.; Scudder, G.D. Sequencing with earliness and tardiness penalties: A review. Oper. Res.
**1990**, 38, 22–36. [Google Scholar] [CrossRef] - Józefowska, J. Just-in-Time Scheduling: Models and Algorithms for Computer and Manufacturing Systems; Springer Science: New York, NY, USA, 2007; ISBN 978-387-71717-3. [Google Scholar]
- Ríos-Solís, Y.A.; Ríos-Mercado, R.Z. Just-In-Time Systems; Springer Sciences: New York, NY, USA, 2012; ISBN 978-1-4614-1122-2. [Google Scholar]
- Shabtay, D.; Steiner, G. Scheduling to maximize the number of just-in-time jobs: A survey. In Just-in-Time Systems; Ríos-Solís, Y.A., Ríos-Mercado, R.Z., Eds.; Springer Sciences: New York, NY, USA, 2012; ISBN 978-1-4614-1122-2. [Google Scholar]
- Choi, B.-C.; Yoon, S.-H. Maximizing the weighted number of just-in-time jobs in flow shop scheduling. J. Sched.
**2007**, 10, 237–243. [Google Scholar] [CrossRef] - Shabtay, D.; Bensoussan, Y. Maximizing the weighted number of just-in-time jobs in several two-machine scheduling systems. J. Sched.
**2012**, 15, 39–47. [Google Scholar] [CrossRef] - Shabtay, D. The just-in-time scheduling problem in a flow-shop scheduling system. Eur. J. Oper. Res.
**2012**, 216, 521–532. [Google Scholar] [CrossRef] - Gerstl, E.; Mor, B.; Mosheiov, G. A note: Maximizing the weighted number of just-in-time jobs on a proportionate flowshop. Inf. Process. Lett.
**2015**, 115, 159–162. [Google Scholar] [CrossRef] - Yin, Y.; Cheng, T.C.E.; Wang, D.-J.; Wu, C.-C. Two-agent flowshop scheduling to maximize the weighted number of just-in-time jobs. J. Sched.
**2017**, 20, 313–335. [Google Scholar] [CrossRef] - Fuchigami, H.Y.; Rangel, S. Métodos heurísticos para maximização do número de tarefas just-in-time em flow shop permutacional. In Proceedings of the Simpósio Brasileiro de Pesquisa Operacional, Porto de Galinhas, Brazil, 25–28 August 2015. [Google Scholar]
- Fuchigami, H.Y.; Rangel, S. Um estudo computacional de um modelo matemático para flow shop permutacional com tarefas just-in-time. In Proceedings of the Simpósio Brasileiro de Pesquisa Operacional, Vitória, Brazil, 27–30 September 2016. [Google Scholar]
- Dhouib, E.; Teghem, J.; Loukil, T. Minimizing the number of tardy jobs in a permutation flowshop scheduling problem with setup times and time lags constraints. J. Math. Model. Algorithm
**2013**, 12, 85–99. [Google Scholar] [CrossRef] - Nawaz, M.; Enscore, E.E., Jr.; Ham, I. A heuristic algorithm for the m-machine n-job flow-shop sequencing problem. OMEGA–Int. J. Manag. Sci.
**1983**, 11, 91–95. [Google Scholar] [CrossRef] - Hodgson, T.J. A note on single machine sequencing with random processing times. Manag. Sci.
**1977**, 23, 1144–1146. [Google Scholar] [CrossRef] - Baker, K.R.; Trietsch, D. Principles of Sequencing and Scheduling; John Wiley & Sons: New York, NY, USA, 2009; ISBN 978-0-470-39165-5. [Google Scholar]
- Nagano, M.S.; Branco, F.J.C.B.; Moccellin, J.V. Soluções de alto desempenho para programação da produção flow shop. GEPROS
**2009**, 4, 11–23. [Google Scholar] - Li, X.; Chen, L.; Xu, H.; Gupta, J.N.D. Trajectory scheduling methods for minimizing total tardiness in a flowshop. Oper. Res. Perspect.
**2015**, 2, 13–23. [Google Scholar] [CrossRef] - Vallada, E.; Ruiz, R.; Minella, G. Minimizing total tardiness in the m-machine flowshop problem: A review and evaluation of heuristics and metaheuristics. Comput. Oper. Res.
**2008**, 35, 1350–1373. [Google Scholar] [CrossRef] - Ronconi, D.P.; Birgin, E.G. Mixed-integer programming models for flow shop scheduling problems minimizing the total earliness and tardiness. In Just-in-Time Systems; Ríos-Solís, Y.A., Ríos-Mercado, R.Z., Eds.; Springer Sciences: New York, NY, USA, 2012; ISBN 978-1-4614-1122-2. [Google Scholar]
- Taillard, E. Benchmarks for basic scheduling problems. Eur. J. Oper. Res.
**1993**, 64, 278–285. [Google Scholar] [CrossRef] - Laha, D.; Sarin, S.C. A heuristic to minimize total flow time in permutation flow shop. OMEGA–Int. J. Manag. Sci.
**2009**, 37, 734–739. [Google Scholar] [CrossRef]

**Figure 1.**Example of different schedules with the same sequence of jobs: (

**a**) only J

_{3}is just-in-time; (

**b**) J

_{2}and J

_{1}are just-in-time; and (

**c**) J

_{2}and J

_{3}are just-in-time.

**Figure 2.**Comparison of performances of heuristics by group with 95% confidence interval of average RPD: (

**a**) related to EM for Group 1; and (

**b**) related to the best H1–H10 solution for Group 2.

**Figure 3.**Comparisons of performances of heuristics in relation to those of model (95% confidence intervals of average RPD).

Variables | Binary | n^{2} + 2n |

Integer | n^{2} + m + n + 1 | |

Total | n(2n + 3) + m + 1 | |

Constraints | (2) | n^{2}m + nm |

(3) | nm | |

(4) | n | |

(5) | n | |

(6) | 1 | |

(7) | n | |

(8) | n + 1 | |

(9) | n + 1 | |

Total | n(n + 2m + 6) + m + 3 |

Heuristic | Initial Ordering | Neighborhood Search | ||||
---|---|---|---|---|---|---|

EDD | MST | Insertion | Permutation | Fwd/Bwd | ||

NEH-based | H1 | x | ||||

H2 | x | x | x | |||

H3 | x | |||||

H4 | x | x | x | |||

Hodgson-based | H5 | x | ||||

H6 | x | x | x | |||

H7 | x | |||||

H8 | x | x | x | |||

Other | H9 | x | x | |||

H10 | x | x |

Group 1 | Group 2 | |
---|---|---|

Number of jobs | 5, 6, 7, 8, 10 | 15, 20, 30, 50, 80, 100 |

Number of machines | 2, 3, 5 | 5, 10, 15, 20 |

Scenario configurations | Scenario 1: T = 0.2 and R = 0.6; Scenario 2: T = 0.2 and R = 1.2; Scenario 3: T = 0.4 and R = 0.6; Scenario 4: T = 0.4 and R = 1.2 | |

Number of instances per class | 100 | 100 |

Number of instances per group | 6000 | 9600 |

Total number of instances solved | 15,600 |

**Table 4.**Overall performance rankings (RPD) of proposed heuristics in relation to EM for Group 1 and to the best found solution for Group 2.

Group 1 | H6 | H5 | H2 | H1 | H4 | H3 | H9 | H8 | H10 | H7 |

0.2 | 0.4 | 1.1 | 1.2 | 3.7 | 7.0 | 9.6 | 16.2 | 21.1 | 41.7 | |

Group 2 | H6 | H5 | H2 | H1 | H4 | H3 | H9 | H10 | H8 | H7 |

0.2 | 0.3 | 0.6 | 2.4 | 7.0 | 11.9 | 31.4 | 61.4 | 68.1 | 76.6 |

n | H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8 | H9 | H10 |
---|---|---|---|---|---|---|---|---|---|---|

5 | 1.0 | 1.1 | 5.4 | 1.8 | 0.4 | 0.2 | 29.1 | 5.5 | 5.7 | 12.7 |

6 | 1.2 | 0.9 | 7.4 | 3.4 | 0.4 | 0.1 | 35.8 | 9.4 | 7.3 | 17.7 |

7 | 1.2 | 1.2 | 6.4 | 3.4 | 0.4 | 0.2 | 43.9 | 16.2 | 8.9 | 20.0 |

8 | 1.5 | 1.0 | 7.8 | 4.8 | 0.3 | 0.3 | 49.3 | 21.8 | 11.6 | 25.3 |

10 | 1.2 | 1.1 | 8.3 | 4.9 | 0.4 | 0.3 | 50.6 | 28.3 | 14.5 | 29.8 |

n | H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8 | H9 | H10 |
---|---|---|---|---|---|---|---|---|---|---|

15 | 3.9 | 1.5 | 10.9 | 6.4 | 0.7 | 0.4 | 59.6 | 41.3 | 26.2 | 40.1 |

20 | 3.6 | 1.1 | 9.4 | 6.2 | 0.5 | 0.4 | 69.4 | 55.7 | 28.3 | 47.5 |

30 | 3.3 | 0.7 | 8.9 | 6.7 | 0.3 | 0.2 | 77.7 | 69.0 | 30.5 | 57.5 |

50 | 2.1 | 0.3 | 8.5 | 6.7 | 0.3 | 0.1 | 84.6 | 79.6 | 33.4 | 69.3 |

80 | 1.0 | 0.1 | 8.8 | 7.3 | 0.1 | 0.1 | 89.4 | 86.3 | 34.8 | 76.3 |

100 | 0.6 | 0.0 | 25.1 | 8.7 | 0.2 | 0.1 | 78.9 | 76.6 | 35.1 | 77.6 |

m | H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8 | H9 | H10 |
---|---|---|---|---|---|---|---|---|---|---|

2 | 0.3 | 0.5 | 7.1 | 3.7 | 0.2 | 0.1 | 42.2 | 16.5 | 7.5 | 20.8 |

3 | 0.9 | 0.8 | 7.4 | 3.7 | 0.3 | 0.1 | 42.3 | 16.7 | 9.6 | 21.3 |

5 | 2.4 | 1.9 | 6.7 | 3.5 | 0.7 | 0.5 | 40.7 | 15.5 | 11.8 | 21.1 |

m | H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8 | H9 | H10 |
---|---|---|---|---|---|---|---|---|---|---|

5 | 0.5 | 0.3 | 12.2 | 7.2 | 0.2 | 0.1 | 78.0 | 69.8 | 28.6 | 61.8 |

10 | 2.1 | 0.7 | 13.0 | 7.1 | 0.4 | 0.2 | 75.9 | 68.0 | 30.7 | 61.3 |

15 | 3.1 | 0.6 | 11.0 | 7.1 | 0.3 | 0.2 | 76.9 | 68.2 | 32.5 | 61.3 |

20 | 3.9 | 0.8 | 11.6 | 6.6 | 0.5 | 0.3 | 75.5 | 66.4 | 33.7 | 61.1 |

**Table 9.**Performances (RPD) of heuristics by group and scenario in relation to EM for Group 1 and to the best found solution for Group 2.

Scenario | H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8 | H9 | H10 | |
---|---|---|---|---|---|---|---|---|---|---|---|

Group 1 | 1 | 0.9 | 0.8 | 8.7 | 4.6 | 0.4 | 0.3 | 42.2 | 16.5 | 10.0 | 20.8 |

2 | 1.0 | 0.7 | 4.7 | 2.2 | 0.2 | 0.2 | 45.7 | 19.2 | 4.3 | 20.0 | |

3 | 1.9 | 1.7 | 9.3 | 5.1 | 0.8 | 0.5 | 39.3 | 14.7 | 15.0 | 22.1 | |

4 | 1.0 | 1.0 | 5.5 | 2.7 | 0.1 | 0.1 | 39.8 | 14.5 | 9.2 | 21.5 | |

Group 2 | 1 | 1.7 | 0.7 | 15.0 | 8.9 | 0.4 | 0.2 | 76.3 | 68.1 | 39.4 | 61.6 |

2 | 1.6 | 0.5 | 7.8 | 4.5 | 0.1 | 0.1 | 78.6 | 71.3 | 13.8 | 62.0 | |

3 | 3.7 | 1.0 | 15.2 | 9.4 | 0.7 | 0.4 | 75.1 | 65.4 | 43.0 | 60.9 | |

4 | 2.5 | 0.3 | 9.7 | 5.3 | 0.1 | 0.1 | 76.3 | 67.6 | 29.3 | 61.0 |

**Table 10.**Overall performance rankings (average RPD) of heuristics in relation to optimal solution for instances in Group 1.

H6 | H5 | H2 | H1 | H4 | H3 | H9 | H8 | H10 | H7 | |
---|---|---|---|---|---|---|---|---|---|---|

RPD | 0.6 | 0.8 | 1.4 | 1.6 | 4.0 | 7.4 | 10.0 | 16.6 | 21.4 | 41.9 |

**Table 11.**Overall performance (average RPD) of heuristics in relation to lower bound given by CPLEX by number of jobs for instances of Group 2.

n | H1 | H2 | H3 | H4 | H5 | H6 | H7 | H8 | H9 | H10 |
---|---|---|---|---|---|---|---|---|---|---|

15 | 6.5 | 1.0 | 10.3 | 6.9 | 1.0 | 1.0 | 56.7 | 41.1 | 28.2 | 36.8 |

20 | −5.0 | −6.5 | 4.0 | −2.8 | −8.8 | −8.8 | 66.5 | 49.6 | 23.1 | 41.1 |

30 | −49.0 | −52.5 | −38.0 | −40.1 | −52.0 | −52.0 | 68.4 | 57.2 | −7.4 | 38.5 |

80 | −1080.2 | −1082.0 | −1001.7 | −1032.6 | −1082.0 | −1082.0 | −13.5 | −93.2 | −764.4 | −251.9 |

100 | −1276.7 | −1276.7 | −990.8 | −1159.3 | −1276.7 | −1276.7 | −460.6 | −518.8 | −865.0 | −276.1 |

Solution Method | Group 1 | Group 2 |
---|---|---|

H1 | 0.08 | 67.99 |

H2 | 0.33 | 7895.49 |

H3 | 0.03 | 72.55 |

H4 | 0.32 | 7820.17 |

H5 | 0.01 | 1.21 |

H6 | 0.13 | 391.51 |

H7 | 0.01 | 1.28 |

H8 | 0.12 | 190.49 |

H9 | 0.06 | 79.02 |

H10 | 0.05 | 56.29 |

EM | 1483.65 | – |

Model | 199,882.99 | – |

© 2018 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Fuchigami, H.Y.; Sarker, R.; Rangel, S.
Near-Optimal Heuristics for Just-In-Time Jobs Maximization in Flow Shop Scheduling. *Algorithms* **2018**, *11*, 43.
https://doi.org/10.3390/a11040043

**AMA Style**

Fuchigami HY, Sarker R, Rangel S.
Near-Optimal Heuristics for Just-In-Time Jobs Maximization in Flow Shop Scheduling. *Algorithms*. 2018; 11(4):43.
https://doi.org/10.3390/a11040043

**Chicago/Turabian Style**

Fuchigami, Helio Yochihiro, Ruhul Sarker, and Socorro Rangel.
2018. "Near-Optimal Heuristics for Just-In-Time Jobs Maximization in Flow Shop Scheduling" *Algorithms* 11, no. 4: 43.
https://doi.org/10.3390/a11040043