Heuristic Approaches With Reinforced Parameter Tuning for the Car Sequencing Problems With Block Batches


 Motivated by the practical supply chain management of the automobile industry, we study the car sequencing problem (CSP) that minimize the conflicts arising from scheduling cars into an assembly line. The CSP is a well established problem, subject to the paint batching constraints to reduce the the costs for color changes and capacity constraints in the assembly shop to level the usage of the options. However, the existing approaches to this problem do not take into account the block batches, which desires a consecutive production batch of cars requiring a certain option. This requirement often occurs when specialized labor time window is short in the customized car production scenario, and renders additional complexities to the traditional car sequencing problem. In this paper, we propose a novel model to deals with these constraints and simultaneously generate the sequencing and replenishment decisions. In addition to our model formulation, we develop two math-heuristic approaches to solve the propose large-scale car sequencing problem. The selected heuristics are based on relax-and-fix procedures, fix-and-optimize procedures and variable neighborhood search. To solve the large-sized instances (commercial solvers, i.e., Cplex, cannot provide a feasible solution within 1 hour), we design and implement a reinforced parameter tuning mechanism to dynamically select the parameter values, so as to speed up the search process. The proposed models and heuristics are tested on compatible instances from the benchmark in the literature (CSPLib), as well as large-sized instances generated from real-world cases. We report on extensive computational experiments, and provide basic managerial insights into the planning process.


Introduction
The traditional car sequencing problem firstly proposed by Parrello et al. (1986) tackles the problem that occur when scheduling cars with various car options in a single assembly line and is addressed through converting position, time and/or technical requirements into discrete 0 − 1 options (Moya et al. , 2019;Solnon et al. , 2008). The assembly line normally consists of series production shops, including weld shop, paint shop and assembly shop. As one of the primary sources of air emissions of regulated chemicals, the paint process generates volatile organic compounds (VOCs), hazardous air pollutants (HAPs) and others. As pointed by Geffen & Rothenberg (2000), the production process generates both solid and hazardous and solid waste, including chemicals (i.e., chlorine bleach) to clean the paint lines and application equipments (sprayers), disposal parts and waste paint due to overspray. Hence, from an environmental and energy saving perspective, the paint batching constraints is considered to reduce the color changes in the paint shop (Bysko et al. , 2020). A contradicting constraints arising in the assembly shop, however, tend to leveling the manufacture of different cars, so as to maintain a proper production speed and usage of car options (Manoj et al. , 2008).
Particularly in the auto industry changing from mass standardization production to mass customization production, each car is composed of a different set of accessories/options, i.e., engines, tires, roofs, etc. With the advent of Internet of Things and cybernetic technologies, the fixture becomes more and more complex to assemble a specific set of options to the car bodies.As mentioned by Ullrich (2013), such problems often occur in the make-to-order and/or just-in-time environment. The setup time of changing from one complex fixture to another one is time consuming and might disorganize the production rhythm. Hence, to reduce the number of setup and the corresponding total setup times, company tends to consecutively process cars with the same option, especially for options that only a few fixture can handle. Motivated by this practical situation, we introduce block constraints, that define a subsequence with a fixed length for a specific option. If this is a changeover from other options to this option, then the following ones must be the same options as well, until the next changeover to another option.
One drawback of block production is the violation of level production requirement, which entails a smooth usage of the parts (options) in the assembly process. In the assembly shop, parts are normally delivered to the assembly line at a pre-specified frequency and speed. Most of the existing literature tackle this issue by maintaining a constant usage rate of the parts at each position of the sequence and penalize the weighted violations. However, this method neglects the process time of different options, i.e., the installation of an engine takes around half an hour, whilst the installation of a sunroof only requires a few minutes. In this paper, we create a time-related evaluation approach to incorporate the processing time of each option. We argue that the new method would more accurate to describe the practical situation than the traditional one, and hence be used to streamline the entire manufacturing process.
The contributions of this paper are threefold: firstly, we extend the classical car sequencing problem to incorporate several novel modeling challenges arising in the context of the car industry, which have not yet been considered in car sequencing problem. A mathmatical formulation is presented for the proposed scheduling problem; secondly, we develop two math-based heuristics with data-driven VNS to tackle the problem; finally, we present extensive computational tests in the car industry and highlight several managerial suggestions.
The structure of this paper is planned as follows. Section 2 briefly describes the design of the study and methodologies used in this paper. Section 3 present the literature reviews about relevant academic work on car sequencing including the solution approaches. Section 4 describes the sustainable supply chain scheduling problem and derives the formulation. Two math-heuristic algorithms that includes datadriven variable neighborhood search (VNS) are presented in Section 5 to efficiently solve the proposed problem. Our computational experiments are reported in Section 6, where we illustrate the efficiency of the proposed solution approach. Section 6.4 describes the system implementation and its benefits to the company. The conclusion and future research directions are pointed out in Section 7.

Methods
The above mentioned practical matters need additional modeling and computation efforts. We extend the classical car sequencing problem by introducing extra block variables and processing time computations. Because of the NP-hardness of the proposed problem, we design and implement two math-heuristic approaches to effectively and efficiently tackle the problem. The first one is a constructive heuristic that is capable of fast generating a solution with acceptable quality based on a relax-and-fix approach; the second one is an improvement heuristic that can significantly improve the solution process. The overall technical accomplishment is embed into a decision support system and deployed in a car manufacturer producing business cars. The experimental tests show that our solution approaches are efficient in solving large sized instances and is capable of improving the company's current manufacture efficiency.
A mixed-integer linear programming (MILP) is applied to depict and analyze the proposed CSP with block batches. Extra 0 − 1 decision variables are proposed to denote the starting position of each block batch. The math-heuristic algorithms are developed to solving the proposed model efficiently. For large-sized MILP formulation, we design and implement a relax-and-fix math-heuristics and a fix-andoptimize math-heuristic to address the issue of large computational expenses. To evaluate the performance of the proposed algorithms, we generate representative instances as the test bed. A comparative analysis is conducted to the acquired results to investigate the potentials of our proposed methodologies.

Solutions approaches for CSP
Among the first attempts to study the car sequencing problem (CSP), Parrello et al. (1986) describes it as generating a full sequence of cars on a single assembly line, so as to install car options (e.g., leather seats, engines, tires) on them. Several specific options are required by each of the cars assembled through the line. To avoid the potential conflicts arising from many consecutive cars requiring the same option, a maximum load ratio is adopted for some options (Warwick & Tsang, 1995). This requirement may describe the so-called by p/q ratio constraints: any successional q cars could consist of p cars maximum demanding a specific type of options. The objective of the car sequencing problem is to identify a complete sequence of cars that does not violate the maximum load ratio constraints for every subsequence or a full sequence with minimum constraints violation costs. The CSP has been proven to be NP-hard by Kis (2004). A number of approaches have been developed for the CSP problem. The evaluations of these algorithms are normally based on CSPLib (Gent & Walsh, 1999), a benchmark library for the car sequencing problem. The above mentioned approaches include the ones that searching for exact solutions and those searching for approximately optimal solutions. Dincbas et al. (1988) solved the CSP with a constraint programming language, with the result is either a car sequence that assures the satisfaction all the option constraints, or a failure implying that no such sequence exists. A constraint programming approach for CSP was proposed by Bergen et al. (2001). They consider two types of constraints: hard constraints that must be satisfied, and soft constraint that can be violated at a cost. Later, Siala et al. (2015) suggested several heuristics impelling a pruning rule, to speed up the solution approach. Andreas  proposed an integer programming model for CSP, based on a binary variable indicating the car-position assignment. Gravel et al. (2005) developed an MILP formulation for CSP with soft capacity constraints, by using additional binary variable deciding if a car-position assignment satisfies the capacity constraints. A first dedicated branch and bound algorithm to solve CSP was proposed by . Other exact approaches, i.e., beam search algorithms, were proposed by Bautista et al. (2008a) and Golle et al. (2015).
Apart from the complete approaches, non-exact methods such as metaheuristics, have been proposed aiming at fast search for near optimal solutions. Hindi & Ploszajski (1994) proposed the first greedy approach for the car sequencing problem. Later, Gottlieb et al. (2003) evaluated six greedy heuristic approaches for the CSP. Puchta & Gottlieb (2002) suggested a local search approaches to address the car sequencing problem, and suggested an inversion operator (i.e., insert a car from any position in the sequence to another position) to increase the search efficiency. Another specially relevant operator is the swap operator (i.e., change the positions of any two cars) (Golle, 2011). The capabilities and potentials of large neighborhood search technique for solving CSP was firstly investigated by Perron et al. (2004). Among the first attempts of applying ant colony optimization algorithms to CSP, Solnon et al. (2008) proposed a dynamic sum of utilization rate and argue that ant colony algorithm is slightly superior to local search for small computation time, whereas both algorithms provide comparable solution quality for large computation time. Gravel et al. (2005) also developed an ant colony optimization (ACO) approach for CSP, which associates with a local search technique which is used to speed up the search process constructed by ants.

Extensions to CSP model
One of the extensions to the car sequencing problem that obtains a lot of interests by the researchers is the ROADEF'2005 challenge suggested by RENAULT (Solnon et al. , 2008). Apart from capacity constraints arising in the assembly shop in the traditional CSP, the challenge introduces paint batching constraints in the paint shop and two classes of capacity constraints with different priorities in assembly shop. This extension is specially relevant to our study, as it introduces the same type of constraints that is used to incorporate usage restrictions of hazardous materials. Several contributions focusing on the (meta-)heuristics approaches of this version of CSP, such as tabu search (Cordeau et al. , 2008;Zufferey et al. , 2006), local search (Estellon et al. , 2008;Gavranović, 2008), and variable neighborhood search (Prandtstetter & Raidl, 2008). The comparison of four heuristics is given in Joly & Frein (2008).
Another variation of the classical CSP is so called extended CSP, proposed by (Bautista et al. , 2008b;Ribeiro et al. , 2008). They introduced a minimum number of operations requirement into the production sequences. Hence, the extended CSP aims at the finding out the trade-off between the capacity overload and under-load. A GRASP approach is proposed by Bautista et al. (2008b) to solve this problem extension.
In this article, we extend the classical CSP by including block production constraints. The block production requirement has been discussed in several literature streams, i.e., supply chain scheduling (SCS) (Hall & Potts, 2003), production-routing (Wang et al. , 2015) and production scheduling-vehicle routing problem (PS-VRP) (Moons et al. , 2017). Based on our knowledge, this is the first attempt to model this constraint into the car sequencing problems. The formulation and solution approaches are presented in the rest of this paper.

Problem statement and formulation
The problem involves a production stage with a single production line environment, which processes the cars consecutively. At the production stage, the cars are sequentially processed through welding shop, paint shop and assembly shop at the same production rhythm. Each shop consists of a series of work stations, where the accessories are assembled to the car bodies according to the bill of materials (BOM). As the stop of the production process incurs a large amount of energy waste, the inventory of the accessories at each station should be enough to satisfy the production requirements. We consider cars R = {1, 2, · · · , N } to be processed consecutively on work stations M = {1, 2, · · · , M }. The planning horizon T = {1, 2, · · · , T } starts from the time when the first car in the sequence enters the production line, and ends at the time when the last car in the sequence leaves the production line. As the production rhythm is unchanged, the car bodies moves from one station to the next at the end of each time period t. The car sequence also must comply with several capacity constraints of each shop, i.e., limited solvent consumption for cleaning paint guns and maximum number of consecutive usage of certain accessaries. Thus, restrictions are represented by a parameter tuple p o , q o : any successional q o cars may contain at most p o cars requiring option o. Therefore, the production sequence must comply with the work station configurations such that conducted processing do not influence the number of cars manufactured in the same time unit, which is described by the industry popular JPH (Job per Hour) indicator.
The remaining notations of our problem are as follows: The mathematical formulation of the problem reads as follows:

Sets and parameters
The objective (1) is aim to minimize the total constraints violation and non-level option consumption cost. s.t.

capacity violation
Constraints (2) calculate the total quantity of capacity violations of option o.

car-machine assignment
Constraints (3) and (4) make sure that each position is allocated to exactly one car and each car is produced on exactly one position.
block production Constraints (5) imply that for each option o, there are J o blocks.
Constraints (5) impose that the number of cars between the first cars of any two blocks should be at least f o + 1, so as to separate different blocks.
Constraints (7) make sure that each car scheduled in the block has option o.
option consumption Constraints (8) calculate the start time of producing car i on station m Constraints (9) impose a schedule coincide with the sequence: for each car i, the start time of the process on station m + 1 should be later than the finish time of the process on mth station . α ijm ≤ α ij,m+1 , ∀i ∈ N , m ∈ M, j = 1, 2, · · · , N Constraints (10) present the relations between variable x and α α ijm ≤ Bx ij , ∀i ∈ N , m ∈ M, j = 1, 2, · · · , N Constraints (11) calculate the consumption of option o at time period t.

Solution Approach
Solving the stand-alone CSP is known to be NP-hard (Kis, 2004). Hence, the integrated car sequencing and inventory management problem is also NP-hard. Due the large computation burden, most studies adopt metaheuristics to tackle the problem. For instance, tabu search (TS) and variable neighborhood search (VNS) algorithms are frequently applied to solve the problem. Usually, commercial softwares including CPLEX or Gurobi have poor-quality solutions for largesized instances of this integrated problem, because of a great number of binary and integer variables. A more specific solution method is needed to tackle this issue. We propose one constructive heuristic and one destructive heuristic that are both capable of solving the problems. The first heuristic is a constructive heuristic based on a relax-and-fix procedure, and the second one is an fix-and-optimise destructive heuristic combining variable neighborhood search and proximity search techniques.

A constructive heuristics
Inspired by the work of Pochet & Wolsey (2006), the structure of the formulation in Section 4 indicates that relax-and-fix heuristics could efficiently solve the scheduling problem. In this approach, the original problem could be iteratively decomposed into some smaller ones, which are partially relaxed sub-problems. Since the size of the sub-problem (the amount of variables) is reduced significantly, the computation time needed could also be reduced. Firstly, all the binary variables are divided into several subsets. During the iterative searching process, the variables of only one of these subsets are remained to be binary, and the rest are changed to be any real number. Then the acquired small-sized problem could be solved to (near) optimality and the 0-1 variables are remained at their current values. Repeat this procedure until all the 0-1 variables are fixed.
The decomposition strategies of the binary variables determine the complexities of the sub-problems Escudero & Salmeron (2005). We adopt an index-based decomposition strategy in this study: the variables are grouped by cars index, which relates the all the binary variables. Specifically, T f denotes the subset of car indices the corresponding binary variables are fixed at their current value, N r represents the subset of car indices the corresponding variables are relaxed to be any real number , and N o defines the subset of car indices the corresponding variables are optimized. All the subsets are gradually updated based on the solution of each sub-problem. Letx ij be the solution at each iteration. The smaller problem (Π s1 ) to be addressed in the next step is defined by introducing the following constraints: The first constraint defines the 0 − 1 variables that have been previously solved and fixed during the current iteration, the second constraint describes the 0 − 1 variables that are relaxed, and the 0 − 1 variables to be solved during the current iteration are defined in the last constraint.
In light of James & Almada-Lobo (2011) and Wei et al. (2017), we use a decomposition pattern with overlapping car index sets (N o and N f ). Specifically, only a subset of the solved solution are fixed. We use two parameters χ and ψ to achieve this strategy, where χ is the number of car indices with integrality requirements and b is the number of car indices whose variables are fixed. By imposing χ < ψ, we select a car indices from the solved ψ car indices. The heuristic procedure is summarized by Algorithm 1.

An improvement heuristic
We introduce an improvement heuristic with an adaptive VNS procedure in this subsection. The VNS procedure has been widely used to solve large mixed integer linear programming problems Wei et al. (2017). In this procedure, firstly we generate a feasible solution and iteratively separates the binary variables from the current solution into two groups. The binary variables in the first group are fixed at their current value and the rest will be optimized in each iteration. Note that binary variables are no longer relaxed in this procedure, therefore, a feasible solution is generated at each iteration. Similar to the relax-and-fix heuristic, the decomposition strategy is crucial to the solution quality and calculation efficiency Helber & Sahling (2010). In this study, we decompose the variables according to a combination of cars N and periods T to keep sufficiently large solution space in each iteration. The subproblem Π s2 to be solved is acquired by imposing constraints: x ij =x ij , y ot =ỹ ot , i ∈ N f , t ∈ T f ; x ij , y ot ∈ {0, 1}, i ∈ N o , t ∈ T o , where N f and T f include the variables whose values are fixed, and N o and T o represent the subsets of N and T , indicating the variables that will be optimized.
In the VNS framework, the solution space is to systematically examined in the following. Firstly, the incumbent solution is partially fixed according to a predefined structure, and then the neighborhood of the current solution is explored by MILP solver. If an improvement is found, VNS will repeat these two steps; otherwise, the VND continues with the next neighborhood structure and explores the corresponding solution space. Note that the moving to the next neighborhood structure is conducted only after a pre-specified number of no improvements. In case of all structures being examined without finding an improved solution, a local optimum is identified.
To speedup the search process, we propose a reinforced parameter tuning mechanism to determine the indices of cars and periods. Specifically, the probabilities of selecting any cars and periods are initialized to 1 and will be adjusted based on two parameters, namely recency and frequency. Recency represents the number of times the corresponding cars and periods has been selected, while frequency is the number of iterations since they were last used. The probability of being selected is the weighted average of these two parameters. Let λ and γbe the number of cars and periods fixed in each iteration, respectively. The proposed heuristic is described in Algorithm 2. where BS stands for best solution upon the current iteration, CS represents the current solution, num means the maximum number of no-improvement iterations and MI is the maximum total iterations.

Results
The model and algorithms are coded in Visual Studio 2015 Enterprise with CPLEX (version 12.8), and the computations are conducted on a Lenvo ThinkStation P720 with six Intel Core 2.4-G processors and 16 GB RAM, equipped with macOS Catalina. All instances are run on CPLEX with formulation for 3600 seconds (s) and the obtained solutions serve as lowerbound to compare the algorithms.

Instance generation
In this section, we evaluate the efficiency of the proposed solution approaches, a series of instances are created based on the benchmark library of CSP problem CSPLib (Gent & Walsh, 1999)

Parameter setting
The solution approaches consist of two stages: the first stage is initial solution generation, using a relaxand-fix constructive heuristic; the second stage improve the solutions from the first stage by either a branch-and-cut algorithm utilized in the Cplex solver or a fix-and-optimize algorithm.
For the constructive heuristic, the value of χ determines the scale of the sub-problem generated in each iteration, while ψ decides the range of the search processing. Note that the solution quality is mainly determined the first iteration since only this sub-problem is technically the real relaxation of the original problem. One can use a higher value of χ to achieve a better solution quality, however, at the cost of more computational expenses. The experimental results reveal that for low values of χ(i.e., ≤ 3), reasonable solutions are obtained fast. However, it is still not possible to guarantee their quality, especially for instances of large-sized instances. Finally, the parameters used are as follows, χ = 5, ψ = 4 and 10s for each iteration (in total 60s) with a tradeoff between efficiency and accuracy.
For the improvement heuristic, the neighborhood structure based on (λ, γ) is important for the efficiency of the fix-and-optimize heuristic. It serves as a strategy either allows an expensive search on a large scale of the solution space, or a dedicated search within a small solution space. Preliminary experiments show that parameter λ is the major factor influencing the quality of the solution. To maintain a reasonable-sized sub-problem, we consider structures with small λ values. Through experiments, the adopted neighborhood structure is by combining values λ ∈ {3, 5, 9, 7} and γ ∈ {3, 4}.

Results analysis
The heuristic algorithms introduced above are used to solve the instances created in Section 6.1. The approach comprises two stages: generating an initial solution with a limited CPU time of 5s and improvement with time limit 60s. B&C stands for the branch-and-cut algorithm imbedded in CPLEX, R&F represents the relax-and-fix heuristic, and F&O refers to the fix-and-optimize improvement heuristic. The solution generated by CPLEX serves as the threshold to calculate the optimality gap.
In the first stage, we utilize either B&C or R&F approach (with the parameters valued in previous sections to obtain the initial solution. The percentages of optimality gap of each instance are presented in the first three columns of Table 1. We observe that the B&C algorithm cannot provide a feasible solution when the number of cars exceeds 300. Algorithm R&F can generate a feasible for all instances in the limited time and can provide a better solution among the solved instances. In the second stage, both F&O and B&C are applied to improve the initial solution. For instance, in Figure 1, "R&F-B&C" denotes that the initial result is calculated by the relax-and-fix algorithm, and then improved by the fix-and-optimize heuristic. Overall, the attribute of the initial result has a positive impact on the improvement efficiency, and R&F+F&O outperforms other algorithm combinations. R&F outperforms B&C in generating better initial solutions, with an average optimality gap 893.5 for solved instances and also leads to better final solutions. As shown in column 4 and 6, both B&C and F&O can significantly improve the initial solution generated by B&C. Note that for instances with 300, 400 and 500 cars, B&C+B&C has difficulties in finding the first feasible solution in 3s, but is capable of providing a feasible solution within 60s. We observe that in column 5 and 7, F&O provides better final solutions than B&C. For instances with less than 200 cars, F&O is able to provide near optimal solutions (gap less than 1%). For instances with larger number of cars, F&O can also generate affordable solutions with a short CPU time. The overall optimality gap among all instances is 8.72%. We take the instances with 200 cars to illustrate the computational efficiency of our heuristic ap-proaches. As we can observe in Figure 1, F&O significantly improves the initial solution in the first 10 seconds, then it becomes time consuming to search for the globally optimal solution. The B&C has a similar performance on the same set of instances, but is outperformed by F&O in the search efficiency and solution quality.

System Implementation and evaluation
In this section, we describe the implementation of a decision support system with integrated heuristic approaches, and the benefits to the company using such DSS. We started working on this problem with the car manufacturing company in 2020. At that time, the company has already utilized an enterprise resource planning (ERP) system to deal with the production and inventory planning problem. However, this system is lack of optimization-based decision-making capability to provide daily operation instructions. The production and inventory decisions were made mainly with non-optimization tools and expert experience.
The main purpose of the collaboration with the company was to streamline their decision-making process and replace their old planning procedures by automatic DSS with advanced solution approaches. The DSS was developed in Microsoft Visual C++ 2015 environment. The algorithms were coded in C++ with IBM ILOG CPLEX concert technology (version 12.8), and is run on top of their information system developed in a Java environment.
The company's previous method was developed a couple of years ago by a consulting agency. That method treat production and inventory as separate problems. The logic used to generate production planning is a greedy algorithm, which prioritizes the production requirements and adjusts the production schedules based on such priority preference. Their method is straightforward and has been used for a number of years. However, such a heuristic requires a lot of planning experiences which is difficult to be quantified and systemized. Considering the complexity of the problems, we believe that our integrated approach could outperform their manual method.
We conducted comparison experiments to evaluate the benefits of our integrated approach. The realworld instances generated in Section 6.1 are used as the test bed and heuristic R&F+F&O is adopted. The main parameters (n, o, m, p o : q o ) of 15 instances of real-world production and inventory data are shown in Table 2, where each row represents one specific production and inventory planning. Note that the value of m (number of work stations) is not the same across different instances, due to the ordinary maintenance requirements on the stations. Table 2 describes the solutions of the experiments. "Vio cost" represents the constraint violations costs. "Opn con" means the non-level option consumption cost. "Cost sv" means the total cost savings acquired by the heuristic approach compared with company's current manual method. The results returned by the R&F-F&O heuristic are given in columns 8 and 9. For comparison, the improvement on total cost made by the R&F-F&O heuristic is summarized in column 10. We observe that our heuristic approach can save 7.74% of the total cost. Besides, the optimality gap between the final result and the threshold result is given in column 11, and the average percentage value is 5.57. The last column of this table is computation time (CPU) of the R&F+F&O heuristic when the solution does not improve anymore.
Form Table 2 we observe that our heuristic would improve the production planning by reducing the cost of constraint violations, from an average of 953 to 926 (2.8% decrease), and increase inventory turnovers by an average of 4.4%. Our algorithm is capable of improving the constraint violation cost and inventory turnovers in all instances, which are the key demand for the company. The results also indicate that our heuristic approach could improve the constraint violation costs in almost each of these 15 instances, and reduce total cost by an average of 7.74%. Compared with the generated large instances, our algorithm can find a satisfiable solution in 12 seconds. Thus, using our heuristic could improve the current method.

Conclusion
In this paper, we extend the classical CSP by addressing block batch constraints, which has been frequently encountered in the auto industry in practice. Especially for manufactures changing from mass standardization to mass customization, the large cumulative setup times of frequently changed fixtures often disturb the normal production rhythm. Besides, the block production also deteriorates the level production requirements, which deserves a more delicate evaluation method of non-level production cost, so as to better tuning the production sequence. We propose a new mixed-integer linear programming (MILP) formulation to tackle the proposed issues. Aware of the NP-hardness, we develop two math-heuristic algorithms to handle the large-scale problems efficiently. The first one is a constructive heuristic that is capable of fast providing acceptable solutions in a limited computation time. The acquired solution can also be used as the starting point for the second improvement heuristic, which incorporates a data-driven adaptive variable neighborhood search to produce high-quality solutions to real-life-size instances within acceptable runtimes. Extensive computational experiments are reported, and several managerial insights into the planning process are given.
In the future, it would be interesting to consider other practical constraints in the car production process, i.e., mixed-line production structure, car sequencing with limited buffers. Obviously, the incorporation of extra constraints would increase the difficulties of solving the complex problem. Hence, more advanced solution algorithms are deserved to be thoroughly studied.