On Propeties of the LIP Model in the Class of RCPSPs

Abstract

The Resource-Constrained Project Scheduling Problem (RCPSP) is a significant and important issue in the field of project management. It arises during project planning when resources must be allocated among tasks with specific time constraints. Solving this problem enables the optimization of project execution time, minimization of resource costs, and increased efficiency of the entire team’s work. Due to the increasing complexity of projects, the development of new methods and algorithms to solve RCPSP is relevant nowadays. The existing methods for obtaining approximate solutions with guaranteed accuracy are characterized by high computational complexity and are often ineffective in considering the specific constraints of the problem. Fast heuristic approaches also have several drawbacks related to fine-tuning algorithm parameters and strong dependence on the quality of the initial solution. This paper investigates the features of the linear integer programming (LIP) model to solve RCPSP. The proposed LIP model is universal and scalable, enabling it to fully consider all specific aspects of the problem. The paper provides a construction algorithm of a functional space of the model and discusses the estimation of complexity. From the estimation of the mentioned algorithm’s complexity, it is observed that the general complexity of the proposed approach is proportional to a controlled parameter of the LIP. Increasing this controlled parameter can significantly reduce the dimensionality of the initial problem, thus leading to the effectiveness of the LIP model-based approach in terms of computational resources. An upper bound for the value of this parameter is obtained for a special case of the RCPSP. Using the obtained balanced value, a numerical experiment was carried out on real-world samples.

1. Introduction

Integer linear programming is widely used in various fields, including transportation and industrial planning. In [1,2], integer linear programming models were developed for solving applied problems concerning the planning of railway transportation processes. In [3,4], scheduling problems were effectively reduced to the associated problems of integer linear programming. In [5], integer linear programming model was proposed to solve some industrial planning problems. An extended overview of applications of integer linear programming, as well as modern methods of solving them, are provided in [6,7,8,9]. In [6,7], the classical statements and methods for solving linear and integer programming problems, including Boolean programming problems, are narrowly discussed. In [8,9], special attention is paid to the development of integer linear programming models for various applied problems regarding management, planning, and decision-making process.

Due to the fact that integer linear programming is a well-known $\mathcal{NP}$ -hard problem, methods for its solving are under active development and improving nowadays. An extended overview of modern methods for solving integer linear programming problems is presented in [10,11].

It is well-known that the various cases for machine scheduling and shop scheduling problems can be reduced to the Resource-Constrained Project Scheduling Problem (RCPSP). The cases of RCPSP are various. The papers [12,13] investigate a special class of RCPSP problems with time-varying activities and uncertain task durations. In the paper [14], a resource-constrained scheduling problem is considered, and a mixed-integer programming model is developed. The paper [15] deals with a similar problem of resource allocation using a two-stage multi-operator differential evolution algorithm. Graph-based methods for reducing project duration are proposed in [16]. The problem being considered in this paper also shares similar features with RCPSP. Given a set of tasks i $(i=1,\dots ,n)$ and resources of initial machines j $(j=1,\dots ,m)$, one needs to construct a schedule of a process with respect to the set of technological constraints. For each task i, there is a given interval $[\sigma \left(i\right)-\widehat{\tau }\left(i\right),\sigma \left(i\right)-\tau \left(i\right)]$ for the start of processing. Thus, the problem can be classified as RCPSP with the fixed duration for processing at each resource and constraints regarding the start and finish of processing for each task. A wide review regarding different cases of RCPSP can be found in [17].

The RCPSP is an extremely difficult $\mathcal{NP}$ -hard problem, even in the simplest form. Effective algorithms for solving RCPSP problems are based on the branch and bound method [18,19,20] and allow finding approximate solutions with an accuracy to some constant. However, such an approach requires significant modification of the initial problem and adaptation to the branching and pruning technique. For example, the branch and bound method may not be effective in the presence of multiple arcs and constraints on the sequence of task execution. In this paper, a LIP model is developed, for which modern software (the PuLP library in Python) is used for direct solution. This approach allows for approximating the optimal solution with high accuracy by using many iterations, constraints on the number of variables, and constraints on the total time of subproblems. The main goal of the study is the development of an adequate mathematical model that fully reflects the diversity of problem constraints (constraints on resources, work execution time, etc.). The paper describes in detail the procedures for forming the variable space, the system of constraints, and the objective function. One of the features of these procedures is the use of a special $\delta$ parameter, which provides a high variability of the variable space and corresponding model flexibility for incorporating various types of constraints.

Solving RCPSP problems with high approximation accuracy requires significant computational resources. Therefore, the use of metaheuristic algorithms [21,22,23,24] and their various modifications is widely spread. However, although metaheuristic algorithms are characterized by high efficiency in terms of run time, they often depend on choosing the correct parameters and the quality of the initial solution. The last fact is often unachievable in the class of RCPSP problems with a fixed set of tasks to be executed (constraints on the guarantee of task execution). In this case, metaheuristic approaches face difficulties in finding even a random feasible solution, including the initial one. The approach proposed in this paper based on the LIP model avoids these drawbacks and allows finding solutions that are sufficiently close to optimal in a reasonable time. This effect is achieved by selecting a balancing value of the model’s parameter $\delta$. The paper discusses in detail the rule for selecting this value and obtains an upper estimate for a special class of RCPSP problems.

Therefore, the proposed LIP model in the paper is highly relevant, as its implementation using modern software allows for approximating the optimal solution with high accuracy in a reasonable time. Moreover, the proposed LIP model is universal, scalable, and enables consideration of all specific features of the investigated problem.

The paper is structured as follows. In Section 2, we introduce the problem under consideration and describe the LIP model. In Section 3, we discuss a significant step in LIP construction, which is related to generating the functional space. In Section 4, we describe the rule for selecting a balanced value of the controlled parameter in the LIP for a special case of the RCPSP. Finally, Section 5 presents the results of a numerical experiment and explains the methodology.

2. LIP Model in the Class of RCPSPs

2.1. General Statement of the Problem

We consider the general case of RCPSP, where the set of tasks $\mathcal{Z}=\left\{{\zeta }_i\right\}$ is given and enumerated by $i=[1,n]$ with parameters

$$\sigma \left(i\right),\rho \left(i\right),\tau \left(i\right),\widehat{\tau }\left(i\right).$$

Here, $\sigma \left(i\right)$ refers to the start of execution at the final machine, $\rho \left(i\right)$ is the duration of execution, and $\tau \left(i\right)$ and $\widehat{\tau }\left(i\right)$ are the minimum and maximum time allowed for processing, respectively. Further, we assume that all time parameters are integers and represented in timestamp format.

We also have the set of initial machines (resources for task execution) $\mathcal{M}=\left\{{\mu }_j\right\}$, enumerated by $j=[1,m]$, with parameters

$$\lambda \left(j\right),\pi \left(j\right),$$

where $\lambda \left(j\right)$ is the duration of task execution at the corresponding initial machine, and $\pi \left(j\right)$ is the inter-job delay—time required for machine preparation and switching when tasks are assigned sequentially.

Problem 1.

We need to construct an assignment of the form

$$\mathcal{Z}⟶\left\{(i,j,t_{ij})\right\}$$

(1)

for a given set of tasks $\mathcal{Z}=\left\{{\zeta }_i\right\},i=[1,n]$ and resources of initial machines $\mathcal{M}=\left\{{\mu }_j\right\},j=[1,m]$, where $(i,j,t_{ij})$ corresponds to the execution of the i-th task at the j-th initial machine with a beginning at $t_{ij}$ (meaning the time moment), subject to the following constraints

$$\left\{\begin{array}{c}\sigma \left(i\right)-\widehat{\tau }\left(i\right)⩽t_{ij}+\lambda \left(j\right)⩽\sigma \left(i\right)-\tau \left(i\right),\hfill \\ |t_{ij}-t_{i^{\prime }j}|⩾\lambda \left(j\right)+\pi \left(j\right),\hfill \end{array}\right.$$

(2)

for all $i,i^{\prime }=[1,n]$ and $j=[1,m]$.

The index i in (2) corresponds to the task number to be executed and provided in accordance with the original task numbering in the set $\mathcal{Z}$. For example, $\sigma \left(i\right)$ is the given start time of i-th task at the finishing machine on the route (i.e., the finish time of the technological route), and $\widehat{\tau }\left(i\right)$ is the maximum time allowed for execution of the i-th task (from the release from the initial machine up to the finish of the technological route), etc. The index j in (2) corresponds to the number of the initial machine available for assignment to execution the task.

The first constraint in (2) ensures that each task from the set $\mathcal{Z}$ is assigned for execution at the initial machine within the allowed minimum and maximum time for processing. The second inequality in (2) corresponds to the operating conditions of the initial machines.

2.2. LIP Model

For solving problem (1), we consider an integer linear program with the following functional space structure. Each variable $x_i\in \{0,1\}$, $i=[1,k]$, represents a set of parameters

$$x_i:z_i,m_i,s_i,{\alpha }_i,$$

where $z_i\in \{1,n\}$, $m_i\in \{1,m\}$, and $s_i$ corresponds to the start of execution of the task $z_i$ at the initial machine $m_i$, and ${\alpha }_i$ is an objective coefficient. Thus, the problem is to minimize the objective function

$$\sum _{i=[1,k]}{\alpha }_i·x_i⟶min,$$

(3)

subject to

$$\left\{\begin{array}{c}{x}_i+{\displaystyle \underset{j\ne i}{\sum _{j=[1,k]}}}\left\{x_j:z_j=z_i\right\}=1,\hfill \\ x_i+{\displaystyle \underset{j\ne i}{\sum _{j=[1,k]}}}\left\{x_j:m_j=m_i,|s_i-s_j|⩽\lambda \left(m_i\right)+\pi \left(m_i\right)\right\}⩽1,\hfill \\ x_i+{\displaystyle \underset{j\ne i}{\sum _{j=[1,k]}}}\left\{x_j:z_i=z_j,s_j+\lambda \left(m_i\right)<\sigma \left(z_i\right)-\widehat{\tau }\left(z_i\right)\right\}=0,\hfill \\ x_i+{\displaystyle \underset{j\ne i}{\sum _{j=[1,k]}}}\left\{x_j:z_i=z_j,s_j+\lambda \left(m_i\right)>\sigma \left(z_i\right)-\tau \left(z_i\right)\right\}=0,\hfill \\ x_i\in \{0,1\}.\hfill \end{array}\right.$$

(4)

We state that $x_i=1$ if the task $z_i$ is assigned for execution at the initial machine $m_i$ with start time $s_i$, and $x_i=0$ otherwise.

3. Algorithm for Construction of the Variables Space

Based on the problem stated in (1), we can establish that the domain of the function in (1) is a set of $(i,j,t_{ij})$. This includes the task number, machine number, and the execution start time. Since $t_{ij}$ can take an arbitrary values, it is subject to constraints from (2) that depend on the parameters $\tau \left(i\right)$ and $\widehat{\tau }\left(i\right)$.

We introduce $\delta$ parameter for all machines, which means the periodicity of generating triples $(i,j,t_{ij})$ for possible assignments of the task i for the beginning of execution at the machine j. In fact, this value could be dynamic and could depends of the width of the corresponding interval $[\tau \left(i\right),\widehat{\tau }\left(i\right)]$ for which the subset of variables is generated.

Without loss of generality, we will consider a subset of variables for a given task i. As previously mentioned, there is also a set of parameters to be given, such as $\sigma \left(i\right)$, which represents the start of execution at the final machine, and $\rho \left(i\right)$, which represents the duration of execution. Then, for the j-th initial machine, the subset of variables corresponding to the i-th task will take the following form,

$$\begin{array}{cc}\hfill & x_{ij1}:(i,j,t_{ij}=\sigma \left(i\right)-\widehat{\tau }\left(i\right)-\lambda \left(j\right),{\alpha }_{ij1}),\hfill \\ \hfill & x_{ij2}:(i,j,t_{ij}=\sigma \left(i\right)-\widehat{\tau }\left(i\right)+\delta -\lambda \left(j\right),{\alpha }_{ij2}),\hfill \\ \hfill & x_{ij3}:(i,j,t_{ij}=\sigma \left(i\right)-\widehat{\tau }\left(i\right)+2·\delta -\lambda \left(j\right),{\alpha }_{ij3}),\hfill \\ \hfill & \dots ,\hfill \\ \hfill & x_{ijk}:(i,j,t_{ij}=\sigma \left(i\right)-\widehat{\tau }\left(i\right)+(k-1)·\delta -\lambda \left(j\right),{\alpha }_{ijk}),\hfill \end{array}$$

where $k=\lfloor \frac{\widehat{\tau }\left(i\right)-\tau \left(i\right)}{\delta }\rfloor +1$ represents the number of variables corresponding to the start of execution of the task i at the machine j and does not contradict the permissible interval of $[\tau \left(i\right),\widehat{\tau }\left(i\right)]$.

The algorithm for generating the functional space of the LIP (3) and (4) is presented in Algorithm 1.

Algorithm 1. An algorithm $Alg(\mathcal{Z},\mathcal{M},\delta )$

1: for all   $i=\left[1,n\right]$  do 2:     for all $j=\left[1,m\right]$ do 3:         for all $l=\left[1,\lfloor \frac{\widehat{\tau }\left(i\right)-\tau \left(i\right)}{\delta }\rfloor +1\right]$ do 4:            $k=k+1$                              ▹ global counter of variables 5:            $z_k=i$  6:            $m_k=j$  7:            $s_k=\sigma \left(i\right)-\widehat{\tau }\left(i\right)+(l-1)·\delta -\lambda \left(j\right)$  8:            ${\alpha }_k=\lfloor \frac{\widehat{\tau }\left(i\right)-\tau \left(i\right)}{\delta }\rfloor +1-l$

The coefficients ${\alpha }_k$ of the objective function are selected to be proportional to the total execution time of the task i considering the variables $s_k$ and $\lambda \left(j\right)$, where $z_k=i$ and $m_k=j$. This rule assures the minimization of the total production cost for all tasks, where a higher duration of production implies the need for more resources.

Let us introduce the following definition

$$\mathsf{\Delta }=\underset{i=\left[1,n\right]}{max}\left\{\lfloor \frac{\widehat{\tau }\left(i\right)-\tau \left(i\right)}{\delta }\rfloor +1\right\}.$$

(5)

Theorem 1.

The worst-case time complexity of $Alg(\mathcal{Z},\mathcal{M},\delta )$ is $O\left(n^2\right)$.

Proof. 

The $Alg(\mathcal{Z},\mathcal{M},\delta )$ operates through several cycles as follows:

• An external cycle runs through all tasks and requires a fixed number of n iterations.
• Next, a cycle runs through all resources that are allowed for execution of the given set of tasks. This also requires a fixed number of m iterations.
• An internal cycle runs through all start time cases of the task i at the initial machine j. This requires not more than $O\left(\mathsf{\Delta }\right)$ iterations in accordance with definition (5).
• Finally, all operations on the values of parameters for the current variable k require a constant number of $O\left(1\right)$ iterations.

Thus, the algorithm $Alg(\mathcal{Z},\mathcal{M},\delta )$ requires $O\left(nm\mathsf{\Delta }\right)$ iterations in terms of the RAM model. We denote by $\mathsf{\Delta }\left(i\right)=\lfloor \frac{\widehat{\tau }\left(i\right)-\tau \left(i\right)}{\delta }\rfloor +1$ the number of iterations at the i-th step of the external cycle $i=[1,n]$. If $T\left(n\right)$ is the running time of the algorithm, wehave

$$\begin{array}{c}T\left(n\right)=m·\mathsf{\Delta }\left(1\right)+m·\mathsf{\Delta }\left(2\right)+\cdots +m·\mathsf{\Delta }\left(n\right)=\\ m·\sum _{i=[1,n]}\mathsf{\Delta }\left(i\right)⩽m·n·\mathsf{\Delta }⩽\mathsf{\Delta }·n^2\end{array}$$

Note that if $m⩾n$, the problem becomes trivial for the considered RCPSP. Since $\mathsf{\Delta }$ is constant that is independent of n, we obtain $T\left(n\right)=O\left(n^2\right)$, where $T\left(n\right)$ is the running time of the algorithm $Alg(\mathcal{Z},\mathcal{M},\delta )$. Therefore, the constant values of c and $n_0$ exist, such that $0⩽T\left(n\right)⩽c·n^2$ for all $n⩾n_0$ (in particular, the inequality holds for $n_0=\mathsf{\Delta }$ ). This concludes the proof. □

According to Theorem 1, the complexity of $Alg(\mathcal{Z},\mathcal{M},\delta )$ is estimated at $O\left(nm\mathsf{\Delta }\right)$, where $\mathsf{\Delta }$ is defined as (5). It is clear that the complexity of the algorithm is directly proportional to the parameter $\delta$. However, a smaller value of $\delta$ could increase optimization opportunities due to a wider functional space. The procedure for finding a balanced value of $\delta$ will be discussed in the following section.

4. Balancing of the Controlled Parameter of the LIP

Let us consider a set of tasks $\mathcal{Z}=\left\{{\zeta }_i\right\}$ of a continuous series type, so that, the duration of the execution of each task at the final machine is the same for all tasks.

$$\begin{array}{cc}\hfill & \sigma \left(1\right)=\sigma \left(z\right),\hfill \\ \hfill & \rho \left(i\right)=\rho \left(z\right)\mathrm{for}\mathrm{all}i=[1,n],\hfill \\ \hfill & \widehat{\tau }\left(i\right)=\widehat{\tau }\left(z\right)\mathrm{for}\mathrm{all}i=[1,n],\hfill \\ \hfill & \tau \left(i\right)=\tau \left(z\right)\mathrm{for}\mathrm{all}i=[1,n],\hfill \\ \hfill & \sigma \left(i\right)=\sigma \left(z\right)+(i-1)·\rho \left(z\right)\mathrm{for}\mathrm{all}i=[2,n].\hfill \end{array}$$

It should be noted that the continuous series type production is a widely recognized class of RCPSPs. For instance, metallurgical and timber processing industries organize their production as a continuous series type, grouping orders into series based on shared features of the final production units during the calendar planning stage.

Theorem 2.

For a given continuous series of tasks $i=[1,n]$, and for a fixed initial machine $j\in [1,m]$, such that $\rho \left(z\right)⩽\lambda \left(j\right)+\pi \left(j\right)$, a solution of the problem (3) and (4) exists guaranteed if

$$\delta =max\left\{\frac{n-1}{\widehat{\tau }\left(z\right)-\tau \left(z\right)},\pi \left(j\right)\right\}$$

(6)

Proof. 

Let us consider the functional space of the model (3) and (4) constructed by using the $Alg(\mathcal{Z},\mathcal{M},\delta )$ algorithm. We obtain

$$\left\{x_k:\left(z_k,m_k,s_k,{\alpha }_k\right)\right\},$$

where $z_k=\left[1,n\right]$, $m_k\in [1,m]$ and

$$s_k=\sigma \left(z_k\right)-\widehat{\tau }\left(z\right)+(l-1)·\delta -\lambda \left(m_k\right)$$

with $l=\left[1,\lfloor \frac{\widehat{\tau }\left(z\right)-\tau \left(z\right)}{\delta }\rfloor +1\right]$. We define

$$x_k=1:z_k=i,s_k=\sigma \left(z_k\right)-\widehat{\tau }\left(z\right)+(i-1)·\delta -\lambda \left(m_k\right)$$

(7)

for all $i=\left[1,n\right]$. Note that $l⩽n$ due to the initial definitions of

$$\left\{\begin{array}{c}l⩽\frac{\widehat{\tau }\left(z\right)-\tau \left(z\right)}{\delta }+1,\hfill \\ \delta ⩽\frac{n-1}{\widehat{\tau }\left(z\right)-\tau \left(z\right)}.\hfill \end{array}\right.$$

We will now show that the set of the form $\left\{x_k=1\right\}$ defined by (7) satisfies all constraints of the model (3) and (4).

Constraints of the form (1) and the first condition in (2) are satisfied due to the construction. To satisfy the second condition in (2), we need to have

$$t_{ij}-t_{i^{{}^{\prime }}j}⩾\lambda \left(j\right)+\pi \left(j\right)$$

for all $i^{\prime }<i$. We then have

$$\begin{array}{c}\sigma \left(z\right)+(i-1)\rho \left(z\right)-\widehat{\tau }\left(z\right)+(i-1)\delta -\sigma \left(z\right)-(i^{{}^{\prime }}-1)\rho \left(z\right)+\widehat{\tau }\left(z\right)-(i^{{}^{\prime }}-1)\delta =\\ (i-i^{\prime })\rho \left(z\right)-(i-i^{\prime })\delta ⩾\lambda \left(j\right)+\pi \left(j\right).\end{array}$$

On the one side, we obtain

$$(i-i^{\prime })\rho \left(z\right)-\lambda \left(j\right)⩾\pi \left(j\right)-(i-i^{\prime })\delta ⩾\pi \left(j\right)-\delta ,$$

and on the other side, we have

$$\left\{\begin{array}{c}(i-i^{\prime })\rho \left(z\right)-\lambda \left(j\right)⩾\rho \left(z\right)-\lambda \left(j\right)\hfill \\ \rho \left(z\right)⩽\lambda \left(j\right)+\pi \left(j\right)\hfill \\ \rho \left(z\right)-\lambda \left(j\right)⩽\pi \left(j\right)\hfill \end{array}\right.$$

for all $\rho \left(z\right)$, $\lambda \left(j\right)$, $\pi \left(j\right)$, $\delta >0$, and $i^{\prime }<i$. At the same time, the inequality $\pi \left(j\right)⩾\pi \left(j\right)-\delta$ holds if, and only if, $\delta ⩽\pi \left(j\right)$. This contradicts the condition $\pi \left(j\right)>0$ otherwise. The theorem is proved. □

Based on Theorem 2, we can choose the value of the parameter $\delta$ in proportion to the value of $\pi \left(j\right)$ for RCPSPs of the continuous series type. We also use this rule to the general case of the problem and present the results of a numerical experiment in the next section.

5. Numerical Results

The proposed integer linear programming model was implemented using Python 3.8.5 and solved using the PuLP software. The experiment was carried out on an Intel Core m3 processor with a speed of 1.2 GHz and 8 GB of 1867 MHz LPDDR3 memory, running macOS 10.13.6.

Real-world data on processes at the converter shopfloor over a month-long period were used as samples, with each instance consisting of $n=100$ tasks and $m=3$ of initial machines with parameters of $\lambda \left(j\right)=42$ (min) and $\pi \left(j\right)=10$ (min) for all $j=[1,m]$. Note that $\rho \left(i\right)⩽\lambda \left(j\right)+\pi \left(j\right)$ and $\frac{n-1}{\widehat{\tau }\left(i\right)-\tau \left(i\right)}⩽\pi \left(j\right)$ for all $i=[1,n]$. Based on Theorem 2, a balanced value of the parameter $\delta$ of 10 (min) was chosen for the main experiment. To compare its effectiveness, we also conducted the same experiment with $\delta$ values of 5, 2, and 1 (min).

Table 1. Computational results.

d	$\mathit{F}/\mathit{t},\mathbf{sec}(\mathit{\delta }=10)$		$\mathit{F}/\mathit{t},\mathbf{sec}(\mathit{\delta }=5)$		$\mathit{F}/\mathit{t},\mathbf{sec}(\mathit{\delta }=2)$		$\mathit{F}/\mathit{t},\mathbf{sec}(\mathit{\delta }=1)$
1	1852.1	7.11	1699.4	14.9	1706.8	34.6	1596.3	69.9
2	1690.2	3.22	1571.1	9.9	1559.7	30.4	1445.8	61.1
3	1627.7	3.92	1448.9	13.4	1490.9	39.1	1427.5	66.3
4	1832.8	9.25	1734.9	23.3	1612.2	37.7	1611.4	56.3
5	1823.8	60.75	1747.5	75.6	1652.6	94.1	1606.0	119.6
6	1101.8	0.55	1039.2	9.3	893.0	33.3	955.2	56.6
7	931.5	0.44	876.1	12.2	784.8	36.5	641.0	58.9
8	1086.9	0.5	1007.1	16.1	960.1	28.3	881.5	56.5
9	1283.7	0.74	1173.3	7.1	1142.1	27.1	1021.3	59.3
10	1383	0.52	1189.4	13.7	1236.4	19.0	1116.8	65.9
11	1723.2	16.07	1698.1	22.7	1522.6	49.2	1390.7	76.5
12	1632.2	34.85	1528.0	36.7	1394.8	63.4	1428.5	100.7
13	1770.6	3.94	1725.3	15.0	1689.9	33.0	1522.9	62.4
14	1990.8	25.17	1869.2	27.7	1851.5	66.9	1882.7	83.1
15	1935.3	15.39	1813.2	23.9	1787.4	48.5	1746.9	76.5
16	1759	5.2	1656.8	20.6	1611.5	35.6	1538.3	65.6
17	1843.8	6.64	1795.7	18.0	1686.8	28.1	1490.6	74.8
18	1835	4.64	1796.5	19.9	1692.6	32.1	1610.0	63.7
19	1717.2	8.69	1623.0	21.2	1522.7	31.9	1486.3	78.5
20	1251.6	1.08	1075.2	9.4	1093.1	35.0	1097.3	64.2
21	1131.3	0.74	982.4	3.4	1034.1	36.5	926.8	64.1
22	1080.5	0.88	887.2	16.0	969.0	30.9	823.7	61.9
23	1133.2	0.42	1020.6	8.2	1000.4	37.3	968.1	61.1
24	1233.4	0.51	1154.8	15.6	1039.2	38.6	1075.5	68.8
25	1704.7	2.65	1575.0	15.3	1638.3	30.0	1612.2	61.1
26	2065.5	33.47	1923.4	34.7	1935.8	62.3	1914.7	95.6
27	1925.6	10.34	1795.6	17.5	1721.5	41.8	1742.8	66.1
28	1982.8	3.71	1902.7	20.6	1953.3	26.0	1717.1	60.7
29	1891.7	26.67	1832.5	33.8	1780.8	54.7	1673.1	88.7

provides the following information for each instance within the considered period:

• The d column specifies the ordering number of each instance.
• The F column shows the objective function value, which is the total cost of all tasks associated with the corresponding instance. These costs were calculated in hundreds of monetary units based on historical data related to the production process. For example, if an instance involves several types of tasks, then there will be an average cost associated with the processing time for each type of task.
• The parameter t represents the CPU time required to solve the corresponding instance, and is measured in seconds.
• The table provides the values of F and t for all instances and for different values of $\delta$, namely 10, 5, 2, and 1 (in minutes).

Upon observing the results provided in Table 1, we can conclude that the decrease in the value of the parameter $\delta$ to 5 min leads to an improvement in the objective function up to $6.1\%$ on average. This effect is achieved by reducing the parameter $\delta$, which leads to a significant increase in the dimensionality of the model’s functional space. For small values of $\delta$, more options for the start execution time $t_{ij}$ of the task i are formed for each initial machine j. Therefore, the optimization opportunities of the model increase, which leads to an improvement in the objective function. However, this improvement comes at the cost of a significant increase in the CPU time, up to $-97.8\%$ on average. Essentially, for different values of $\delta$, we obtain ideologically identical models of different dimensionalities. This explains the significant difference observed in the obtained solutions. Similar trends are observed for the cases of $\delta =2$ and $\delta =1$, with improvements of $8.7\%$ and $13.1\%$ for the objective value and the decreases of $-299.3\%$ and $-602.6\%$ in CPU time, respectively. The model’s dimensionality with parameter $\delta =1$ is significantly higher than the dimensionality of the model with parameter $\delta =2$. The higher-dimensional model offers more opportunities for optimization and, as a result, delivers better quality of the objective function. However, the high dimensionality of the model requires significant computational costs, which is why we observe a decrease in efficiency in terms of run time for the case $\delta =1$. Therefore, we can conclude that the balanced value of the parameter $\delta =10$ min provides effective results for the objective, while maintaining an acceptable CPU time. This conclusion is based on the computational experiment’s results, which show that decreasing the parameter $\delta =10$ to values of 5, 2, and 1 leads to an improvement in the objective function of $6.1\%$, $8.7\%$, and $13.1\%$, respectively. At the same time, computational efficiency decreases to $-97.8\%$, $-299.3\%$, and $-602.6\%$, respectively. In the particular case of the initial dimensionality of $n=100$ and $m=3$, for example, a result of $14.9$ (s) for the case of $\delta =5$ is also acceptable. However, when increasing the dimensionality of the problem, where the run time for the case of $\delta =10$ could be measured in minutes, a slight improvement in the quality of the objective function may not justify such a significant decrease in computational efficiency.

6. Discussion

The proposed paper presents an approach based on the LIP aimed at solving RCPSP in continuous series production. It covers the defined functional space and constraints, along with an objective function for total processing costs. Additionally, it outlines an algorithm for constructing the LIP’s functional space and provides a complexity estimation. The application of such an approach in solving RCPSPs has several advantages compared to known methods of approximate solving with guaranteed estimates of accuracy. The proposed model is directly subject to solutions using modern software, which significantly reduces the computational costs of implementation. In addition, the functional space of the proposed model makes it flexible for the implementation of specific classes of problem constraints using a controlled parameter $\delta$. Increasing this parameter leads to a significant reduction in the dimensionality of the original problem, which makes the approach computationally efficient.

A balanced value selection rule for the controlled parameter of the LIP is proposed for the RCPSP special case. The paper includes a numerical experiment using real-world data from a converter shopfloor with a balanced controlled parameter value. The results of the computational experiment show that using a balanced value of the parameter allows obtaining a solution in an acceptable time without significant losses in the quality of the objective function.

The main direction of further research is related to strengthening the obtained upper bound of the model parameter in the class of general RCPSPs, as well as constructing solution approximations. Additionally, it will be interesting to investigate the application of the proposed approach to a wider range of production environments, considering different types of tasks, resources and constraints that may arise in practice. Moreover, the extension of the approach to handle uncertain data and disruptions in the production process could provide valuable insights for real-world applications. Another potential direction for future research is the integration of optimization algorithms with simulation techniques to provide more realistic and accurate models for production planning and control. Finally, the implementation of the proposed approach in a practical software system would allow for further testing and validation of its effectiveness in various production settings.

For managers and engineers, the proposed LIP model for solving RCPSPs is of great importance as it allows for the efficient resolution of issues related to optimizing production processes and resource planning. This helps to reduce production costs and increase efficiency, which are key tasks in modern industry.

For readers specializing in mathematical programming and scheduling theory, the obtained results are also of interest. Considering the LIP models with upper-bound controlled parameters to reduce the initial dimensionality of the problem can provide new ideas and directions for subsequent research and applied projects. Moreover, the proposed approach can be applied to solving other optimization problems, which makes it universal and interesting for a wide range of readers.