Exploiting Promising Sub-Sequences of Jobs to solve the No-Wait Flowshop Scheduling Problem

TL;DR

This paper introduces a novel approach that leverages common sub-sequences called super-jobs to improve solutions for the NP-hard no-wait flowshop scheduling problem, significantly enhancing solution quality.

Contribution

It proposes IG-SJ, an innovative algorithm that exploits super-jobs within the Iterated Greedy framework to better solve the no-wait flowshop scheduling problem.

Findings

IG-SJ finds 64 new best solutions on benchmark instances.

Exploiting super-jobs improves solution quality for the no-wait flowshop.

The approach effectively captures problem structure to enhance optimization.

Abstract

The no-wait flowshop scheduling problem is a variant of the classical permutation flowshop problem, with the additional constraint that jobs have to be processed by the successive machines without waiting time. To efficiently address this NP-hard combinatorial optimization problem we conduct an analysis of the structure of good quality solutions. This analysis shows that the No-Wait specificity gives them a common structure: they share identical sub-sequences of jobs, we call super-jobs. After a discussion on the way to identify these super-jobs, we propose IG-SJ, an algorithm that exploits super-jobs within the state-of-the-art algorithm for the classical permutation flowshop, the well-known Iterated Greedy (IG) algorithm. An iterative approach of IG-SJ is also proposed. Experiments are conducted on Taillard's instances. The experimental results show that exploiting super-jobs is successful since IG-SJ is able to find 64 new best solutions.

Figures

Tables

Table 1. Table 3: Result on Taillard’s instances (organized by size) for Σ 1 = { 60 % , 80 % , ∞ } subscript Σ 1 percent 60 percent 80 \Sigma_{1}=\{60\%,80\%,\infty\} . Gray cell: the best-known solution of the literature is reached. #/X : Number of times the best-known is improved (X = all runs).

	50					100										200										500
5		17	2	21	11	X	14	5	29	13	11	16	5	6	4
10						26	20	7	24	18	26	22	X	23	23	24	19	X	X	X	X	29	28	X	X
20						13	29	12	25	26	X	29	X	19	29	X	X	X	X	X	X	X	X	29	X	X	X	X	28	29	23	X	X	X	X

Table 2. Table 4: Result on Taillard’s instances (organized by size) for Σ 2 = { 60 % , 70 % , 80 % , 90 % , ∞ } subscript Σ 2 percent 60 percent 70 percent 80 percent 90 \Sigma_{2}=\{60\%,70\%,80\%,90\%,\infty\} . Gray cell: the best-known solution of the literature is reached. #/X : Number of times the best-known is improved (X = all runs).

	50					100										200										500
5	1	23	2	25	17	X	14	6	X	13	14	20	8	6	6
10						27	17	19	X	24	28	26	X	X	22	27	19	X	X	X	X	X	29	X	X
20						17	X	22	26	27	X	X	X	27	29	X	X	X	X	X	X	X	X	X	X	X	X	X	X	29	26	X	X	X	X

Table 3. Table 5: IG SJ SJ {}_{\mbox{{\scriptsize SJ}}}   with Σ 1 = { 60 % , 80 % , ∞ } subscript Σ 1 percent 60 percent 80 \Sigma_{1}=\{60\%,80\%,\infty\} . Reported measures are average over the 10 instances of each size.

Instances	Problem size		End of improvement				RPD value				Time (s)
	60%	80%	Init	IG60%	IG80%	IG∞	Init	IG60%	IG80%	IG∞	60%	80%	$\infty$	total
20$\times$5	1.23	10.26	98.7	0.0	1.3	0.0	0.06	0.06	0.00	0.00	0.14	0.31	0.00	0.45
20$\times$10	1.00	10.00	100.0	0.0	0.0	0.0	0.00	0.00	0.00	0.00	0.14	0.30	0.00	0.45
20$\times$20	1.26	10.35	95.3	2.3	2.3	0.0	0.03	0.03	0.00	0.00	0.14	0.30	0.01	0.45
50$\times$5	9.23	31.65	10.0	31.0	53.7	5.3	0.97	0.22	0.06	0.06	0.59	1.72	1.69	3.99
50$\times$10	5.98	29.83	28.3	6.7	57.7	7.3	0.72	0.47	0.07	0.07	0.82	1.84	0.98	3.64
50$\times$20	4.10	27.85	59.0	3.3	29.3	8.3	0.42	0.24	0.05	0.04	0.89	1.88	0.54	3.30
100$\times$5	45.46	78.32	0.0	43.3	34.7	22.0	3.00	0.03	0.00	-0.01	6.88	7.07	8.98	22.93
100$\times$10	29.04	68.99	0.0	16.3	53.7	30.0	1.69	0.07	-0.05	-0.07	3.25	7.48	9.38	20.11
100$\times$20	27.37	68.44	0.0	9.3	59.0	31.7	1.49	0.09	-0.08	-0.10	2.82	7.71	9.22	19.74
200$\times$10	95.36	157.41	0.0	15.3	45.7	39.0	2.89	-0.13	-0.18	-0.19	30.94	35.48	46.51	112.93
200$\times$20	81.83	150.74	0.0	5.0	41.7	53.3	1.99	-0.20	-0.30	-0.32	22.12	39.35	48.80	110.27
500$\times$20	268.87	409.28	0.0	0.7	30.3	69.0	2.81	-0.18	-0.24	-0.25	598.84	656.63	784.92	2040.38

Table 4. Table 6: IG SJ SJ {}_{\mbox{{\scriptsize SJ}}}   with Σ 2 = { 60 % , 70 % , 80 % , 90 % , ∞ } subscript Σ 2 percent 60 percent 70 percent 80 percent 90 \Sigma_{2}=\{60\%,70\%,80\%,90\%,\infty\} . Reported measures are averages over the 10 instances of each size.

Instances	Problem size				End of improvement						RPD value						Time (s)
	60%	70%	80%	90%	Init	IG60%	IG70%	IG80%	IG90%	IG∞	Init	IG60%	IG70%	IG80%	IG90%	IG∈fty	60%	70%	80%	90%	$\infty$	total
20$\times$5	1.23	10.19	10.30	10.20	98.70	0.00	1.33	0.00	0.00	0.00	0.06	0.06	0.00	0.00	0.00	0.00	0.14	0.14	0.14	0.31	0.00	0.74
20$\times$10	1.00	10.00	10.00	10.00	100.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.00	0.14	0.14	0.14	0.31	0.00	0.73
20$\times$20	1.26	10.22	10.40	10.20	95.30	2.30	1.67	0.67	0.00	0.00	0.03	0.03	0.00	0.00	0.00	0.00	0.14	0.14	0.14	0.30	0.01	0.74
50$\times$5	9.23	29.51	31.70	29.50	9.30	23.70	35.67	20.67	9.00	1.67	0.97	0.22	0.06	0.04	0.03	0.03	0.54	1.40	1.40	1.56	1.70	6.60
50$\times$10	5.98	28.09	29.90	28.10	24.30	5.30	30.00	19.67	14.67	6.00	0.72	0.47	0.09	0.07	0.06	0.06	0.76	1.29	1.31	1.77	0.99	6.11
50$\times$20	4.10	26.91	27.90	26.90	56.70	3.00	14.00	13.00	10.67	2.67	0.42	0.24	0.06	0.04	0.04	0.03	0.86	1.14	1.19	1.87	0.54	5.60
100$\times$5	45.46	71.38	78.30	71.40	0.00	31.00	21.33	16.00	19.67	12.00	3.00	0.03	0.00	-0.01	-0.02	-0.03	6.82	6.38	6.94	7.63	8.91	36.68
100$\times$10	29.04	63.72	69.00	63.70	0.00	9.00	25.33	26.67	25.33	13.67	1.69	0.07	-0.04	-0.07	-0.09	-0.09	3.32	6.57	6.80	7.01	8.92	32.62
100$\times$20	27.37	62.91	68.50	62.90	0.00	8.00	16.33	32.00	28.67	15.00	1.49	0.09	-0.05	-0.10	-0.12	-0.13	2.90	6.95	7.11	7.01	8.63	32.60
200$\times$10	95.36	144.20	157.50	144.20	0.00	5.70	19.33	28.00	23.00	24.00	2.89	-0.13	-0.18	-0.20	-0.22	-0.22	31.09	30.83	32.45	35.71	43.83	173.91
200$\times$20	81.83	138.14	150.90	138.10	0.00	0.70	14.67	28.00	28.67	28.00	1.99	-0.20	-0.28	-0.32	-0.33	-0.34	22.09	34.00	33.18	35.29	45.30	169.85
500$\times$20	268.87	376.81	409.50	376.80	0.00	0.00	5.33	15.67	31.33	47.67	2.81	-0.18	-0.23	-0.26	-0.27	-0.28	601.14	566.95	585.10	631.06	744.54	3 128.79

Table 5. Table 7: Best known solutions of Taillard instances. A bold value indicates a new best solution was found out by our approach.

Instance	Best	Gap	Instance	Best	Gap	Instance	Best	Gap	Instance	Best	Gap
Ta01	1,486	0	Ta31	3,160	-1	Ta61	6,366	-31	Ta91	15,248	-71
Ta02	1,528	0	Ta32	3,432	0	Ta62	6,219	-15	Ta92	15,007	-78
Ta03	1,460	0	Ta33	3,210	-1	Ta63	6,108	-13	Ta93	15,276	-100
Ta04	1,588	0	Ta34	3,338	-1	Ta64	6,001	-25	Ta94	15,117	-83
Ta05	1,449	0	Ta35	3,356	0	Ta65	6,183	-17	Ta95	15,113	-96
Ta06	1,481	0	Ta36	3,346	-1	Ta66	6,058	-16	Ta96	14,997	-112
Ta07	1,483	0	Ta37	3,231	0	Ta67	6,224	-23	Ta97	15,300	-95
Ta08	1,482	0	Ta38	3,235	0	Ta68	6,115	-15	Ta98	15,162	-75
Ta09	1,469	0	Ta39	3,070	-2	Ta69	6,359	-11	Ta99	15,012	-88
Ta10	1,377	0	Ta40	3,317	0	Ta70	6,371	-10	Ta100	15,259	-81
Ta11	2,044	0	Ta41	4,274	0	Ta71	8,059	-18	Ta101	19,551	-130
Ta12	2,166	0	Ta42	4,177	0	Ta72	7,859	-21	Ta102	19,980	-116
Ta13	1,940	0	Ta43	4,099	0	Ta73	8,017	-11	Ta103	19,791	-122
Ta14	1,811	0	Ta44	4,399	0	Ta74	8,330	-18	Ta104	19,775	-153
Ta15	1,933	0	Ta45	4,322	0	Ta75	7,939	-19	Ta105	19,732	-111
Ta16	1,892	0	Ta46	4,289	0	Ta76	7,773	-28	Ta106	19,852	-90
Ta17	1,963	0	Ta47	4,420	0	Ta77	7,851	-15	Ta107	19,967	-145
Ta18	2,057	0	Ta48	4,318	0	Ta78	7,881	-32	Ta108	19,900	-156
Ta19	1,973	0	Ta49	4,155	0	Ta79	8,137	-24	Ta109	19,817	-101
Ta20	2,051	0	Ta50	4,283	0	Ta80	8,095	-19	Ta110	19,794	-141
Ta21	2,973	0	Ta51	6,129	0	Ta81	10,676	-24	Ta111	46,264	-425
Ta22	2,852	0	Ta52	5,725	0	Ta82	10,562	-32	Ta112	46,797	-478
Ta23	3,013	0	Ta53	5,862	0	Ta83	10,591	-20	Ta113	46,154	-390
Ta24	3,001	0	Ta54	5,788	0	Ta84	10,588	-19	Ta114	46,556	-343
Ta25	3,003	0	Ta55	5,886	0	Ta85	10,507	-32	Ta115	46,402	-339
Ta26	2,998	0	Ta56	5,863	0	Ta86	10,624	-66	Ta116	46,667	-274
Ta27	3,052	0	Ta57	5,962	0	Ta87	10,793	-32	Ta117	46,170	-339
Ta28	2,839	0	Ta58	5,926	0	Ta88	10,801	-38	Ta118	46,495	-378
Ta29	3,009	0	Ta59	5,876	0	Ta89	10,703	-20	Ta119	46,408	-335
Ta30	2,979	0	Ta60	5,958	0	Ta90	10,752	-46	Ta120	46,433	-414

Table 6. Table 8: Analysis of the 5 iterations of IIG SJ SJ {}_{\mbox{\scriptsize SJ}} . Results are presented according to the 12 different sizes of the Taillard instances N × M 𝑁 𝑀 N\times M . The RPD value of a run is computed from the best-known quality reported in Table 7 . Times are given in seconds. For each iteration, the reported values of RPD and time are the average values computed over 200 runs.

	Iter 0	Iter 1		Iter 2		Iter 3		Iter 4		Iter 5		Total
Instances	RPD	time (s)	RPD	time (s)	RPD	time (s)	RPD	time (s)	RPD	time (s)	RPD	time (s)
20$\times$5	0.000	14	0.000	14	0.000	14	0.000	14	0.000	14	0.000	71
20$\times$10	0.000	14	0.000	14	0.000	14	0.000	14	0.000	14	0.000	71
20$\times$20	0.015	15	0.001	14	0.000	14	0.000	14	0.000	14	0.000	71
50$\times$5	0.276	129	0.073	112	0.029	103	0.020	101	0.013	100	0.009	545
50$\times$10	0.128	124	0.059	107	0.037	101	0.020	97	0.019	98	0.019	527
50$\times$20	0.120	111	0.034	100	0.016	97	0.010	96	0.010	94	0.010	497
100$\times$5	1.015	742	0.317	370	0.162	253	0.134	236	0.107	229	0.102	1830
100$\times$10	0.577	332	0.215	282	0.147	254	0.134	243	0.124	231	0.112	1341
100$\times$20	0.587	324	0.222	265	0.159	244	0.137	226	0.127	206	0.124	1264
200$\times$10	1.431	1835	0.441	1281	0.187	1084	0.102	1005	0.085	976	0.084	6181
200$\times$20	1.180	1726	0.366	1269	0.206	1116	0.134	1048	0.105	908	0.082	6068
500$\times$20	1.748	32906	0.598	20789	0.299	16668	0.157	14747	0.090	11728	0.055	96838

Table 7. Table 9: Solution fitness found with the first configuration ( 60 % / 80 % / ∞ percent 60 percent 80 60\%/80\%/\infty )

050$\times$5		100$\times$5		100$\times$10		100$\times$20		200$\times$10		200$\times$20		500$\times$20
Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best
Ta31	3,161	Ta61	6,369	Ta71	8,062	Ta81	10,682	Ta91	15,279	Ta101	19,588	Ta111	46,454
Ta32	3,432	Ta62	6,223	Ta72	7,866	Ta82	10,568	Ta92	15,058	Ta102	20,009	Ta112	46,934
Ta33	3,210	Ta63	6,116	Ta73	8,022	Ta83	10,599	Ta93	15,282	Ta103	19,828	Ta113	46,329
Ta34	3,338	Ta64	6,002	Ta74	8,334	Ta84	10,588	Ta94	15,148	Ta104	19,813	Ta114	46,743
Ta35	3,356	Ta65	6,190	Ta75	7,939	Ta85	10,510	Ta95	15,136	Ta105	19,762	Ta115	46,563
Ta36	3,346	Ta66	6,065	Ta76	7,780	Ta86	10,642	Ta96	15,032	Ta106	19,874	Ta116	46,816
Ta37	3,231	Ta67	6,230	Ta77	7,851	Ta87	10,798	Ta97	15,334	Ta107	19,994	Ta117	46,365
Ta38	3,235	Ta68	6,120	Ta78	7,886	Ta88	10,804	Ta98	15,193	Ta108	19,942	Ta118	46,694
Ta39	3,070	Ta69	6,364	Ta79	8,143	Ta89	10,707	Ta99	15,041	Ta109	19,845	Ta119	46,589
Ta40	3,317	Ta70	6,377	Ta80	8,096	Ta90	10,767	Ta100	15,282	Ta110	19,824	Ta120	46,629

Table 8. Table 10: Solution fitness found with the second configuration ( 60 % / 70 % / 80 % / 90 % / ∞ percent 60 percent 70 percent 80 percent 90 60\%/70\%/80\%/90\%/\infty )

050$\times$5		100$\times$5		100$\times$10		100$\times$20		200$\times$10		200$\times$20		500$\times$20
Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best	Inst.	Best
Ta31	3,160	Ta61	6,368	Ta71	8,063	Ta81	10,680	Ta91	15,280	Ta101	19,592	Ta111	46,466
Ta32	3,432	Ta62	6,222	Ta72	7,859	Ta82	10,572	Ta92	15,052	Ta102	19,998	Ta112	46,949
Ta33	3,210	Ta63	6,113	Ta73	8,020	Ta83	10,594	Ta93	15,286	Ta103	19,816	Ta113	46,326
Ta34	3,338	Ta64	6,005	Ta74	8,334	Ta84	10,588	Ta94	15,143	Ta104	19,810	Ta114	46,724
Ta35	3,356	Ta65	6,191	Ta75	7,939	Ta85	10,510	Ta95	15,128	Ta105	19,752	Ta115	46,560
Ta36	3,346	Ta66	6,065	Ta76	7,779	Ta86	10,640	Ta96	15,028	Ta106	19,864	Ta116	46,810
Ta37	3,231	Ta67	6,230	Ta77	7,855	Ta87	10,800	Ta97	15,334	Ta107	20,008	Ta117	46,320
Ta38	3,235	Ta68	6,122	Ta78	7,885	Ta88	10,805	Ta98	15,185	Ta108	19,935	Ta118	46,666
Ta39	3,070	Ta69	6,364	Ta79	8,143	Ta89	10,707	Ta99	15,046	Ta109	19,841	Ta119	46,553
Ta40	3,317	Ta70	6,374	Ta80	8,096	Ta90	10,759	Ta100	15,283	Ta110	19,818	Ta120	46,591

Equations

$$f(\pi )=C_{\text{mbox}max}=\underset{i\in \{1,\dots ,N\}}{\max }\{C_i\}=C_{{\pi }_N}$$

$$d_{i,i^{\prime }}=p_{i,1}+\underset{1\le r\le M}{\max }\left(\sum _{j=2}^r{p}_{i,j}-\sum _{j=1}^{r-1}{p}_{i^{\prime },j},0\right)$$

$$C_i(\pi )=\sum _{k=2}^i{d}_{{\pi }_{k-1},{\pi }_k}+\sum _{j=1}^M{p}_{{\pi }_i,j}$$

$$RPD=\frac{C_{max}(\pi )-C_{max}({\pi }^{\ast })}{C_{max}({\pi }^{\ast })}\ast 100$$

Full text

1 Introduction

Scheduling problems represent an important class of combinatorial optimization problems, most of them being NP-hard. They consist in the allocation of different operations on a set of machines over the time. The aim of scheduling problems is to find the schedules (or solutions) that optimize one or more criteria such as the makespan or the flowtime.

Among these scheduling problems, the jobshop and the flowshop have been widely studied in the literature, as they represent many industrial situations. In this paper, we are specifically interested in the No-Wait Flowshop Scheduling Problem (NWFSP) (Röck, 1984). This extension of the classical Permutation Flowshop Scheduling Problem (PFSP) imposes that operations have to be processed without any interruption between consecutive machines. This constraint describes real process constraints that may be found in the chemical industry for example. It incorporates a specific structure on solutions we will exploit during the solving. Therefore we will conduct an analysis on some instances, of good quality solutions that will allow us to make an observation: sub-sequences of jobs are common within these solutions. This will lead us to define the concept of super-jobs (sub-sequences of consecutive jobs) and to exploit them into a Local-Search method (Holger H. Hoos, 2005).

Indeed, while solving NP-hard problems, the use of exact methods, mostly based on enumerations, is not practicable. Therefore heuristics and metaheuristics are developed. Heuristics designed for a specific problem can use, for example, priority rules to construct the schedule. Their advantages are their speed – most of them are greedy heuristics – and their specificity – characteristics of the problem to be solved can be exploited –. Metaheuristics, on their side, are generic methods that can be applied to many optimization problems. Their efficiency is linked to their high ability to explore the search space and the way the metaheuristic has been adapted to the problem under study. In this context, the aim of the present work is to study how the identification of super-jobs increases the performance of a metaheuristic, and more specifically a Local-Search, up to obtain new best-known solutions.

Indeed, as it will be exposed in the article, the concept of super-jobs has several advantages.

• •

First, it reduces the combinatorics of the problem – by reducing the search space – and makes feasible the use of efficient methods for small size problems.

• •

Second, it modifies the fitness landscape during the execution of the Local-Search and thus, avoid some local optima.

Experiments show that exploiting these super-jobs obtains very good results as a large number of new best solutions have been found out for large size instances of the commonly used Taillard’s benchmark (Taillard, 1993).

To expose the way we propose to define and exploit super-jobs, this article is organized as follows: Section 2.1 presents the No-Wait Flowshop Scheduling Problem and a brief literature review on the problem. Section 3 reports the analysis we conducted and the super-jobs are formally defined. Section 4 describes the proposed approach to exploit super-jobs, and Section 5 gives experimental results. Then, Section 6 improves the method with an iterated version and shows its performance. The last section presents some conclusions as well as some perspectives.

2 No-Wait Flowshop Scheduling Problem

Among the numerous scheduling problems, the Flowshop Scheduling Problem (FSP) consists in scheduling a set of $N$ jobs $\{J_{1},\dots,J_{N}\}$, on a set of $M$ machines $\{M_{1},\dots,M_{M}\}$. Several versions exist according to specific constraints that may be considered. In this article we are interested in the No-Wait version of this problem.

2.1 Problem Description

Presentation of the problem

The No-Wait Flowshop Scheduling Problem (NWFSP) is a variant of the well-known Permutation Flowshop Scheduling Problem (PFSP), where no waiting time is allowed between the processing of a job on the successive machines (Röck, 1984). Despite this constraint, the NWFSP remains a NP-hard problem.

More formally, the NWFSP may be defined as follows. Let $J$ be a set of $N$ jobs that have to be processed on a set of $M$ ordered machines; Machines are critical resources that can only process one job at a time. A job $J_{i}$ is composed of $M$ tasks $\{t_{i,1},\dots,t_{i,M}\}$ for the $M$ machines respectively. A processing time $p_{i,j}$ is associated to each task $t_{i,j}$. As for the PFSP, the sequence of jobs is the same on each machine, hence, a solution of the NWFSP is commonly represented by a permutation $\pi=\{\pi_{1},\dots,\pi_{N}\}$ where $\pi_{1}$ is the first job scheduled and $\pi_{N}$ the last one. In this paper, the goal is to find a sequence that minimizes the makespan ($C_{\mbox{max}}$) defined as the total completion time of the schedule (equation (1)).

[TABLE]

No-Wait variant specificity

The NWFSP possesses a characteristic not present in the classical PFSP that enables to reduce the computation time of the makespan of a sequence. This characteristic concerns the delay defined between two consecutive jobs as the start-up interval between the two jobs of a sequence on the first machine. Let $d_{i,i^{\prime}}$ be the delay between two jobs $i$ and $i^{\prime}$; it is computed as follows:

[TABLE]

For a better understanding of the specificities of the No-Wait Flowshop Scheduling Problem, Figure 1 provides a representation of a solution for an instance with five jobs and four machines. On this figure, the delay $d_{i,i^{\prime}}$ between two consecutive jobs $i$ and $i^{\prime}$ is indicated.

An interesting property is that the delay is constant and does not depend on the position of the two jobs within the sequence (Bertolissi, 2000). This has a direct impact on the computation of the makespan $C_{\mbox{max}}$, as it is easy to see on Figure 1, which actually corresponds to the sum of the delays between consecutive jobs and all the processing times of the last job scheduled.

Then, the completion time $C_{i}(\pi)$ of the job $\pi_{i}$ of sequence $\pi$ can be directly computed from the delays of the preceding jobs as follows:

[TABLE]

where $i\in\{2,...,N\}$. $C_{1}(\pi)$ is the sum of the processing times on the $M$ machines of the first scheduled job and then, it is not concerned by the delay. Therefore, the makespan ($C_{max}=C_{N}(\pi)$) of a sequence $\pi$ can be computed from equation (3) with a complexity of $O(N)$.

Neighborhood operator

Approaches we will present, involve local search methods. These ones use a neighborhood operator to move from a solution to another in the search space. In this work, we use a permutation representation and the insertion operator (Schiavinotto and Stützle, 2007), as it is known to make local search more efficient on flowshop problems (Kouvelis et al., 2000). This operator selects within a sequence $\pi$, a job $\pi_{i}$ and inserts it at position $k$ ($i\neq k$). Hence, jobs between positions $i$ and $k$ are shifted. Two sequences $\pi$ and $\pi^{\prime}$ are said to be neighbors when they differ from exactly one insertion move. The size of the neighborhood induced by this operator *i.e., *the number of neighboring solutions, is $(n-1)^{2}$. It is very interesting to note that exploiting the characteristics of the NWFSP, the makespan of $\pi^{\prime}$ can be directly computed from the makespan of $\pi$ with a complexity of $O(1)$ (Pan et al., 2007).

2.2 State-of-the-art

The NWFSP is NP-Hard when the number of machines is strictly higher than two (Röck, 1984). Thus, exact methods are not able to find the optimal solution in a reasonable time for large-scale instances. Recently, several heuristics and metaheuristics have been developed to tackle this problem. Table 1 lists the main approaches of the literature ordered by date and indicates the type of each one, either heuristic (H) or metaheuristic (M).

Heuristic approaches

Heuristic methods are mostly constructive. They usually start from an initial sequence of jobs ordered according to a criterion. Then, they build a solution by inserting jobs in this order, to optimize the objective function at each step. Some heuristics are either adaptations of heuristics developed for the classical permutation flowshop problem (PFSP) or have been specifically designed for the NWFSP. Hence, the well-known constructive heuristic NEH (Nawaz et al., 1983), initially designed for the PFSP, has been successfully applied on the No-Wait variant. Among heuristics specifically designed for the NWFSP, we may cite BIH (Bianco et al., 1999), BH (Bertolissi, 2000), GAN-RAJ (Gangadharan and Rajendran, 1993) and RAJ (Rajendran, 1994), LC (Laha and Chakraborty, 2008)), IBI (Mousin et al., 2017).

Metaheuristic approaches

Metaheuristics are efficient methods to explore large search space and mostly able to find solutions with a higher quality than constructive heuristics. Both bio-inspired and Local-Search  algorithms have been proposed to tackle the NWFSP. Regarding bio-inspired algorithms, we may find genetic algorithms (Aldowaisan and Allahverdi, 2003), particle swarm optimization (Pan et al., 2008), or differential evolution (Qian et al., 2009). On the other side, several Local-Search  approaches have also been proposed, such as tabu search (Grabowski and Pempera, 2005; Samarghandi and ElMekkawy, 2012), variable neighborhood search (VNS) (Jarboui et al., 2010) or simulated annealing (Aldowaisan and Allahverdi, 2003). Recently, Ding et al. (Ding et al., 2015) proposed a very efficient approach named TMIIG (Tabu-Mechanism Improved Iterated Greedy) based on a variable neighborhood search (Mladenović and Hansen, 1997). In the perturbation phase, the authors chose to use the efficient destruction-construction method of the Iterated Greedy (IG) (Ruiz and Stützle, 2007), initially proposed for the PFSP, and added a tabu mechanism to avoid scheduling a job at its previous positions during the different destruction-construction phases.

2.3 Benchmark

Taillard’s benchmark (Taillard, 1993), initially provided for the PFSP, is also widely used in the literature for the NWFSP. This benchmark proposes 120 instances, organized by 10 instances of 12 different sizes with a number of jobs $N\in\{20,50,100,200,500\}$ and $M\in\{5,10,20\}$. The higher the number of jobs and/or the number of machines, the more difficult the instance to solve. Data provided by these instances are the processing times of each job on each machine. Taillard’s instances are said to be random as the processing times are uniformly generated according to $\mathcal{U}[1;99]$. As far as we know, TMIIG is currently one of the best algorithms to solve Taillard’s instances since it has recently (in 2015) found out several new best solutions for the largest instances.

3 Super-jobs: Promising Sub-Sequences of Consecutive Jobs

For the NWFSP, each job is processing without interruption between the successive machines. Therefore, a question arises: does this specificity lead to a particular structure of the best solutions of a given instance. In this section, we conduct an analysis of the global and local optimum solutions in order to extract structural information on them. This analysis leads us to define a promising sub-sequence of consecutive jobs as a super-job. Then, we present a methodology to identify super-jobs of an unknown instance in order to use them to solve it.

3.1 Structural Analysis of Optimum Solutions

This analysis aims at extracting similarities in the structure of efficient schedules *i.e., *good quality solutions. We conduct this analysis on small instances (low number of jobs) with processing times uniformly generated following the methodology of Taillard’s instances (see Section 2.3). We report here, as an example, the analysis of an instance with 12 jobs and 5 machines. This problem size (12) enables to exhaustively enumerate the search space and therefore, to identify the global optimum and the best local optima111Local optima are solutions that have no better neighboring solutions *i.e., *no insertion move could lead to a strictly better quality solution.. Indeed, local optima are interesting to analyze since they may trap local search methods that explore the search space moving iteratively to improving neighbors. In the following, the term optimum solutions (or optima) is used to deal with the global or local optimum solutions more generally.

Figure 2 gives the global optimum and the 10 best local optima of the studied instance of size 12. For this small instance, it is easy to see that these best optima share a similar structure between them and with the global optimum. Indeed, job $8$ is always positioned at the beginning of the schedule and two sub-sequences of two consecutive jobs are present in all of them: $[0~{}4]$ in green, and $[11~{}2]$ in red and one sub-sequence in 10 over 11 solutions: $[9~{}1]$ colored in blue. Local optima can not be improved by applying the insertion operator. However, if we consider each identified sub-sequence of consecutive jobs as a unique job, the best local optimum ($C_{max}=1036$) differs from the global optimum ($C_{max}=1021$) by the single move of the sub-sequence $[11~{}2]$ only. In the same manner, applying the insertion operator on the other local optima with the consideration of the identified sub-sequences instead of single jobs moves all the local optima (except the one of $C_{max}=1176$ identified with a star) to the global optimum.

As mentioned before, this study has been conducted on a small instance to be able to exhaustively enumerate the search space. Here, only sub-sequences of two consecutive jobs were found. However, the size is not limited. Hence, if a job $a$ is always followed by a job $b$ and, the job $b$ is always followed by a job $c$ then, the sub-sequence $[a~{}b~{}c]$ of three consecutive jobs has to be considered rather than the two sub-sequences $[a~{}b]$ and $[b~{}c]$ separately.

Observations made in this analysis motivate the substitution of original jobs by promising sub-sequences of jobs to favor to reach better quality solutions. This transformation of the original problem may represent a good opportunity to solve large size instances. Therefore a question arises: how to define and identify the promising sub-sequences?

3.2 Definition of Super-Jobs

The previous exhaustive analysis of the structure of local optima for small size instances leads us to suppose that a similar behavior appears on larger ones. In this section, we present the methodology we propose to identify promising sub-sequences of an unknown instance to be solved.

Regardless the size of the search space, good quality solutions and more precisely, good quality local optima, hopefully share a similar structure. When the search space is non enumerable, it is commonly admitted to use a sample of solutions in order to analyze their structure, characteristics …

Here, we propose to extract the promising sub-sequences from a pool $\mathcal{P^{*}}$ of good quality local optima and to define a super-job with a confidence of $\sigma$, any sub-sequence of consecutive jobs that appears at least $\sigma$ percent of times in solutions of $\mathcal{P^{*}}$. For example, if $\sigma=50\%$, the super-jobs are the sub-sequences of consecutive jobs shared by half of the solutions of $\mathcal{P^{*}}$. Let us note that only the longest sub-sequences are considered as super-jobs. For example, if both $[a~{}b]$ and $[b~{}c]$ appear at least $\sigma$ percent of times in $\mathcal{P^{*}}$, only $[a~{}b~{}c]$ is defined as a super-job.

This methodology has the advantage to be relevant regardless the problem size. However, the main drawback may be the computational time required to generate the pool of good quality solutions. Therefore, the size of the pool has to be fixed carefully: too large means that too much time would be spent to generate the pool, too small means that the identification of the super-jobs would be insignificant. This aspect will be discussed during the experimental section.

3.3 Advantages of Super-Jobs

The advantages of considering sub-sequences of consecutive jobs (super-jobs) as unique jobs are several. First, for a complexity point of view, it will reduce the combinatorics of the problem *i.e., *the number of potential solutions. Secondly, for a local search point of view, this will modify the search space and the landscape induced by the insertion operator and so, new regions of the search space may become reachable.

In order to provide a better understanding of the impact of super-jobs on the landscape, we present a visualization in 2D of the landscape transformation in Figure 3. Each point of the graph represents a solution. Blue points represent the original landscape, considering solutions constructed from original jobs following a neighborhood relationship (in the simplified representation, a solution has two neighbors). Red points represent the modified landscape obtained while considering super-jobs. Clearly, the use of super-jobs smooths the landscape and makes it easier to avoid some original local optima which disappeared.

4 Iterated Greedy with Learning

Super-jobs have been defined as common structural characteristics of good quality solutions. In this section we propose an approach that exploits these super-jobs to improve an already efficient heuristic proposed in the literature for the PFSP – the Iterated Greedy (IG) – in order to reach new best solutions for the Taillard’s instances. Thus, this section presents the IG Algorithm first, and then the proposed approach.

4.1 Iterated Greedy Algorithm

The Iterated Greedy (IG) algorithm (Ruiz and Stützle, 2007), initially proposed for the classical Permutation Flowshop Scheduling Problem (PFSP), is an iterated local search, based on the insertion operator, whose perturbation phase removes some jobs from a solution, and reinserts them one by one at their best position *i.e., *the position that minimizes the partial makespan. The local search itself is an iterative improvement: each job of the sequence is considered in a random order and is re-inserted at its best position. This process is repeated until a local optimum is reached. The acceptance criterion of IG is inspired from the one of the simulated annealing and, checks if the new local optimum found is better or not than the best one ever found during the run. IG is known to be efficient to solve many variants of PFSP. However, even if it is able to reach good quality solutions in a reasonable computational time, it is not able to reach, for the NWFSP, the best-known solutions of the largest instances of Taillard’s. Indeed, currently, the best algorithm for the NWFSP is the recent algorithm TMIIG (Ding et al., 2015), inspired from IG (see Section 2.2). Since the performance of IG is doubtless to solve small and medium sizes instances and, since the use of super-jobs decreases the problem size, we propose to design a new algorithm taking advantage of both IG and the super-jobs.

4.2 Iterated Greedy with Super-Jobs Algorithm

The Iterated Greedy with super-jobs algorithm (IG${}_{\mbox{{\scriptsize SJ}}}$) identifies super-jobs of several increasing levels of confidence during the search and exploits them into the basic IG algorithm (Ruiz and Stützle, 2007). Algorithm 1 gives the pseudo-code of this new algorithm. Given a pool of good quality local optima, whose generation will be discussed later, and an increasing list $\Sigma=\{\sigma_{1},\sigma_{2},\dots,\sigma_{n}\}$ of levels of confidence, IG${}_{\mbox{{\scriptsize SJ}}}$  first identifies super-jobs regarding the first level of confidence $\sigma_{1}$. Afterwards, an initialization method generates a first solution $\pi$ with these identified super-jobs. A process is then, iterated for each level of confidence of $\Sigma$, alternating between (i) a phase of super-jobs identification (except for the first level of confidence $\sigma_{1}$) and (ii) a phase of improvement using IG. The Iterated Greedy algorithm is executed on the solution considering super-jobs as jobs of the problem. As IG has no natural stopping criterion, a maximal time, as well as a maximal number of iterations without improvement, are used to stop the IG phase. Once all the levels of confidence have been used, the algorithm returns the best-found solution over the run. Figure 4 illustrates IG${}_{\mbox{{\scriptsize SJ}}}$  behavior with two levels of confidence $\Sigma=\{60\%,80\%\}$.

Table 2 presents the evolution of the solution $\pi$ for all phases of an execution of IG${}_{\mbox{{\scriptsize SJ}}}$  on the instance ta023 of Taillard (20 jobs, 20 machines) with the list of confidence levels $\Sigma=\{60\%,80\%,\infty\}$, where $\sigma=\infty$ means that no super-job is created (the problem is solved with all the original jobs). In this example, with $\sigma=60\%$, seven super-jobs are identified (phase (i)): one of size 12, two of size 2 and the fourth-remaining ones of size 1. Therefore, the problem size is decreased from 20 to 7. The initialization method then builds a local optimum with a quality of 3021 that IG is not able to improve (phase (ii)). Then, considering a confidence level of $\sigma=80\%$, some previous super-jobs are decomposed (phase (i)). Indeed, the largest super-job is decomposed into eight smaller ones. The problem size is equal to 14 and IG manages to find a better solution with a quality of 3013 (phase (ii)). It appears, in this special case, that the global optimum is reached within this second phase. This explains why the last phase ($\sigma=\infty$, super-jobs are all of size 1) is not able to produce any improving solution.

5 Experiments

In order to assess the efficiency of the IG${}_{\mbox{{\scriptsize SJ}}}$  algorithm, experiments are driven on Taillard’s benchmarks and results compared to the previous best-known solutions of the literature obtained by TMIIG (Ding et al., 2015).

5.1 Experimental Protocol

As exposed in section 2.2, the benchmark used to evaluate the performance of the proposed method is composed of Taillard’s instances (Taillard, 1993) organized by 10 instances of 12 different sizes. The algorithm was implemented in C++ and the experiments were executed on an Intel(R) Xeon(R) 3.5GHz processor.

Following a preliminary study, several parameters was settled for these experiments:

• •

Initial pool of solutions $\mathcal{P}^{*}$: 10 solutions (enough to extract knowledge) were generated from 10 independent executions of IG with a maximal time of $n^{2}*10$ ms each.

• •

Levels of confidence: Two lists $\Sigma_{1}=\{60\%,80\%,\infty\}$ and $\Sigma_{2}=\{60\%,70\%,80\%,90\%,\infty\}$ were tested in order to evaluate the performance of IG${}_{\mbox{{\scriptsize SJ}}}$  according to the granularity.

• •

Initialization method: Iterated Best Insertion heuristic (Mousin et al., 2017) a constructive heuristic hybridized with a basic local search (first improvement hill climbing).

• •

Stopping criterion of IG in phase ii: A maximal time of $n_{sj}^{2}*10$ ms (where $n_{sj}$ is the number of super-jobs of the phase), and a maximal number of iterations without improvement of $50*n_{sj}$ are defined.

Each execution of IG${}_{\mbox{{\scriptsize SJ}}}$  on a given instance $\mathcal{I}$ returns a solution $\pi$ of fitness $C_{max}(\pi)$. To measure the quality of the solution, the Relative Percentage Deviation (RPD) is computed relatively to the best-known solution of the literature $\pi^{*}$ as follows:

[TABLE]

Hence a negative RDP indicates that a new best known solution is found.

IG${}_{\mbox{{\scriptsize SJ}}}$  is stochastic, thus 30 runs were executed to make the experimental results robust, and performance for an instance $\mathcal{I}$ is the average of the 30 RPD computed.

5.2 Experimental Results

To analyze performance of the IG${}_{\mbox{{\scriptsize SJ}}}$  algorithm, results obtained are compared with the best-known solutions of the literature, reported in (Ding et al., 2015). Tables 3 (list $\Sigma_{1}$) and 4 (list $\Sigma_{2}$) indicate, for each instance (10 instances per size) if the best-known solution of the literature is reached (cells colored in gray) and if this best-known is improved (non empty cell). Hence, when a number is present in a cell, this indicates the number of times the method improves the previous best-known solution over the 30 executions, an ’x’ indicates 30/30. The results obtained for the 30 instances with 20 jobs are not reported here as a simple IG manages to find the optimal solution. Both tables show that for all instances the method reaches the best-known of the literature regardless the two lists of confidence levels $\Sigma_{1}$ and $\Sigma_{2}$. In addition they show that all instances with 100, 200 and 500 jobs are improved with the proposed IG${}_{\mbox{{\scriptsize SJ}}}$  algorithm. The detail of the new best makespan values reached by the method is given in Tables 9 and 10 in the A.

To deeper analyze the behavior of the method, Tables 5 and 6 report some information about the execution of the method for the two lists $\Sigma_{1}$ and $\Sigma_{2}$. Results presented are average over the 30 executions of all instances (10) of a same size. Both tables have the same structure and the conclusions are also similar. We will first discuss about the common analyses and then point out differences within the discussion.

Left parts of these tables report the size of the problem *i.e., *the number of jobs for each phase. These jobs are either original jobs, or the super-jobs constructed by the concatenation of several jobs, as explained before. This measure gives the combinatorics of the problem. For example, in Table 5 for instances of size 200, when $\sigma=60\%$, the number of jobs is around 80-90. This means that the size of the problem has been divided by more than 2. In the following phase, when $\sigma=80\%$, some super-jobs are decomposed and the number of jobs is around 130-140. The combinatorics is still reduced. As mentioned before when $\sigma=\infty$ the number of jobs equals the original number of jobs (*i.e., *200 for the previous example). This first observation indicates that there is a real difference between the set of jobs obtained for the two levels of confidence, which shows that the identification of super-jobs is different.

Another observation is that the number of machines has also an impact on the identification of super-jobs. Indeed for a given number of jobs, the more the number of machines, the smaller the combinatorics. As far as instances of size 500 are concerned, the high level of combinatorics may be explained by the use of IG to generate the pool of solutions. Indeed, IG has difficulty to converge for large size problems within the time allowed. Hence the solutions of the pool are too diversified to identify common sub-sequences of jobs.

Measures about the convergence of IG${}_{\mbox{{\scriptsize SJ}}}$  are given in the middle part of the two tables. The column, called End of improvement, indicates in percentage, the number of times (over the 30 executions) the method – $Init$ or $IG$ – reaches the best solution of the run (average of the 10 instances of each size). We can observe, that in both tables, for instances of size 20, the best solution is mainly reached during the initialization phase. Indeed, for small size instances, IG is very efficient and manages to reach best-known solutions. For size 50, the IG${}_{\mbox{{\scriptsize SJ}}}$  manages to almost always find its best solution before considering the original problem ($\sigma=\infty$) contrary to the original IG. This validates the use of super-jobs. However, for largest size problems, some improvements are still obtained in the last phase when the original problem is considered.

This analysis is re-enforced by the third set of columns of both tables that report the average RPD at each phase. Thus it indicates, how far from the best-known solution of the literature, are solutions reached after each phase. Let us recall that a negative value indicates that a new best solution has been found. For instances of size 20, the best-known solution, which is optimal, is reached (RPD=0). For size 50, the best-known solutions are often reached (but maybe not in all the executions, which explained a small positive RPD). The most interesting is for large instances, as best known solutions are improved (negative RPD). A complementary interesting observation for large size instances is the high improvement between the initialization and the first phase with $\sigma=60\%$. In the following phases, even if some better solutions are reached, the improvement is less important but significant.

The right part of the two tables reports time spent at each phase. The stopping criterion, at each phase, is either a maximal time or a maximal number of iterations without improvements, both depending on the number of (super-)jobs (see Section 5.1). So, as we can expect, for most cases, the time spent increases with the value of confidence level. Note that the total time is quite significant (the computational time for the generation of the pool of solutions still have to be added), but the objective of the approach is to be able to find new best solutions. So we do not consider real computing time constraints.

5.3 Discussion

The experimental results proved the performance of our approach (IG${}_{\mbox{{\scriptsize SJ}}}$) since new best solutions have been found out for every largest Taillard’s instance. This section provides a discussion on two important aspects of the method: the computational time required for the generation of the pool of solutions, and the analysis of the dynamic of the method.

Discussion on the generation of the pool $\mathcal{P^{*}}$

The computational time of the proposed method may represent a drawback when solving large instances. This computational time is partly explicated by the generation of the pool of solutions $\mathcal{P^{*}}$.

The fact is that the performance of the approach is based on the knowledge extraction from this pool of initial solutions used to identify pertinent super-jobs. Preliminary results show that the quality of the solutions of the pool impacts a lot the performance, and hence constructive heuristics do not give enough good quality solutions to identify reliable super-jobs. Hence, we chose IG, with a time limit, to give pretty good quality solutions for the pool of solutions, but it is time consuming. In addition, we tested different sizes for the pool. Indeed, the higher the size, the larger the computational time to generate the pool whereas the lower the size, the lower the chance to have a representative pool. Following these tests we decided to generate a pool of 10 solutions only, as pertinent super-jobs can be found out, even with so few solutions. A small pool reduces a lot the whole computational time of the approach. However, the time still remains important. For example, to solve a 200 jobs instance, 400 seconds are required to generate one solution of the pool, hence around one hour for the 10 solutions of the pool. This is quite long, but not so important if we want to obtain new best solutions.

Since our approach is stochastic, in the exposed experiments, the performance is evaluated from 30 executions of IG${}_{\mbox{{\scriptsize SJ}}}$  for each instance. Each one generates its own pool of good quality solutions. We drove some parallel experiments where a single pool of 10 solutions was generated only and was shared between the 30 executions. The experimental results were similar: best-known solutions of the literature were reached for the smallest instances of Taillard, and improved for the largest one. Using such a shared pool decreases the whole computational time for the 30 executions.

During the analysis of the method, we also noticed that for largest instances (with 500 jobs, mainly) a better pool of solutions improves the identification of super-jobs and then still reduces the combinatorics. Thus, we can imagine leaving more computational time to IG to generate a shared pool of better quality solutions, instead of generating one different pool for each execution.

Discussion on the behavior of the method

Another interesting aspect is that the performance of the approach lies on the reduction of the combinatorics of the problem made possible by the particular structure of the best quality local optima. In the search space, each local optimum is the ’center’ of a basin of attraction. All the basins make the landscape very rugged for Local-Search  methods. The perturbation phase of IG has been designed to escape from local optima, and so, from their attraction basins. However, the basins of attraction are not side-by-side but included in each other; the best local optimum of a large basin may be the center of other ones. Hence, even with a perturbation, a Local-Search  method often remains in the same large basin of attraction it started. The reduction of the combinatorics of the problem, with the identification of super-jobs, produces an interesting effect on the landscape. Indeed, some original local optima do not exist in the reduced landscape and so, for its basins of attraction. Therefore, regions of the landscape are smoothed, original basins of attractions get larger and, the performance of IG at each iteration of our approach is improved. For example, for instances with 20 jobs (the easiest of the Taillard instances), IG ends to converge close to the best-known solutions without reaching it, whereas with the reduction of the combinatorics, it reaches it each time. The reduction of the number of basins of attraction helps IG to move towards the best one. Exploiting super-jobs erases rugged regions of the search space and increases the performance of IG. These encouraging results lead us to incorporate (IG${}_{\mbox{{\scriptsize SJ}}}$) in a more general scheme.

6 IIG${}_{\mbox{\scriptsize SJ}}$: an Iterative Version

6.1 Description

The experimental results presented above, showed that the learning mechanism is efficient for both small and large size instances. Indeed, IG${}_{\mbox{{\scriptsize SJ}}}$  is able to either find out new best solutions or at least to reach the best-known solutions for the Taillard instances. For the largest (and actually the most difficult) instances of size 100, 200 and 500, new best solutions were discovered. However the successive RPD values (see Section 5.2 Tables 3 and 4) show that IG${}_{\mbox{{\scriptsize SJ}}}$  still improves the solution when the original problem is considered ($\sigma=\infty$). This suggests IG${}_{\mbox{{\scriptsize SJ}}}$ may be improved. For instances of size 500, we noticed that the initial solutions used to identify the super-jobs are very diversified (the size of the problem was barely reduced by two with the lower level of confidence $\sigma=60$) because the original IG is not efficient for this size. Undoubtedly, this has an effect on the performance of the whole execution of IG${}_{\mbox{{\scriptsize SJ}}}$. Iterating IG${}_{\mbox{{\scriptsize SJ}}}$ from the solutions obtained at the end of the 30 executions may improve the quality as well as the size of super-jobs identified and so the performance of the algorithm.

The proposed iterative approach (IIG${}_{\mbox{\scriptsize SJ}}$) given in Algorithm 2 is based on this idea.

IIG${}_{\mbox{\scriptsize SJ}}$  starts with a set $\mathcal{P}_{0}$ of $R$ solutions, iterates $I$ times the inner procedure and returns the best solution $\pi^{*}$ found. The inner procedure aims at building sets of solutions with better and better qualities in order to identify super-jobs hopefully being those of the optimal solution. At iteration $i\in I$, it starts with $\mathcal{P}_{i}$ as an empty set where $R$ new solutions will be iteratively added following these three steps: (i) first, $\rho$ solutions are uniformly picked at random from the set $\mathcal{P}_{i-1}$ and stored in a temporary set $\mathcal{P}_{tmp}$ then (ii), IG${}_{\mbox{{\scriptsize SJ}}}$  is applied with $\mathcal{P}_{tmp}$ and $\Sigma$ to obtain a new solution $\pi$ that is finally (iii), stored in $\mathcal{P}_{i}$, the set of the current iteration $i$; if $\pi$ is better than the current $\pi^{*}$ then it replaces it. The parameter $\rho$ is used to select a subset of solutions and then to maintain the diversity in the constructed pool $\mathcal{P}_{tmp}$, otherwise the same super-jobs would be identified for each confidence level in phase (ii). Figure 5 gives an illustration of the inner procedure.

6.2 Experimental Protocol

IIG${}_{\mbox{\scriptsize SJ}}$  presents its own parameters to settle in addition to those of IG${}_{\mbox{{\scriptsize SJ}}}$. The number of solutions $R$ of a pool $(\mathcal{P}_{i})_{i\geq 0}$ has been set to 20 that is statistically reasonable to evaluate the average performance of the approach; the number of solutions $\rho$ set to 10 like in the experiments of Section 5 where 10 solutions were used to identify the super-jobs, and the number of iterations $I$ set to 5, enough to converge and to prevent over-learning. Iterated greedy (IG) (Ruiz and Stützle, 2007) is still the algorithm used in IG${}_{\mbox{{\scriptsize SJ}}}$  to improve solutions. It is stopped when either a maximal time of $n_{sj}^{2}$ ms (where $n_{sj}$ is the current number of super-jobs) or a maximal number of iterations without improvement of $25*n$ is reached. Note that this stopping criterion is shorter than the one set in the previous experiments (Section 5). Indeed, since the process is iterated, the end of the convergence is not mandatory for each execution of IG. Moreover, the use of IG${}_{\mbox{{\scriptsize SJ}}}$  requires the setting of the parameter $\Sigma$ to identify the jobs with different levels of confidence. We use $\Sigma=\{60\%,70\%,80\%,90\%,\infty\}$ since the previous experiments showed better results for large size instances with this setting.

6.3 Experimental Results

Table 7 reports the best-known solutions of all Taillard instances and gives the gap value between the results obtained by our approach and the previous best-known solutions of the literature obtained by TMIIG (Ding et al., 2015). A gap equal to 0 means IIG${}_{\mbox{\scriptsize SJ}}$  reaches the best-known solutions of TMIIG, and a strictly negative gap means it finds out a solution with a better quality *i.e., *a new best-known solution. This table shows that for the largest instances of size 100, 200 and 500 jobs, IIG${}_{\mbox{\scriptsize SJ}}$  improves the good results already obtained with IG${}_{\mbox{{\scriptsize SJ}}}$  and finds out new best-known solutions. The quality of the best solution has been improved up to 478 like for the instance Ta112 for example. Clearly, IIG${}_{\mbox{\scriptsize SJ}}$  is very efficient to solve uniform instances of the no-wait flowshop scheduling problem like Taillard instances. As far as we know, Table 7 reports the values of the best-known solutions of the literature for the Taillard instances at this time. The full description (schedule $+$ makespan) of the best solutions is given online222blinded_webpage.

In the following, we detail the results obtained by IIG${}_{\mbox{\scriptsize SJ}}$  and discuss the interest of using IG${}_{\mbox{{\scriptsize SJ}}}$  iteratively. We present the results by grouping Taillard instances according to the 12 different sizes ($N\times M$) since the number of jobs $N$ and the number of machines $M$ impact the resolution of the problem. In our experiment, one iteration of IIG${}_{\mbox{\scriptsize SJ}}$  provides 20 solutions. All the solutions obtained after each iteration during a run of IIG${}_{\mbox{\scriptsize SJ}}$  are memorized in order to make an a posteriori analysis to validate the interest of iterating the approach of IG${}_{\mbox{{\scriptsize SJ}}}$. After running IIG${}_{\mbox{\scriptsize SJ}}$  on Taillard instances, the qualities of the solutions obtained after each iteration and the (new) best-known quality (values reported in Table 7) are compared to compute the RPD value (see Section 5.1). Table 8 gives the average RPD computed from the 200 values obtained (20 solutions per iteration, 10 instances by size) for each iteration of IIG${}_{\mbox{\scriptsize SJ}}$. A null RPD value means that the quality of the 200 solutions provided at the considered iteration is equal to the best-known quality for each of the 10 instances respectively. A strictly positive RPD value means that at least one solution provided at the end of the iteration does not have the best-known quality. As expected, the average RPD decreases with the successive iterations that shows the interest of exploiting the solution provided by an iteration to identify new and better super-jobs. This decrease is illustrated on Figure 6 that shows the associated boxplots for the most difficult instances (20-jobs instances are optimally solved from the beginning).

A line separates each graphic: the left part corresponds to the first iteration (like one execution of IG${}_{\mbox{{\scriptsize SJ}}}$) while the right part corresponds to the next iterations performed in IIG${}_{\mbox{\scriptsize SJ}}$. We observe that the larger the instance size, the larger the improvement of the median quality. Between iteration 4 and iteration 5, for different instances (eg. 100$\times$ 10, 100$\times$ 20, 200$\times$ 10), some qualities are even deteriorated. This may be explained by over-learning where the solutions in the sets $\mathcal{P}_{3}$ or $\mathcal{P}_{4}$ are too similar, and so the approach has difficulties to detect new super-jobs and get stuck in a particular region of the search space. Therefore the number of iterations of IIG${}_{\mbox{\scriptsize SJ}}$  has to be set carefully to avoid over-learning and a loss of time computing.

Table 8 reports also, in seconds, the average execution time for each iteration and the average of the total time. Since the execution time depends on the number of (super-)jobs (see Section 6.2), it increases a lot when the number of jobs increases. This value nearly reaches 96,838 seconds for the largest instances (size 500) *i.e., *almost 28 hours. Obviously, this time is not satisfactory practically. But, in these experiments, our goal is to simply improve the performance of our initial approach IG${}_{\mbox{{\scriptsize SJ}}}$  to find out new best solutions ; what was done. If we analyze more carefully the average times for each iteration, we observe a reduction of the time inversely proportional to the instance size, the larger this reduction the higher the number of jobs. We may explain this by the increase of the size of the super-jobs and the decrease of their numbers. Solutions are more and more similar within the set and so may share larger sub-sequences of jobs that gives a smaller and smaller number of jobs.

7 Conclusion

This paper presents IG${}_{\mbox{{\scriptsize SJ}}}$  a new approach based on the Iterated Greedy algorithm that found out 64 new best solutions of Taillard’s instances for the No-Wait Permutation Flowshop Scheduling Problem (NWFSP). The novelty of this approach is to modify the landscape during the search by first reducing the size of the initial problem and then, increasing it. This process is allowed by the observed common structure of the best good quality solutions of the NWFSP that present common sub-sequences of consecutive jobs. The identification of these sub-sequences has been discussed in the paper and has led to the definition of super-jobs with a confidence level. Super-jobs are considered as a single job of the problem therefore, the confidence level indirectly determines the size of the problem to be solved. The proposed approach consists in successively exploiting these super-jobs into the execution of Iterated Greedy.

In the experiments, we show that the number of super-jobs, identified with a middle level of confidence (here, 60%) reduces by the half the size of the problem. Therefore, the Iterated Greedy algorithm more easily discovers good regions of the search space. The increase of the confidence level decomposes little by little the previous identified super-jobs hence, the search space is revealed gradually.

Besides, IG${}_{\mbox{{\scriptsize SJ}}}$  has been integrated in an iterative approach, called IIG${}_{\mbox{\scriptsize SJ}}$, to take advantage of the solutions found after each execution to identify better and better super-jobs. Despite the high computational time of this method, the performance of IG${}_{\mbox{{\scriptsize SJ}}}$  has been successfully improved since the 64 new best solutions found out by IG${}_{\mbox{{\scriptsize SJ}}}$have been overtaken. This work shows the benefit of using knowledge into optimization method such as meta-heuristics, and shows the impact of the quality of the knowledge used.

Future works will focus on how to adapt this approach for other permutation problems and so, how to identify other means to extract knowledge from the best solutions. Moreover, the different increasing levels of confidence, needed to identify the super-jobs, will be analyzed to try to set the values in function of the instance.

Appendix A Value of best solutions found by the simple version algorithm

Here are given the best solutions found by IG${}_{\mbox{{\scriptsize SJ}}}$. Table 9 reports value obtained with the first configuration ($\Sigma=60\%,80\%,\infty$), and Table 10 with the second configuration ($\Sigma=60\%,70\%,80\%,90\%,\infty$). A bold value indicates that a new best solution has been found. These tables do not report results for instances with 20 jobs, as for these small instances, optimal solutions are already found in the literature.