A hybrid Lagrangean metaheuristic for the two-machine cross-docking flow shop scheduling problem

TL;DR

This paper introduces a hybrid Lagrangean metaheuristic to optimize truck scheduling in cross-docking centers, significantly improving efficiency in minimizing makespan compared to existing methods.

Contribution

It proposes a novel hybrid Lagrangean metaheuristic approach for the two-machine flow shop scheduling problem with precedence constraints in cross-docking, outperforming current solutions.

Findings

Outperforms existing methods on small and large instances

Efficiently generates upper and lower bounds within polynomial time

Reduces makespan in cross-docking truck scheduling

Abstract

Cross-docking is a logistics strategy that minimizes the storage and picking functions of conventional warehouses. The objective is to unload the cargo from inbound trucks and directly load it into outbound trucks, with little or no storage. The success of the strategy depends on an efficient transshipment operation. This work undertakes a study of truck scheduling in a cross-docking center. The problem is modeled as a two-machine flow shop scheduling problem with precedence constraints, with the objective of minimizing the makespan. The proposed method is based on a Lagrangean relaxation solved by a Volume algorithm over a time-indexed formulation. We use polynomial time heuristics for generating efficient upper and lower bounds in a computationally efficient time, outperforming current results in the literature for small and large size instances.

Figures

Tables

Table 1. Table 1: Previous specific research works for the truck scheduling problems. Based on [ 17 ] .

Publication	Notation	Complexity	Contribution
Miao et al. [41]	[$M|limit,t_{io}|\star$]	NP-hard	MM, HM, P
Chen and Lee [21]	[$E2|t_j=0|C_{max}$]	NP-hard	B, ES, P
Chen and Lee [21]	[$E2|t_j=0|C_{max}$]	NP-hard	P
Chen and Song [22]	[$E|t_j=0|C_{max}$]	NP-hard	MM, HS, B
Boysen [16]	[$E|p_j=p,no-wait,t_j=0|\sum T_o$]	Open	MM, HM, ES
Boysen and Fliedner [17]	[$E|t_{io},f_{ix}|\sum W_s{U}_s$]	NP-hard	MM, P
Boysen and Fliedner [17]	[$E|t_i=0,f_{ix}$ $|$ $\sum W_s{U}_s$]	NP-hard	P
Boysen et al. [18]	[$E2|p_j=p,change|C_{max}$]	NP-hard	MM, HS, HI, ES, P
McWilliams [40]	[$E|no-wait|\ast$]	Open	HM
Vahdani and Zandieh [54]	[$E2\left|change\right|C_{max}$]	NP-hard	MM, HM
Melo and Araujo [5]	[$E|t_j=0|C_{max}$]	NP-hard	HM
Arabani et al. [4]	[$E2\left|change\right|C_{max}$]	Open	HM
Larbi et al. [33]	[$E2\left|pmtn\right|\ast$]	NP-hard	MM, ES
Alpan et al. [3]	[$E\left|pmtn\right|\ast$]	Open	MM, ES
Lima [39]	[$E2|t_j=0|\sum C_j^2$]	NP-hard	MM, HS, HM
Cota et al. [26]	[$E|t_j=0|C_{max}$]	NP-hard	MM, HS

Table 2. Table 2: Summary of the artificial benchmark.

Group	Jobs	Jobs	NP	TP
	M1(n)	M2(m)
	5	3-4-5-6-7	U(1,4)	U(1,10)
	10	6-8-10-12-14	U(1,9)	U(1,10)
1	20	12-16-20-24-28	U(1,19)	U(1,10)
	40	24-32-40-48-56	U(1,39)	U(1,10)
	60	36-48-60-72-84	U(1,59)	U(1,10)
	5	3-4-5-6-7	U(1,4)	U(10,100)
	10	6-8-10-12-14	U(1,9)	U(10,100)
2	20	12-16-20-24-28	U(1,19)	U(10,100)
	40	24-32-40-48-56	U(1,39)	U(10,100)
	60	36-48-60-72-84	U(1,59)	U(10,100)

Table 3. Table 3: Computational results for complete model and constructive heuristics.

		Group 1 - Processing time [1, 10]										Group 2 - Processing time [10, 100]
n	m		MIP		JB		CDH		H1		H2		MIP		JB		CDH		H1		H2
			GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)	GAP	T(s)
5	3	Best	0.0%	0.1	0.0%	0.0	15.2%	0.0	0.0%	0.0	0.0%	0.0	0.0%	6.7	0.0%	0.0	7.8%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	0.2	6.8%	0.0	26.3%	0.0	4.8%	0.0	4.8%	0.0	0.0%	21.0	2.4%	0.0	28.8%	0.0	2.3%	0.0	2.3%	0.0
	4	Best	0.0%	0.1	0.0%	0.0	2.7%	0.0	0.0%	0.0	0.0%	0.0	0.0%	3.9	0.0%	0.0	3.0%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	0.3	7.7%	0.0	22.3%	0.0	5.9%	0.0	5.9%	0.0	0.0%	354.9	7.5%	0.0	24.2%	0.0	6.2%	0.0	6.2%	0.0
	5	Best	0.0%	0.3	4.5%	0.0	17.1%	0.0	0.0%	0.0	0.0%	0.0	0.0%	32.6	3.8%	0.0	19.3%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	0.5	9.8%	0.0	32.8%	0.0	2.5%	0.0	3.3%	0.0	0.8%	1570.1	9.9%	0.0	33.4%	0.0	2.6%	0.0	2.6%	0.0
	6	Best	0.0%	0.1	4.8%	0.0	13.0%	0.0	0.0%	0.0	0.0%	0.0	0.0%	80.9	5.7%	0.0	13.5%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	1.3	16.6%	0.0	29.4%	0.0	5.2%	0.0	5.5%	0.0	11.8%	2388.3	16.1%	0.0	30.7%	0.0	4.8%	0.0	6.2%	0.0
	7	Best	0.0%	0.2	0.0%	0.0	16.7%	0.0	0.0%	0.0	0.0%	0.0	0.0%	94.9	0.0%	0.0	16.6%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	3.7	14.1%	0.0	36.4%	0.0	6.3%	0.0	5.4%	0.0	13.1%	2882.5	13.9%	0.0	38.0%	0.0	5.1%	0.0	6.7%	0.0
\hdashline      Subgroup Average			0.0%	1.2	11.0%	0.0	29.4%	0.0	4.9%	0.0	5.0%	0.0	5.1%	1443.4	10.0%	0.0	31.0%	0.0	4.2%	0.0	4.8%	0.0
10	6	Best	0.0%	5.1	0.0%	0.0	7.5%	0.0	0.0%	0.0	0.0%	0.0	28.7%	2801.1	0.7%	0.0	8.9%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	20.2	11.8%	0.0	24.8%	0.0	1.8%	0.0	1.7%	0.0	28.2%	3509.9	11.3%	0.0	23.0%	0.0	1.4%	0.0	1.4%	0.0
	8	Best	0.0%	10.2	2.7%	0.0	9.6%	0.0	0.0%	0.0	0.0%	0.0	23.6%	3597.6	2.3%	0.0	15.0%	0.0	0.0%	0.0	0.0%	0.0
		Average	0.0%	167.5	13.3%	0.0	25.8%	0.0	6.0%	0.0	5.4%	0.0	36.7%	3600.0	17.0%	0.0	30.5%	0.0	3.7%	0.0	4.2%	0.0
	10	Best	0.0%	14.1	1.4%	0.0	14.8%	0.0	0.0%	0.0	2.2%	0.0	35.7%	3600.0	2.2%	0.0	26.4%	0.0	4.6%	0.0	1.0%	0.0
		Average	0.0%	369.6	15.9%	0.0	28.8%	0.0	6.5%	0.0	6.4%	0.0	45.2%	3600.0	18.4%	0.0	36.8%	0.0	7.6%	0.0	7.9%	0.0
	12	Best	0.0%	42.1	3.9%	0.0	17.6%	0.0	0.0%	0.0	0.0%	0.0	51.7%	3600.0	3.1%	0.0	19.3%	0.0	0.0%	0.0	0.0%	0.0
		Average	5.0%	2440.5	14.0%	0.0	41.0%	0.0	5.4%	0.0	5.3%	0.0	65.2%	3600.0	13.9%	0.0	40.8%	0.0	5.4%	0.0	5.4%	0.0
	14	Best	0.0%	21.9	1.3%	0.0	27.9%	0.0	0.0%	0.0	1.0%	0.0	53.2%	3600.0	2.0%	0.0	28.9%	0.0	0.0%	0.0	0.0%	0.0
		Average	4.6%	3141.6	10.8%	0.0	45.5%	0.0	7.0%	0.0	8.1%	0.0	73.6%	3600.0	11.4%	0.0	45.2%	0.0	6.7%	0.0	5.8%	0.0
\hdashline      Subgroup Average			1.9%	1227.9	13.1%	0.0	33.2%	0.0	5.3%	0.0	5.4%	0.0	49.8%	3582.0	14.4%	0.0	35.2%	0.0	5.0%	0.0	4.9%	0.0
20	12	Best	1.5%	3600.0	10.0%	0.0	12.4%	0.0	1.5%	0.0	0.7%	0.0	-	3600.0	10.2%	0.0	13.7%	0.0	0.6%	0.0	0.6%	0.0
		Average	14.8%	3600.0	18.1%	0.0	26.1%	0.0	6.6%	0.0	7.1%	0.0	-	3600.0	17.9%	0.0	26.0%	0.0	6.4%	0.0	6.5%	0.0
	16	Best	14.5%	3600.0	16.4%	0.0	21.4%	0.0	1.6%	0.0	5.4%	0.0	-	3600.0	17.4%	0.0	22.7%	0.0	2.3%	0.0	4.2%	0.0
		Average	32.4%	3600.0	23.0%	0.0	32.6%	0.0	9.8%	0.0	10.5%	0.0	-	3600.0	23.3%	0.0	32.6%	0.0	8.2%	0.0	10.4%	0.0
	20	Best	24.5%	3600.0	14.3%	0.0	31.9%	0.0	2.5%	0.0	4.4%	0.0	-	3600.0	15.5%	0.0	31.2%	0.0	3.7%	0.0	1.3%	0.0
		Average	36.0%	3600.0	24.2%	0.0	38.5%	0.0	11.1%	0.0	10.9%	0.0	-	3600.0	24.8%	0.0	38.0%	0.0	11.4%	0.0	10.3%	0.0
	24	Best	19.9%	3600.0	2.4%	0.0	35.0%	0.0	0.0%	0.0	2.6%	0.0	-	3600.0	1.5%	0.0	35.6%	0.0	0.6%	0.0	5.2%	0.0
		Average	38.4%	3600.0	21.2%	0.0	44.4%	0.0	12.8%	0.0	14.0%	0.0	-	3600.0	21.7%	0.0	44.1%	0.0	12.2%	0.0	13.0%	0.0
	28	Best	19.4%	3600.0	1.6%	0.0	39.2%	0.0	1.1%	0.0	4.9%	0.0	-	3600.0	3.1%	0.0	41.0%	0.0	0.9%	0.0	0.9%	0.0
		Average	36.5%	3600.0	16.7%	0.0	49.3%	0.0	15.2%	0.0	15.0%	0.0	-	3600.0	17.4%	0.0	48.9%	0.0	14.4%	0.0	13.5%	0.0
\hdashline      Subgroup Average			31.6%	3600.0	20.6%	0.0	38.2%	0.0	11.1%	0.0	11.5%	0.0	$\ast$	3600.0	21.0%	0.0	37.9%	0.0	10.5%	0.0	10.7%	0.0
40	24	Best	40.2%	3600.0	15.7%	0.0	20.9%	0.0	3.9%	0.0	4.5%	0.0	-	3600.0	2.3%	0.0	50.0%	0.0	0.0%	0.0	1.8%	0.0
		Average	46.3%	3600.0	20.7%	0.0	26.2%	0.0	9.6%	0.0	9.0%	0.0	-	3600.0	8.6%	0.0	56.0%	0.0	6.2%	0.0	5.6%	0.0
	32	Best	52.6%	3600.0	21.3%	0.0	25.2%	0.0	9.0%	0.0	8.3%	0.0	-	3600.0	22.4%	0.0	27.4%	0.0	6.0%	0.0	6.0%	0.0
		Average	57.0%	3600.0	26.5%	0.0	31.8%	0.0	12.8%	0.0	12.5%	0.0	-	3600.0	28.5%	0.0	32.7%	0.0	11.8%	0.0	11.0%	0.0
	40	Best	57.3%	3600.0	26.1%	0.0	31.7%	0.0	9.1%	0.0	8.3%	0.0	-	3600.0	24.4%	0.0	32.6%	0.0	9.0%	0.0	10.4%	0.0
		Average	69.2%	3600.0	31.1%	0.0	36.1%	0.0	12.5%	0.0	12.3%	0.0	-	3600.0	32.4%	0.0	37.7%	0.0	13.3%	0.0	13.6%	0.0
	48	Best	-	3600.0	23.9%	0.0	41.6%	0.0	9.5%	0.0	11.6%	0.0	-	3600.0	23.0%	0.0	41.7%	0.0	10.8%	0.0	11.6%	0.0
		Average	-	3600.0	29.6%	0.0	45.2%	0.0	16.6%	0.0	16.8%	0.0	-	3600.0	29.1%	0.0	45.3%	0.0	16.6%	0.0	16.1%	0.0
	56	Best	-	3600.0	16.8%	0.0	44.4%	0.0	13.2%	0.0	15.5%	0.0	-	3600.0	18.4%	0.0	44.8%	0.0	13.8%	0.0	14.8%	0.0
		Average	-	3600.0	23.3%	0.0	48.3%	0.0	19.7%	0.0	19.3%	0.0	-	3600.0	23.3%	0.0	48.3%	0.0	18.7%	0.0	18.1%	0.0
\hdashline      Subgroup Average			$\ast$	3600.0	26.2%	0.0	37.5%	0.0	14.2%	0.0	14.0%	0.0	$\ast$	3600.0	24.4%	0.0	44.0%	0.0	13.3%	0.0	12.9%	0.0
60	36	Best	-	3600.0	16.9%	0.0	20.9%	0.0	5.5%	0.0	4.5%	0.0	-	3600.0	17.8%	0.0	21.4%	0.0	5.9%	0.0	3.4%	0.0
		Average	-	3600.0	22.8%	0.0	26.7%	0.0	8.6%	0.0	8.4%	0.0	-	3600.0	22.7%	0.0	26.6%	0.0	8.4%	0.0	7.6%	0.0
	48	Best	-	3600.0	26.0%	0.0	30.4%	0.0	9.6%	0.0	10.7%	0.0	-	3600.0	26.5%	0.0	30.6%	0.0	9.4%	0.0	8.5%	0.0
		Average	-	3600.0	29.9%	0.0	33.0%	0.0	12.0%	0.0	12.8%	0.0	-	3600.0	29.6%	0.0	32.9%	0.0	11.2%	0.0	12.0%	0.0
	60	Best	-	3600.0	26.6%	0.0	35.3%	0.0	14.2%	0.0	13.9%	0.0	-	3600.0	28.0%	0.0	36.1%	0.0	13.3%	0.0	12.9%	0.0
		Average	-	3600.0	33.5%	0.0	40.6%	0.0	18.2%	0.0	18.3%	0.0	-	3600.0	33.6%	0.0	40.7%	0.0	16.9%	0.0	17.0%	0.0
	72	Best	-	3600.0	25.7%	0.0	42.6%	0.0	15.5%	0.0	14.8%	0.0	-	3600.0	26.0%	0.0	42.8%	0.0	13.5%	0.0	13.5%	0.0
		Average	-	3600.0	30.6%	0.0	46.2%	0.0	19.1%	0.0	18.9%	0.0	-	3600.0	30.5%	0.0	46.0%	0.0	18.2%	0.0	17.6%	0.0
	84	Best	-	3600.0	20.3%	0.0	44.0%	0.0	19.3%	0.0	18.4%	0.0	-	3600.0	20.2%	0.0	44.4%	0.0	17.8%	0.0	17.4%	0.0
		Average	-	3600.0	26.0%	0.0	50.4%	0.0	21.9%	0.0	21.4%	0.0	-	3600.0	25.9%	0.0	50.3%	0.0	21.4%	0.0	20.5%	0.0
\hdashline      Subgroup Average			$\ast$	3600.0	28.6%	0.0	39.4%	0.0	16.0%	0.0	16.0%	0.0	$\ast$	3600.0	28.5%	0.0	39.3%	0.0	15.2%	0.0	14.8%	0.0

Table 4. Table 4: Computational results for Lower Bounds.

	Group 1 - Processing time [1, 10]				Group 2 - Processing time [10, 100]
n	LR	$L{B}_1$	$L{B}_2$	$L{B}_{HgR}$	LR	$L{B}_1$	$L{B}_2$	$L{B}_{HgR}$
5	23.7	29.3	33.6	34.7	232.8	288.9	337.4	347.0
10	39.4	60.9	66.2	70.0	379.1	635.9	667.6	706.9
20	70.7	119.7	140.2	143.4	705.7	1203.0	1412.7	1442.4
40	132.9	225.5	293.5	294.9	-	2253.2	2871.8	2883.2
60	193.9	338.0	444.3	444.3	-	3373.5	4452.3	4452.3

Table 5. Table 5: Computational results for large instances. The best, the average and the worst percentage Loss values are presented for each instance configuration.

$m_i$	$n_1$	$n_2$				Loss(%)
				JRH	JLPTH	CDH	H1	H2
2	20	[16,24]	Best	16.92	16.76	17.69	9.02	9.76
			Average	32.34	30.91	35.37	20.93	22.20
			Worst	53.77	51.24	64.08	36.36	35.08
			Std Dev	6.73	6.49	8.67	4.84	4.74
	30	[24,36]	Best	17.83	17.14	21.31	11.62	12.46
			Average	33.94	32.98	37.59	24.25	25.88
			Worst	46.49	45.84	64.72	37.11	36.38
			Std Dev	5.39	5.18	6.96	4.35	4.13
	40	[32,48]	Best	22.80	22.29	24.60	15.54	17.96
			Average	35.29	34.52	38.67	26.75	28.36
			Worst	47.91	45.72	59.40	37.13	39.12
			Std Dev	4.34	4.25	6.41	3.80	3.62
	50	[40,60]	Best	25.58	25.18	23.65	19.44	19.36
			Average	35.77	35.03	38.94	28.01	29.62
			Worst	46.22	45.58	59.36	35.91	38.07
			Std Dev	3.96	3.91	6.28	3.32	3.29
	60	[48,72]	Best	25.93	26.12	26.65	18.83	21.02
			Average	36.25	35.67	38.93	29.20	31.01
			Worst	46.69	45.47	56.3	36.72	38.43
			Std Dev	3.62	3.62	5.33	3.24	3.12
	70	[56,84]	Best	29.25	28.84	28.02	22.52	23.22
			Average	36.52	36.01	39.81	30.35	31.51
			Worst	44.62	44.49	56.35	39.09	39.07
			Std Dev	3.24	3.20	5.30	3.02	2.88
	80	[64,96]	Best	28.84	28.07	28.01	22.46	25.42
			Average	36.52	36.12	39.58	30.99	32.18
			Worst	43.73	43.52	55.55	38.98	39.38
			Std Dev	2.97	2.94	5.13	2.89	2.73
Average 2 machines				35.23	34.46	38.41	27.21	28.68
4	20	[16,24]	Best	20.90	17.36	17.56	11.57	12.99
			Average	39.87	34.38	35.89	24.78	25.31
			Worst	61.61	52.48	59.75	35.31	35.00
			Std Dev	7.27	6.15	7.43	4.65	4.33
	30	[24,36]	Best	26.60	24.04	24.02	17.80	17.47
			Average	39.92	36.17	37.29	28.05	28.88
			Worst	51.71	46.49	59.00	36.70	39.66
			Std Dev	5.17	4.54	6.28	3.75	3.67
	40	[32,48]	Best	26.79	24.49	22.00	19.42	20.38
			Average	39.68	36.79	37.64	29.35	30.25
			Worst	50.72	46.13	54.92	38.28	39.28
			Std Dev	4.31	3.87	5.63	3.47	3.16
	50	[40,60]	Best	27.85	26.69	21.9	20.73	21.36
			Average	39.27	36.71	37.66	30.29	31.25
			Worst	49.65	47.95	57.31	39.26	38.59
			Std Dev	3.89	3.68	5.43	3.29	3.06
	60	[48,72]	Best	28.57	27.55	26.52	21.08	24.53
			Average	39.01	36.96	37.7	31.07	32.05
			Worst	49.20	45.64	51.43	39.82	38.62
			Std Dev	3.44	3.35	4.68	2.94	2.83
	70	[56,84]	Best	30.86	30.08	26.71	23.55	24.86
			Average	38.75	36.99	38.21	31.52	32.49
			Worst	47.80	44.42	52.69	38.48	38.67
			Std Dev	3.14	2.90	4.57	2.82	2.62
	80	[64,96]	Best	30.27	29.09	27.63	22.95	26.10
			Average	38.39	36.94	38.33	32.17	33.12
			Worst	44.81	43.51	50.97	38.69	39.38
			Std Dev	2.86	2.77	4.47	2.65	2.60
Average 4 machines				39.27	36.42	37.53	29.60	30.48
10	20	[16,24]	Best	12.54	11.59	5.69	0.00	4.10
			Average	35.38	24.56	28.23	13.50	16.49
			Worst	55.41	45.50	61.03	27.01	27.27
			Std Dev	7.52	5.74	8.44	4.79	4.24
	30	[24,36]	Best	26.91	18.44	18.53	12.24	13.86
			Average	43.46	32.08	34.65	24.14	24.71
			Worst	59.20	45.91	53.51	34.19	35.02
			Std Dev	6.31	5.16	6.64	4.60	4.46
	40	[32,48]	Best	28.06	22.54	27.20	15.96	18.67
			Average	49.17	38.74	40.87	31.79	32.10
			Worst	63.17	48.35	57.14	41.04	40.96
			Std Dev	6.04	4.87	6.21	4.33	4.21
	50	[40,60]	Best	36.50	28.39	27.36	26.04	25.41
			Average	50.62	42.04	42.83	35.96	35.81
			Worst	63.10	51.89	57.84	43.15	41.23
			Std Dev	4.79	3.77	5.27	3.28	3.20
	60	[48,72]	Best	38.27	32.56	30.42	27.74	27.91
			Average	49.40	41.85	41.97	36.70	36.44
			Worst	59.34	48.44	57.24	42.09	41.97
			Std Dev	4.04	3.11	4.79	2.71	2.67
	70	[56,84]	Best	37.66	32.57	29.75	28.49	29.02
			Average	47.62	41.21	41.24	36.53	36.24
			Worst	59.36	46.98	52.51	42.02	41.12
			Std Dev	3.55	2.63	4.57	2.50	2.34
	80	[64,96]	Best	37.61	33.20	30.17	28.94	28.30
			Average	45.92	40.44	40.82	36.34	36.12
			Worst	53.71	45.87	51.81	41.30	41.29
			Std Dev	3.11	2.50	4.38	2.46	2.32
Average 10 machines				45.94	37.28	38.66	30.71	31.13
$U(2,4)$	20	[16,24]	Best	4.57	4.25	9.02	3.85	2.32
			Average	31.33	27.94	36.48	18.62	19.36
			Worst	59.86	46.01	86.91	33.61	35.40
			Std Dev	9.89	8.82	14.55	6.75	6.69
	30	[24,36]	Best	9.57	6.79	10.14	4.82	5.28
			Average	32.07	29.70	38.14	21.86	22.68
			Worst	51.89	47.81	85.47	38.32	36.28
			Std Dev	8.26	7.63	13.76	6.60	6.40
	40	[32,48]	Best	10.90	9.54	10.61	3.00	6.57
			Average	32.33	30.58	38.18	23.72	24.67
			Worst	47.42	44.74	79.10	37.64	36.84
			Std Dev	7.81	7.34	13.05	6.52	6.57
	50	[40,60]	Best	13.26	12.21	12.64	8.33	10.21
			Average	32.65	31.27	38.69	25.04	26.04
			Worst	48.53	45.11	76.62	38.96	37.57
			Std Dev	7.70	7.34	12.63	6.53	6.75
	60	[48,72]	Best	11.15	11.04	11.83	8.34	9.44
			Average	32.74	31.51	38.74	25.72	26.84
			Worst	47.14	43.42	81.55	36.36	38.58
			Std Dev	6.97	6.75	12.09	6.17	6.28
	70	[56,84]	Best	16.49	14.56	16.39	9.94	11.67
			Average	32.36	31.40	39.3	26.16	27.32
			Worst	45.60	43.95	77.17	37.74	39.01
			Std Dev	6.81	6.58	11.96	6.01	6.19
	80	[64,96]	Best	15.01	14.13	15.48	11.03	13.05
			Average	32.53	31.67	39.57	26.95	27.71
			Worst	43.92	43.37	77.62	37.52	37.56
			Std Dev	6.57	6.41	12.05	5.94	6.02
Average $U(2,4)$ machines				32.29	30.58	38.44	24.01	24.94
$U(2,10)$	20	[16,24]	Best	3.40	3.40	2.11	0.15	0.46
			Average	27.78	21.25	35.94	13.15	13.77
			Worst	55.42	43.67	103.55	34.38	31.48
			Std Dev	11.45	9.18	22.69	7.57	7.24
	30	[24,36]	Best	4.35	1.97	4.09	1.18	1.18
			Average	31.67	26.05	40.02	19.44	19.43
			Worst	61.61	45.32	97.89	38.78	37.32
			Std Dev	12.13	10.24	21.41	8.95	8.75
	40	[32,48]	Best	7.67	4.04	4.50	2.14	2.72
			Average	33.90	29.08	40.85	23.07	22.96
			Worst	60.57	48.93	96.09	40.26	39.74
			Std Dev	13.05	10.85	19.21	9.63	9.58
	50	[40,60]	Best	8.09	6.88	4.61	3.58	3.77
			Average	33.64	29.66	41.28	24.30	24.33
			Worst	60.51	50.56	100.21	40.83	40.86
			Std Dev	12.11	10.53	18.97	9.46	9.41
	60	[48,72]	Best	8.81	6.33	6.36	4.54	4.45
			Average	20.78	29.63	41.03	24.64	24.87
			Worst	55.67	47.11	98.85	40.11	41.00
			Std Dev	11.55	10.18	18.76	9.38	9.39
	70	[56,84]	Best	7.49	6.18	6.63	4.98	5.18
			Average	32.01	29.25	40.85	24.92	25.08
			Worst	51.53	47.36	93.43	40.86	40.08
			Std Dev	11.07	9.87	18.56	9.28	9.28
	80	[64,96]	Best	8.26	7.51	5.94	5.05	6.07
			Average	31.49	29.10	41.10	25.16	25.32
			Worst	50.58	45.83	92.11	41.67	40.27
			Std Dev	10.57	9.63	18.53	9.01	9.10
Average $U(2,10)$ machines				31.93	27.72	40.15	22.10	22.25
Total average				36.93	33.29	38.64	26.73	27.50

Table 6. Table 6: Sampling of instances

Type	Instances
Y1	5-3-4-1
Y2	5-4-4-1
Y3	5-5-4-1
Y4	5-6-4-1
Y5	5-7-4-1
Y6	10-6-9-1
Y7	10-8-9-1
Y8	10-10-9-1
Y9	10-12-9-1
Y10	10-14-9-1
Y11	5-3-4-2
Y12	5-4-4-2
Y13	5-5-4-2
Y14	5-6-4-2
Y15	5-7-4-2
Y16	10-6-9-2
Y17	10-8-9-2
Y18	10-10-9-2
Y19	10-12-9-2
Y20	10-14-9-2

Table 7. Table 7: Parameter bounds for tuning the Volume Algorithm

Parameter	Lower bound	Upper bound	Type
$\pi$	0.0005	0.0100	FLOAT
MaxWaste	5	30	INT
factor	0.1	1.0	FLOAT
${\alpha }_{max}$	0.20	0.95	FLOAT
st	0.6	1.8	FLOAT
$\alpha$	0.05	0.90	FLOAT
yellow	0.20	0.95	FLOAT
green	1.0	2.0	FLOAT

Table 8. Table 8: Four best parameters settings for the volume algorithm

Iteration	Parameter								Solution value of the instances
	$\pi$	MaxWaste	factor	${\alpha }_{max}$	st	$\alpha$	yellow	green	Y1	Y2	Y3	Y4	Y5	Y6	Y7	Y8	Y9	Y10	Y11	Y12	Y13	Y14	Y15	Y16	Y17	Y18	Y19	Y20
501	0.00708	28	0.22871	0.33265	1.01875	0.21709	0.80291	1.13994	24	14	30	20	30	36	46	56	60	66	155	137	191	328	414	337	537	558	629	793
502	0.00527	9	0.34752	0.75030	1.71397	0.73405	0.58396	1.56980	24	15	29	21	30	37	46	56	60	66	157	154	191	341	414	337	563	558	629	793
503	0.00688	20	0.62855	0.83046	1.17734	0.28130	0.60572	1.40758	25	15	30	21	30	37	46	56	60	66	118	136	191	307	414	337	531	558	629	793
504	0.00679	24	0.87753	0.30337	1.41179	0.08300	0.48159	1.56487	26	15	30	20	30	32	46	56	60	66	95	136	191	307	414	337	531	558	629	793

Equations

$$(F)Minimize{C}_{max}$$

$$\sum _{t=0}^{T_f-p_{1j}}{x}_{jt}=1,$$

$$\sum _{t=T_0}^{T_f-p_{2j}}{y}_{jt}=1,$$

$$\sum _{j\in J^1}\sum _{s=max(0;t-p_{1j}+1)}^t{x}_{js}\le 1,$$

$$\sum _{j\in J^2}\sum _{s=max(T_0;t-p_{2j}+1)}^t{y}_{js}\le 1,$$

$$\sum _{t=T_0}^{T_f-p_{2j}}t{y}_{jt}-\sum _{t=0}^{T_f-p_{1k}}(t+p_{1k})x_{kt}\ge 0,$$

$$C_{max}\ge p_{2j}+\sum _{t=T_0}^{T_f-p_{2j}}t{y}_{jt},$$

$$x_{jt}\in \{0,1\},$$

$$y_{jt}\in \{0,1\},$$

$$C_{max}\ge 0.$$

$$L(\lambda )=Minimize{C}_{max}+\sum _{j\in J^2}\sum _{k\in S_j}{\lambda }_{jk}(\sum _{t=0}^{T_f-p_{1k}}(t+p_{1k})x_{kt}-\sum _{t=T_0}^{T_f-p_{2j}}t{y}_{jt})$$

$$L(\lambda {)}_x=Minimize\sum _{j\in J^2}\sum _{k\in S_j}{\lambda }_{jk}\sum _{t=0}^{T_f-p_{1k}}(t+p_{1k})x_{kt}$$

$$L(\lambda {)}_x=Minimize\sum _{j\in J^1}\sum _{t=0}^{T_f-p_{1j}}(t+p_{1j})x_{jt}{w}_j^1$$

$$L(\lambda {)}_y=Minimize{C}_{max}-\sum _{j\in J^2}\sum _{k\in S_j}{\lambda }_{jk}\sum _{t=T_0}^{T_f-p_{2j}}t{y}_{jt}$$

$$\sum _{t=T_0}^{T_f-p_{2j}}{y}_{jt}=1,$$

$$\sum _{j\in J^2}\sum _{s=max(T_0;t-p_{2j}+1)}^t{y}_{js}\le 1,$$

$$C_{max}\ge p_{2j}+\sum _{t=T_0}^{T_f-p_{2j}}t{y}_{jt},$$

$$y_{jt}\in 0,1,$$

$${\lambda }_{jk}\ge 0,$$

$$C_{max}\ge 0.$$

$$L(\lambda {)}_y=Minimize{C}_{max}+\sum _{j\in J^2}\sum _{t=T_0}^{T_f-p_{2j}}t.y_{jt}{w}_j^2$$

$$L{B}_1=\sum _{i\in J^2}{p}_{2i}+mi{n}_{j\in J^2}\{\sum _{i\in J^1,i\in S_j}{p}_{1i}\}.$$

$$L{B}_2=\sum _{i\in J^1}{p}_{1i}+mi{n}_{j\in J^1}\{\sum _{i\in J^2,i\in P_j}{p}_{2i}\}.$$

$${\alpha }_{opt}=argmin\parallel \alpha {\nu }_{({\lambda }_{jk-1},x^k,y^k)}^{\prime k}+(1-\alpha ){\nu }_{({\lambda }_{jk-1},\bar{x},\bar{y})}^k{\parallel }^2$$

$$\alpha ={\alpha }_{max}\ast \alpha if{\alpha }_{opt}<0$$

$$\alpha =min\{{\alpha }_{opt},{\alpha }_{max}\}if{\alpha }_{opt}\ge 0$$

$$s=\frac{\pi \ast (st\ast UB-\bar{z}))}{\parallel {\nu }_{({\lambda }_{jk-1},\bar{x},\bar{y})}{\parallel }^2}$$

$$Minimize{C}_{max}$$

$$\sum _{t=0}^{T-p_j}{x}_{jt}=1,$$

$$\sum _{j\in J_1}\sum _{s=max(0;t-p_j+1)}^t{x}_{js}\le m_1,$$

$$\sum _{j\in J_2}\sum _{s=max(0;t-p_j+1)}^t{x}_{js}\le m_2,$$

$$\sum _{t=0}^{T-p_j}t{x}_{jt}\ge \sum _{t=0}^T(t+p_i)x_{it},$$

$$C_{max}\ge p_j+\sum _{t=0}^{T-p_j}t{x}_{jt},$$

$$x_{jt}\in \{0,1\},$$

$$C_{max}\ge 0.$$

$$L_{MD}(\lambda )=Minimize{C}_{max}-\sum _{j\in J_2}\sum _{i\in S_j}{\lambda }_{ij}(\sum _{t=0}^{T-p_j}t{x}_{jt}-\sum _{t=0}^T(t+p_i)x_{it}))$$

$$L_{MD}^{\prime }(\lambda )=Min\sum _{j\in J_2}\sum _{i\in S_j}{\lambda }_{ij}\sum _{t=0}^T(t+p_i)x_{it}$$

$$\sum _{t=0}^{T-p_j}{x}_{jt}=1,$$

$$\sum _{j\in J_1}\sum _{s=max(0;t-p_j+1)}^t{x}_{js}\le m_1,$$

$$x_{jt}\in \{0,1\},$$

Full text

1 Introduction

The current market environment, characterized by increasingly fierce competition, the globalization of the economy and an accelerated technological revolution has led companies to improve their production, logistics and distribution systems. Customers are demanding better and faster services, direct-to-customers strategies and many other new requirements, that expects more efficient and integrated logistic operations. Cross-docking is one logistic technique that can reduce inventory costs while increasing the goods flow, improving the efficiency of the supply chain.

A Cross-docking Distribution Center (CDC) is a logistics technique widespread throughout the world. Several well-known companies such as retail chains (WalMart [50]), mailing companies (UPS [27]), automobile manufacturers (Toyota [55]) and logistics providers ([29], [30]) have gained considerable competitive advantages by using CDC.

The main idea behind cross-docking centers is to receive products from different suppliers or manufacturers and consolidate them to common final delivery destinations. In comparison to traditional warehouses, a CDC is managed with minimal handling and with little or no storage between unloading and loading of goods. This practice can serve different goals: the consolidation of shipments, a shorter delivery lead time, the reduction of costs, etc. Readers are referred to [32], for a survey discussing industry practices and CDC problem characterization.

Cross-docks raise numerous optimization questions, either strategic, tactical or operational. In a Cross-docking Distribution Center (CDC), scheduling decisions are particularly relevant to ensure a rapid turnover and on-time deliveries. Due to its real-world importance, several truck-scheduling works and procedures have been introduced during recent years, treating specific cross-dock settings.

A schematic representation of processes at a CDC is illustrated in Figure 1. Firstly, incoming trucks arrive at the yard of the CDC, if the number of trucks is higher than the number of docks, some of them have to wait in a queue until further assignment. Secondly, after being docked, goods of the inbound trucks are unloaded, scanned, sorted, moved across the dock and loaded into outbound trucks for an immediate delivery elsewhere in the distribution chain. Once an outbound (inbound) truck is completely loaded (unloaded), the truck is removed from the dock, replaced by another truck and the course of action repeats.

In a conventional distribution center, five operations are usually carried out when managing products: receiving, sorting, storing, picking and shipping operations. All of which can be done consecutively or in a particular order. As a result of applying a cross-docking system, a reduction of the cost of both storage and products picking can be achieved by synchronizing the inbound and outbound trucks flows. There are many benefits with the cross-docking: costs reduction (warehousing, inventory-holding, handling, and labor costs), shorter delivery lead times (from supplier to customer, increase of throughput), improved customer service and customer satisfaction, reduction of storage space, faster inventory turnover, fewer overstocks, reduced risk of loss and damage, etc. However, efficient transshipment processes and careful operations planning become indispensable within a CDC, where inbound and outbound flows need to be synchronized to keep the terminal storage as low as possible, and on-time deliveries are ensured. Many articles in the literature develop computerized scheduling procedures, which have achieved good results (See examples in Table 1).

In this work, we consider a time-indexed integer programming formulation for a flow shop scheduling problem with cross-docking precedence constraints. We first consider the 2-dock case denoted as $F2|CD|C_{max}$, and strongly NP-hard (See [21]), and later we deal with the parallel dock generalization, $F2(P)$ $|CD|C_{max}$. Computational experiments show that the model is efficient when solving small problems.

A Hybrid Lagrangian Metaheuristic approach is also proposed and tested. The method can efficiently generate strong lower and upper bounds. Results are compared to the best heuristics in the literature introduced by Chen and Lee [21] (based on Johnson’s algorithm), with the CDH heuristic developed by Cota et al. [26] for a parallel machines scenario, and to the best heuristics proposed by Chen and Song [22] for the multiple parallel processors (multiple docks) case. Better solutions are consistently obtained for all instances tested. The article is organized as follows, an overview of related works is presented in Section 2. The mathematical model and the Hybrid Lagrangian Metaheuristic Framework are described in Section 3 and 4, respectively. Section 5 generalizes the algorithm for the parallel machine case. Computational experiments are reported in Section 6. Finally, discussions and conclusions are drawn in Section 7.

In this manuscript, we propose a Hybrid Lagrangian Metaheuristic Framework for the cross-docking flow shop scheduling problem. The work has a similar line of thought than Boschetti and Maniezzo [15]. However, it emphasizes the use of the information of the Lagrangian Multipliers as discussed in Pirkwieser et al. [47], and Paula et al. [45].

For the 2-dock case, although the subproblems of the Lagrangian relaxation are polynomial, through a series of cuts on the makespan value, we improve the linear lower bounds. The proposed algorithm uses the information obtained from the Lagrangian multipliers to construct feasible solutions through a NEH based heuristic ([42]), and performs search procedure through a Local Search framework. Furthermore, the proposed hybrid algorithm proves optimality in several instances.

We generalize our approach to the parallel-dock case. In this scenario, the subproblems are NP-hard, with a focus on improving the feasible solutions we solve the subproblem’s linear relaxations, to feed the Lagrangian Metaheuristic. Results show that the technique outperforms current heuristic methods.

2 Literature Review

The increasing use of cross-docking techniques has motivated several authors to investigate new ways to improve the design and tactical operations of CDCs. In the literature, several decision problems are studied concerning strategical, tactical, and operational decisions.

Boysen and Fliedner [17], and Belle et al. [13] focus on the review of the existing literature of cross-docking problems. According to [16], decision problems in a cross-docking center can be allocated according to the following classification, ordered from strategic to operational levels: location of cross-docking centers, layout, vehicle routing, dock’s assignments of destinations, truck scheduling and resource scheduling inside the center. Here we focus on truck scheduling problems, where the aim is deciding where and when should the trucks be processed.

Examples of strategic decisions in a CDC can be found in many works. Location of a cross-docking is analyzed in Campbell [20], Klose and Drexl [31], Chen et al. [24], and Chen [23]. The layout of cross-docking centers is studied in Gue [29], Bartholdi and Gue [10] and Vis and Roodbergen [35].

Some other works deal with the vehicle routing as Oh et al. [44] and Wen et al. [25]. Regarding operational decisions, some works consider the dock assignment problem: Belle et al. [13], Boysen and Fliedner [17], Tsui and Chang [52] [53], Bozer and Carlo [19] and Gue [29].

In a CDC, scheduling decisions are particularly important to ensure a rapid turnover and on-time deliveries. Due to its real-world importance, several truck-scheduling works and procedures have been introduced during recent years, treating specific cross-dock settings. For that reason, we highlight in Table 1, some outstanding works dealing with truck scheduling problems in a CDC. As proposed by [16], a classification scheme for deterministic truck scheduling problems is presented for each work, as well as, their contribution.

Chen and Lee [21] study a two-machine cross-docking flow shop scheduling problem, in which a job at the second machine can be processed only after finalizing some jobs at the first one, with the objective of minimizing the makespan. The authors show the problem is strongly NP-hard. They develop a polynomial approximation algorithm with an error-bound analysis and a branch-and-bound algorithm. Computational results show that the branch-and-bound algorithm can optimally solve problems with up to 60 jobs in a reasonable time.

Chen and Song [22] extended the Chen and Lee [21] problem to the two-stage hybrid cross-docking scheduling problem, by considering multiple parallel processors (multiple docks) per stage (inbound and outbound), allowing simultaneous loading and unloading operations. They propose a mixed integer programming model and four constructive heuristics, based on Johnson’s rule, to investigate the performance for moderate and large scale instances.

Another studies considering multiple dock environment are proposed by Alpan et al. [2], but with a different aim, a dynamic program based model is presented to find the schedule of transshipment operations minimizing the operations total cost, solving only small size instances. Larbi et al. [34] presented some heuristics to obtain near optimal solutions for large instances considering the same scenario than [2].

Cota et al. [26] deals with the operational decision problem of scheduling the trucks on multiple inbound and outbound docks, that is, they consider the same setting than Chen and Song [22]. They propose a time-indexed mixed integer linear programming formulation and a constructive polynomial heuristic. Results are compared to the best heuristics proposed in [22, 26] on medium and large instance, and better solutions were consistently obtained for instances with greater number of machines and jobs.

The hybrid metaheuristics arise as an option to achieve solutions within a reasonable computational time in very difficult combinatorial optimization problems. The hybrid method consists of a cooperative combination of methods, exact and/or approximated, and aims to absorb to the limit the potentialities of all the approaches (see surveys Alba [1], Puchinger and Raidl [48] and Blum et al. [14]).

Paula et al. [45] propose a variant of the Lagrangian Relaxation to obtain good bounds to the problem of parallel machines scheduling with sequence-dependent setup times. In this effort, the Lagrangian Relaxation is improved by the use of a metaheuristic as an internal procedure of the Lagrangian Relaxation. The heuristic is used to generate feasible solutions during the execution of the non-delayed relax-and-cut algorithm.

Pirkwieser et al. [47] present a similar work, using the Lagrangian Relaxation applied to the Knapsack Constrained Maximum Spanning Tree problem, in which the Lagrangian Multipliers influence the procedures executed by the Genetic Algorithm.

Boschetti and Maniezzo [15] propose a Lagrangian Metaheuristic procedure. Their approach consists in using metaheuristic techniques to obtain feasible solutions using the information of Lagrangian Multipliers. The solutions obtained tend to be good bounds. We remark that, in these efforts, the potential of the information of the Lagrangian Multipliers is still not completely used. Part of our goals is to improve the use of this information. Readers are referred to [14] for a survey on hybrid metaheuristics.

As discussed here, a significant number of CDC articles are dedicated to the study of strategical and tactical aspects. However, not always aligned with industry practice. More recently, Ladier and Alpan [3] discuss the relationship between the industry needs and academic research topics, pointing out the gap between both worlds. They highlight some gaps between theory and practice which would need to be filled in order to get closer to real-life constraints, for example: researchers should aim towards removing simplifying assumptions which are difficult to justify in an industrial context, or, it would be necessary to take deadlines into account for outbound truck departures.

In this work, we consider the problem of scheduling the trucks as described in Chen and Lee’s approach [21]. As Chen and Song [22] and Cota et al. [26] generalize their problem, we compare our results to the best algorithms in all these works considering a 2-dock version and a parallel-dock case.

3 Mathematical Model

In this section, we present a mathematical formulation for a 2-dock version based on scheduling problem initially proposed by Chen and Lee [21]. The integer programming model considered in this work adopts a time-indexed formulation proposed by Lima [39] but adopting the makespan as objective function, as proposed by Chen and Lee [21].

Considering a 2-dock cross-docking center where $n$ loaded trucks arrive with products demanded by one or more customers. In the center, each truck must unload its cargo and load it into one or more outbound trucks, responsible for delivery to specific destinations in the supply chain. Each departing vehicle may leave the center only after the cargo is fully loaded, and it can begin the loading process only after all needed products were available in the center. Here we consider the existence of two docks in the center, one dock dedicated to unload the trucks and the other one for loading purposes, machine 1 (M1) and machine 2 (M2), respectively. The problem corresponds to define the truck sequence in the inbound and outbound dock, minimizing the completion time of the last job processed by machine 2.

The following parameters, sets and variables are considered:

Input Parameters

$n$: number of jobs to be processed on M1.

• 2.

$m$: number of jobs to be processed on M2.

• 3.

$p_{ij}$: processing time of job $j$ on machine $i$.

• 4.

$T_{f}$: size of time horizon. A first estimate for the time horizon is the sum of the processing times of all jobs.

• 5.

$T_{0}\geq 0$: beginning of time horizon for the jobs ${j\in J^{2}}$, i.e., minimum starting date for processing of the output trucks, initially set as $T_{0}$ = $min_{j\in J^{2}}$ $\{\sum_{i\in J^{1},i\in S_{j}}p_{1i}\}$, then $T$ = {$T_{0},...,T_{f}$} $\forall j\in J^{2}$.

**Sets

**

The set of periods is defined as $T$ = {$0,...,T_{f}$}. To represent arrivals and truck departures in cross-docking center, two sets of jobs are created:

$J^{1}$ = {$j_{1}^{1},j_{2}^{1},...,j_{n}^{1}$} , set of $n$ jobs (inbound trucks), which must be processed on M1.

• 2.

$J^{2}$ = {$j_{1}^{2},j_{2}^{2},...,j_{m}^{2}$}, set of $m$ jobs (outbound trucks), which must be processed on M2.

• 3.

$S_{j}$, set of precedent jobs. For each job $j_{j}^{2}\in J^{2}$, there is a corresponding subset of $J^{1}$ that must be completed before beginning its process. It is considered that each element job ${j\in J^{2}}$ has at least one job $S_{j}$ as precedent.

Decision variables

$x_{jt}$ $(\forall j\in J^{1},\forall t\in T$), binary variable, $x_{jt}$ is equal to 1 if job $j$ starts its process at time $t$ and equal to [math] otherwise.

• 2.

$y_{jt}$ $(\forall j\in J^{2},\forall t\in T$), binary variable, $y_{jt}$ is equal to 1 if job $j$ starts its process at time $t$ and equal to [math] otherwise.

• 3.

$C_{max}$: makespan. Maximum completion time in M2.

The complete mathematical model (F) is presented as follows:

{fleqn}

[TABLE]

subject to

[TABLE]

The objective function (1) minimizes the makespan. The set of constraints (2) ensures that each job $j_{j}^{1}$ $\in$ $J^{1}$ should start its processing in one and only one period within the time horizon. The set (3) works with the same reasoning on M2. Constraints (4) ensure that a job $j_{j}^{1}$ $\in$ $J^{1}$ does not start its processing while another job is being processed in the same machine M1. The constraints set (5) works, in the same way, but applied to jobs $j_{j}^{2}$ $\in$ $J^{2}$. The set (6) controls the precedence relationships. For every existing precedence relation, the start date of the job $j_{j}^{2}$ $\in$ $J^{2}$ should be greater than or equal to the completion time of its precedent $j_{k}^{1}\in S_{j}$. The set of constraints (7) indicates that the variable $C_{max}$ should be the maximum completion time of jobs in $J^{2}$. Finally, sets (8) to (10) define the variable’s domain.

3.1 Lagrangian Relaxation

Let L($\lambda$) be the relaxation of formulation F, when constraints 6 are dualized and its violation penalized in the objective function. For each constraint is associated one Lagrangian multiplier $\lambda$ representing the weight given to the violation. The set of Lagrangian multipliers will be represented by $\lambda_{jk}$, with $j\in J^{2}$ and $k\in S_{j}$. Notice that, these constraints are the cross-docking precedence relations, coupling decisions in M1 with decisions in M2. Thus, the subproblem L($\lambda$) is defined as:

{fleqn}

[TABLE]

s.t. (2) – (5), (7) – (10), $\lambda_{jk}\geq 0$.

Now we are able to uncouple the problem into two new scheduling problems, one for each machine. Subproblem $X$ considers M1 while subproblem $Y$ considers M2. The value of the lower bound is obtained by adding the subproblems objective functions L$(\lambda)_{x}$ and L$(\lambda)_{y}$.

Subproblem $X$

Isolating the terms of the objective function that contain variables $x$, we reach to:

[TABLE]

s.t. (2), (4), (8) and $\lambda_{jk}\geq 0$.

Rewriting the above objective function from the perspective of jobs in $J^{1}$, we have:

[TABLE]

where $\quad w_{j}^{1}=\sum_{i\in J^{2}}\lambda_{ij}$, where $\lambda_{ij}=0$ if $\textit{j}\notin S_{i},\quad$.

The problem mentioned above is known as The Total Weighted Completion Time ([46]), denoted by $1||\sum C_{j}W_{j}$. This problem can be solved by the WSPT rule (Weighted Shortest Processing Time First) proposed by Smith in 1956 [49]. According to this rule, the optimal solution is obtained by ordering the jobs in descending order of $w_{j}^{1}$ / $p_{1j}$, and can be obtained in O($n\log$($n$)).

Subproblem $Y$

With the terms associated to variables $y$, subproblem $Y$ can be defined as:

[TABLE]

subject to

[TABLE]

Defining $w_{j}^{2}=-\sum_{k\in S_{j}}\lambda_{jk}$ \forall$$j $\in$ $J^{2}$, we can rewrite the problem as follows:

[TABLE]

s.t. (15), (16), (17), (18) e (20).

The first term of the objective function (21) is the makespan. The second term represents the sum of the weighted starting times of the jobs on M2, also known as The Total Weighted Starting Time, denoted $\sum I_{j}W_{j}$. Thus, the Y subproblem can be defined as $1||{C_{max}}+\sum I_{j}W_{j}$. To solve this subproblem, we proposed a rule named WSPT-TRD.

The WSPT-TRD rule works as follows. First, the WSPT rule is used to generate a sequence of jobs on M2. The second step is to define the correct allocation of jobs in the time horizon. For that, we evaluate the increase of the makespan when the weights associated with the jobs are negative. When the weights are negative, it creates a trade-off situation, as explained next.

When considering a general, weights $w_{j}^{2}$ may have positive or negative values. Let us first consider schedule decisions for jobs with $w_{j}^{2}\geq 0$, both $C_{max}$ and $\sum I_{j}W_{j}$ have similar behavior since the objective function is minimized by allocating the jobs at the beginning of the time horizon. In our particular case, as $\lambda_{jk}\geq 0$, we do not have the case of $w_{j}^{2}>0$; however, our algorithm here proposed considers this possibility.

Considering jobs with negative weights ($w_{j}^{2}<0$), the objective function terms lead to different solutions. On the one hand, by considering the makespan $C_{max}$ one tends to allocate the jobs at the beginning of time horizon, as the weights do not influence its final value. On the other hand, when analyzing the $\sum I_{j}W_{j}$ one tends to allocate the jobs as late as possible, taking advantage of the negative weights.

We notice that if we delay all jobs with negative weights one-time unit, the $C_{max}$ increases one unit. Thus, our algorithm computes the sum of the negative weights, if the sum of the negative weights is less than $-1$, the displacement of the jobs towards the end of the time horizon compensates the increase of $C_{max}$, defining in this way the best allocation of jobs.

Pseudocode of algorithm WSPT-TRD:

Step 1: Compute the weights $w_{j}^{2}$ on the machine 2 ($w_{j}^{2}=-\sum_{k\in S_{j}}\lambda_{jk}\hskip 2.84544pt\forall j\in J^{2}$).

Step 2: Sort the jobs in $J^{2}$ in decreasing order of $w_{j}^{2}$ / $p_{2j}$.

Step 3: Compute the sum of the negative weights as $\delta$ = $\sum_{j\in J^{2}}w_{j}^{2}\hskip 2.84544pt\forall j\in J^{2}\wedge w_{j}^{2}<0$.

Step 4: If $w_{j}^{2}=0$ $\forall j\in J^{2}$ or $\delta$ $\geq-1$, allocate the jobs from $t=T_{0}$ by sequence generated by WSPT rule.

Step 5: If there exists $w_{j}^{2}<0$ and $\delta$ $\leq-1$, allocate the jobs from t = $T_{f}$ by the reverse sequence generated by WSPT rule.

Theorem 1**.**

Considering the problem $1||{C_{max}}+\sum I_{j}W_{j}$, the algorithm WSPT-TRD obtains an optimal solution.

Proof 1**.**

The proof is provided in Appendix A.

3.2 Lower Bounds

Besides the lower bound obtained from the Lagrangian relaxation, we consider here two other lower bounds. The first one, called $LB_{1}$ is defined as proposed by Chen and Lee [21], as follows:

[TABLE]

$LB_{1}$ basically computes the sum of processing time on $M2$, plus the minimum amount of time necessary to begin the process of the first job in $M2$, that is, the minimum set of precedent jobs in $M1$.

The second lower bound, $LB_{2}$, proposed in this article, considers a complementary condition:

[TABLE]

Where, $P_{j}$ represents the successors subsets jobs $j\in J^{1}$ corresponding to job $i\in J^{2}$, i.e., successors are all jobs that must be processed after completion for a given job in the first stage.

In this case, $LB_{2}$ computes the sum of processing times in $M1$ plus the minimum set of common successors of $j\in J^{1}$. Finally, the Lower Bound is defined as the maximum lower bound, $LB=max\{LB_{1},LB_{2}\}$.

It is worth noticing that with a valid $LB$ we can redefine a new date for the beginning of the processing time of jobs in the $WSPT-TRD$ algorithm. Particularly, in Step 4, $T_{0}=LB-\sum_{i\in J^{2}}p_{2i}$, this is valid for the jobs with $w_{j}^{2}=0$ or for all jobs when $\delta$ $\geq-1$.

4 Hybrid Lagrangian Metaheuristic

In the Hybrid Lagrangian Metaheuristic Framework proposed in this work, the Lagrangian Dual is solved by the Volume algorithm, as proposed in [8] and [43]. Readers are referred to [9] and [28] for a discussion on the Volume algorithm and its performance. In our case, the Lagrangian Relaxation incorporates heuristics as internal procedures with a focus on obtaining feasible solutions. These heuristics are based on a constructive method and a Local Search. Both procedures are executed sequentially under the Lagrangian Relaxation.

The Volume algorithm is an extension of the subgradient algorithm, which produces a sequence of primal and dual solutions, thus being able to prove optimality. This algorithm has similar computational effort than the subgradient algorithm, and it presents similarities with the Conjugate Subgradient method [36], [56] and the Bundle method [37, 38]. A discussion of its main features and a global convergence analysis can be found in [7].

In the proposed algorithm the precedence constraints are dualized. The Lagrangian multipliers define a penalty to a given job allocated at a given position if the job has a large associated value, it means that it has a greater impact on the objective function, i.e., it is allocated in a disadvantageous position. This information can be used to decide when to schedule the jobs. Following, we describe two constructive heuristics used to obtain feasible solutions.

4.1 Constructive Heuristics

The heuristic H1 uses information from Lagrangian multipliers to sort jobs on M1, while H2 uses information from Lagrangian multipliers to sort jobs on M2. In the final step both heuristics use an NEH-like heuristic ([42]) to construct the feasible solution. For a given list of jobs, the NEH function construct a solution by scheduling the jobs on the list one by one, in the best position of the partial schedule. The two heuristics are described below:

H1

Step 1: For each job on the machine 1 ($k\in J^{1}$), compute $\beta_{k}=\dfrac{\sum_{j\in J^{2}}\lambda_{jk}}{Nprec_{k}}$.

Where $Nprec_{k}$ corresponds to the number of jobs in the second stage that are waiting for the completion of job $k$ on M1.

Step 2: Get the sequence on M1 by ordering jobs in decreasing order of $\beta_{k}$.

Step 3: Calculate the new release dates ($r_{j}$, $j\in J^{2}$) of jobs on M2.

Step 4: Get the sequence on M2 by ordering jobs in non-decreasing order of release dates $r_{j}$ and apply NEH.

H2

Step 1: For each job on M2 ($j\in J^{2}$), compute $\beta_{j}=\dfrac{\sum_{k\in S_{j}}\lambda_{jk}}{Nprec_{j}}$.

Where $Nprec_{j}$ corresponds to the number of precedents that job $j$ has.

Step 2: Get the sequence on M2 by ordering jobs in increasing order of $\beta_{j}$.

Step 3: Sequence the jobs on the M1 according the sequence on M2, respecting the precedence relations of cross-docking.

If there is a job on M1 without precedence relationship in the machine 2, schedule this job last.

Step 4: Calculate the new release dates ($r_{j}$, $j\in J^{2}$) of jobs on M2, from the sequence on M1.

Step 5: Get the sequence on M2 by ordering jobs in non-decreasing order of release dates $r_{j}$ and apply NEH.

4.2 The Lagrangian algorithm

Let $x$ and $y$ be solutions of subproblems X and Y, respectively, with objective function value $z$. Then $\lambda$ are the Lagrangian multipliers obtained by the Volume Algorithm, and $\nu$($\lambda$, $x$, $y$) is the subgradient. Let UB be the upper bound or feasible solution. The initial UB is generated by a Lagrangian metaheuristic. The algorithm is described below:

Step 0: We start with a null vector $\lambda_{jk}$ ($\lambda_{jk}$=0). Solve the Lagrangian subproblem to obtain the initial solution of X subproblem ($x^{0}$), Y subproblem ($y^{0}$) and objective function value ($z^{0}$). Let UB be the feasible solution obtained by Lagrangian metaheuristic. Set $\bar{x}=x^{0}$, $\bar{y}$=$y^{0}$, $\bar{z}=z^{0}$ and $k$=1.

Step 1: Compute the subgradient $\nu$($\lambda_{jk-1}$, $\bar{x}$, $\bar{y}$) and $\lambda_{jk}$=$\bar{\lambda_{jk}}$ + s$$\nu($\lambda_{jk-1})$, the calculation of the step size $s$ is given by the equation (27). Solve the Lagrangian subproblem with the new $\lambda_{jk}$ and let $x^{k}$, $y^{k}$ and $z^{k}$ be the solutions obtained. Then \bar{x}=\alpha$$x^{k} + (1-$\alpha$)$\bar{x}$, \bar{y}=\alpha$$y^{k} + (1-$\alpha$)$\bar{y}$ and $\bar{\lambda}$=\alpha$$\lambda^{k} + (1-$\alpha$)$\bar{\lambda}$, where $\alpha$ is a number between 0 and 1, defined by convex combination such as defined in (24).

Step 2: If $z^{k}$ $>$ $\bar{z}$ update $\bar{\lambda}$=$\lambda_{jk}$ and $\bar{z}$=$z^{k}$. If $\bar{z}$ improves by 10% since the last run of the Lagrangian metaheuristic then go to Step 3. Else go to Step 4.

Step 3: Lagrangian heuristics (H1, H2):

1. 1.

$UB^{k}$ $\leftarrow$ Constructive Heuristics (H1 and H2); 2. 2.

$UB^{k}$ $\leftarrow$ Local Search (list);

If $UB^{k}<UB$ update UB = $UB^{k}$ and add a cut in order to reduce the time horizon, improving the limits found (update $T_{f}$=UB).

Step 4: Stop criteria: If satisfied stop. Else let $k=k+1$ and go to Step 1.

The step size $s$ and the parameter $\alpha$ used to define $\bar{x}$ and $\bar{y}$, are computed as proposed in [8] and [28]. First, we define $\alpha_{opt}$ as:

[TABLE]

The parameter values $\pi$, MaxWaste, factor, $\alpha_{max}$, st, $\alpha$, yellow and green, some of them yet to be introduced, were defined using the SPOT method, as explained in Appendix B. The parameters $\alpha_{max}$ and $\alpha$ are initially defined as 0.3034 and 0.0830 respectively, based on computational tests performed by SPOT. And $\alpha$ is computed as:

[TABLE]

[TABLE]

Before setting the value of the step $s$, we need to define the parameter $\pi$. Therefore, to set the value of $\pi$ we define three types of algorithms iterations as defined in [8] and [9].

Each iteration with no improvement is named red. Then, the parameter MaxWaste represents the maximum number of iterations without a lower bound improvement. If $z^{k}$ $>$ $\bar{z}$ and $\nu^{\prime k}_{(\lambda_{jk-1},x^{k},y^{k})}\nu^{k}_{(\lambda_{jk-1},\bar{x},\bar{y})}<0$, it means that a longer step in the direction to $\nu^{k}$ would have given a smaller value for $z^{k}$. Those iterations are denominated yellow, otherwise, the iteration is denominated green. At each yellow iteration we would multiply $\pi$ by the yellow parameter. At each green iteration we would multiply $\pi$ by the green parameter. After a sequence of 24 consecutive red iterations, we would multiply $\pi$ by factor parameter. Thus, the step size $s$ at iteration $k$ is defined as:

[TABLE]

In the “Lagrangian heuristics step” two constructive heuristics and a Local Search are executed sequentially. The Local Search is implemented based on the proposals of [6] and [51]. The procedure adopted is composed by “swap” and “insertion” moves in the sequence on machine 2 generated by H1 and H2. The former consists of interchanging all pairs of jobs. The latter consists of removing a job from its original position and inserting it on one of the $n-1$ remaining positions. The local search procedure stops when it is unable to improve the solution further.

Finally, the stop criterion is determined if one of the following criteria is satisfied:

Maximum number of iterations, in this case 1000 iterations, or; 2. 2.

Relative tolerance GAP defined as: $\dfrac{z^{k}-\bar{z}}{\bar{z}}<0.1$, or; 3. 3.

Null Subgradient module or negligible: $\parallel\nu_{(\lambda_{jk-1},\bar{x},\bar{y})}\parallel^{2}\leq 0.000001$.

4.3 JB Heuristic

We compare the results of heuristics H1 and H2 with the best heuristic introduced by Chen and Lee [21], which is based on Johnson’s algorithm. The heuristic JB is proposed in two steps. Firstly, for an instance of $F2|CD|C_{max}$, the authors construct an instance of $F2||C_{max}$ with $n$ jobs. The first stage is maintained unchangeable and the second stage is converted into $n$ jobs. Secondly, Johnson’s algorithm is applied to obtain a sequence in the first stage, generating a lower bound. From the sequence in the first stage, jobs $j\in J_{2}$ at the second stage are sequenced as soon as possible in the time horizon, respecting the completion time of its predecessors. We run the above algorithm for the primary problem and its reverse problem and select the best solution. As a result, an Upper Bound for the problem is generated (See [21] for a more detailed explanation), so we calculated the relative GAP. With the objective of a fair comparison, the NEH algorithm and Local search are used to refine the results of JB in the same way than used in H1 and H2.

4.4 CDH Heuristic

The proposed H1 and H2 algorithms are also compared with the heuristic in Cota et al. [26], called CDH. The CDH heuristic starts by creating a preliminary schedule in the second machine. With this, a schedule is defined in the first machine and finally the second machine is rescheduled. The heuristic initially creates fictitious processing times $TF_{j}=(\sum_{i\in J^{1},i\in S_{j}}p_{1i})+p_{2j}$ for each job $j\in J^{2}$. Then, a preliminary schedule on M2 is obtained by ordering jobs in increasing order of fictitious processing times. Then the jobs on the M1 are sequence according the preliminary schedule on M2, respecting the precedence relations of cross-docking. The sequence on M1 imposes release dates to the jobs in the second machine due to precedence relationships. So, the ERD rule (earliest release date first) is applied to reschedule jobs in the second machine, obtaining a sequence on the M2. Let UB be the upper bound obtained with the heuristic and LB be the lower bound calculated as proposed in [22], we generate the percentage GAP for all tested instances.

5 Generalization for parallel-docks CDC

In this section, we present a time-indexed mixed integer formulation for $F2(P)|CD|C_{max}$ based on the proposal of Cota et al. [26]. The cross-docking problem is modeled as a hybrid two-stage flow shop scheduling problem with identical machines and cross-docking constraints, with the objective of minimizing the makespan. The problem is denoted as $F2(P)|CD|C_{max}$, since $F2|CD|C_{max}$ is strongly NP-hard, as showed by Chen and Lee [21], it is not difficult to see that $F2(P)|CD|C_{max}$ is also strongly NP-hard.

5.1 Time-indexed mixed integer linear programming model for $F2(P)|CD|C_{max}$

For the parallel-docks formulation, we use the following notation:

Input Parameters

$m_{1}$: number of parallel processors in stage 1.

• 2.

$m_{2}$: number of parallel processors in stage 2.

• 3.

$n_{1}$: number of jobs in stage 1.

• 4.

$n_{2}$: number of jobs in stage 2.

• 5.

$p_{j}$: processing time of job $j$.

• 6.

$T$: Time horizon considered initially. In practice, we used $T=\sum_{{j}\in J_{1}}p_{j}+\sum_{{j}\in J_{2}}p_{j}$.

Sets

$T$ = {$0,...,T$}, set of discrete periods considered.

• 2.

$J_{1}$ = {$1,2,...,n_{1}$}, set of jobs in stage 1.

• 3.

$J_{2}$ = {$1,2,...,n_{2}$}, set of jobs in stage 2.

• 4.

$S_{j}$: a set of precedent subset jobs of $J_{1}$ corresponding to job $j\in J_{2}$, $S_{j}\subset S=\{S_{1},...,S_{{n_{2}}}\}$.

Decision variables

$C_{max}$: makespan.

• 2.

$x_{jt}=1$, if job $j$ starts to be processed at time $t$, 0, otherwise.

The multiple dock formulation is defined as:

{fleqn}

[TABLE]

subject to

[TABLE]

The objective function remains as the minimization of the makespan. Constraints (29) and (30) ensure that in every stage, each job should start its processing on one, and only one, time slot within the time horizon $T$. Constraints set (31) and (32) indicates that the number of jobs that can be process simultaneously is less than or equal to the number of existing parallel processors in the stage considered. The constraint set (33) represents the cross-docking constraints, in which the release date of each job $j\in J^{2}$, must be greater than or equal to the completion date of each task belonging to its precedence set. Besides that, the constraint set ensures that each job $j\in J^{2}$, starts processing only after its release date. Constraints (34) compute the makespan, analyzing the maximum completion time. Constraints (35) and (36) specify the domains of each decision variable.

5.2 Lagrangian Relaxation for $F2(P)|CD|C_{max}$

Let $L_{MD}(\lambda$) be the relaxation of multiple dock formulation, when the cross-docking constraints (33) are dualized and its violation penalized in the objective function. We define the subproblem $L_{MD}$($\lambda$) as:

{fleqn}

[TABLE]

s.t. (29) – (32), (34) – (36), $\lambda_{ij}\geq 0$.

Just as we did for the 2-dock case, we are able to uncouple the problem into two new scheduling problems, one for each stage.

Subproblem 1

[TABLE]

subject to

[TABLE]

Subproblem 2

[TABLE]

subject to

[TABLE]

5.3 Constructive Heuristic for parallel-dock CDC

The first subproblem can be defined as $Pm||\sum C_{j}W_{j}$, while the second as $Pm||C_{max}-\sum I_{j}W_{j}$, therefore, it is not difficult to see that both subproblem are strongly NP-hard (see [46]). In this case, we focus on improving the problem’s upper bounds, thus, in each iteration, we solve the linear relaxations of the subproblems, obtain integer solutions and then compute their Lagrangian multipliers. The logic of the procedure is described in Algorithm 1, maintaining the same reasoning proposed in Section 4.

For comparison purposes, we limited the computational time in 60 seconds, and we compute the LB precisely as proposed by Chen and Song [22].

6 Computational Experiments

6.1 Results for the 2-dock problem

To investigate the performance of the Complete Model and Hybrid Lagrangian Metaheuristic Framework, artificial instances are generated varying the processing time of jobs and the number of jobs on machines 1 and 2, according to Chen and Lee [21]. We ran the tests on a single thread in the Intel Xeon-Silver 4110 (2.1GHz/8-core/85W) with 64 GB memory and Linux operational system. The programming language used is C++ with the optimization software CPLEX 12.4.

6.1.1 Instances Generation

The instances used in this work are generated through the software MATLAB, following the description found in Chen and Lee [21]. Table 2 presents a summary of the generated instances and its characteristics. It is divided into two groups, each row informs the features of a sub-group of instances. $n$ and $m$ indicate the number of jobs in each stage. $(NP)$ the discrete uniform distribution to select the number predecessors of jobs $j\in J^{2}$ and $(TP)$ the distribution to generate all processing times.

In each group of instances, $n$ is fixed and the number $m$ is randomly chosen from the range of $[0.6n,0.8n,1.0n,1.2n,1.4n]$. For each $n$, five instances with different $m$ values are considered. And for each pair ($n$, $m$), we generate 10 different problems, therefore the benchmark consists of 500 instances, 50 instances per row of Table 2 111all instances and codes are available at https://github.com/GabrielaBragaFonseca/Cross-docking-Problems.

6.1.2 Computational Results

In Table 6.1.2 we report computational results for the Complete Model (MIP) and heuristics JB, CDH, H1, and H2. Columns $n$ and $m$ show respectively the number of jobs in the first and second machine. For each instance size ($n$, $m$) we report the best result and the average of 10 cases tested. We also presented the subgroup’s average results.

The GAP(%) is computed as $\dfrac{(\mbox{Upper Bound - Lower Bound)}}{\mbox{Upper Bound}}$ and the column T(s) refers to CPU time expended to solve the problem in seconds. The run time is limited to one hour of CPU time (3.600 seconds), and results are depicted in Table 6.1.2 are registered. The dash (-) means that the corresponding value is not found. Finally, after comparing and analyzing the MIP, JB, CDH, H1 and H2 the best results obtained are highlighted in the Table.

The GAP is calculated considering the best lower bound found when comparing the lower bounds of Complete Model and Hybrid Lagrangian Metaheuristic Framework. It is worth highlighting that the constructive heuristic JB is proposed by Chen and Lee [21] and CDH heuristic is proposed by Cota et al. [26].

The MIP results show that the proposed model is efficient to solve to optimality only small instances. Furthermore, for the larger instances the model found no solution. These results expose the difficulty of solving time-indexed models. In the time-indexed problems, the number of variables is proportional to the time horizon, and the higher the number of jobs the greater the horizon of time to sequence them, increasing the computational effort to solve these problems. This fact justifies the proposal of the hybrid constructive heuristics to solve instances with a greater number of jobs.

Results show that H1 and H2 performs better than heuristics JB and CDH. Based on the Table 6.1.2, the heuristic H2 showed GAP results more efficients. Comparing the average GAPs we can observe that the heuristic H2 has its better performance when $n<m$ for small and large instances. When $n>m$, the heuristic H2 gets better for small cases, while H1 presents better results for large instances. The same behavior is noticed when $n=m$, H2 is best for small cases, and H1 for larger ones. The heuristic JB had no best GAP in any instance. As for the CDH heuristic, the GAPs found were high, which was already expected, since the heuristic was developed for a more general machine’s scenario.