A Two-Stage Bin Packing Algorithm for Minimizing Machines and Operators in Cyclic Production Systems

Abstract

This study presents a novel, two-stage algorithm that minimizes the number of machines and operators required to produce multiple product types repeatedly in cyclic scheduling. Our algorithm treats the problem of minimum machines as a bin packing problem (BPP), and the problem of determining the number of operators required is also modeled as the BPP, but with constraints. The BPP is NP-hard, but with suitable heuristic algorithms, the proposed model allocates multiple product types to machines and multiple machines to operators without overlapping setup times (machine interference). The production schedule on each machine is represented as a circle (donut). By using lower bounds, it is possible to assess whether the number of machines required by our model is optimal; if not, the optimality gap can be quantified. The algorithm has been validated using real-world data from an industrial facility producing 17 types of products. The results of our algorithm led to significant cost savings and improved scheduling performance. The outcomes demonstrate the effectiveness of the proposed algorithm in optimizing resource utilization by reducing the number of machines and operators required. Although this study focuses on a manufacturing system, the model can also be applied to other contexts.

1. Introduction

Optimizing machine allocation and workforce scheduling is critical for minimizing operational costs in industries such as automotive, textile, and electronics. However, traditional scheduling models often overlook key factors such as machine interference and the cyclical nature of production demands. This study proposes a novel bin-packing-based approach to determine the optimal number of machines and operators in cyclic manufacturing environments. By systematically incorporating production constraints, the model addresses limitations in existing heuristic methods and significantly improves resource allocation efficiency.

Many industries, including food, textiles, plastics, electronics, and rubber, face significant manufacturing challenges, such as determining the number of production machines, operators, and production scheduling. A paint factory may produce multiple types of paint, each considered a distinct product; a food processing facility produces items with different packaging, colors, and shapes; and a textile factory may produce clothing in multiple colors and sizes. These challenges highlight the need for an optimal manufacturing strategy in production environments where multiple product types are manufactured using several nearly identical machines with limited capacity; efficient workforce management and cyclic production planning are essential. The primary goals in such settings include optimizing the number of machines and operators, establishing a production schedule that aligns with these objectives, and ensuring the timely fulfillment of customer orders. These considerations become particularly important when skilled labor is scarce to operate costly machinery and equipment.

A key feature of such production systems is that a single operator manages multiple, nearly identical machines. Assessing the efficiency of these systems requires analyzing the average cycle time, which consists of machine runtime, service time, and downtime. Downtime can occur when one or more machines require setup or service, but the operator is busy servicing another machine, leaving the machines requiring service idle until the operator becomes available. This phenomenon is referred to as machine interference [1]. Integrating machines and human labor is crucial in modern manufacturing, directly impacting efficiency, precision, and production speed. As technology evolves, the interaction between machines and human operators becomes increasingly sophisticated, emphasizing the need for a well-balanced approach that enhances productivity while supporting workforce development.

The optimization of machine scheduling is one of the most critical issues in modern manufacturing, and many studies have been conducted on optimizing production schedules [2,3]. In this context, determining the optimal number of machines required to meet the total demand for various products and the number of operators needed for those machines is a challenging problem. This paper analyzes the problem of minimum machines and operators as a combinatorial optimization closely related to the bin packing problem (BPP), a well-known NP-hard problem involving efficiently allocating items to a finite number of bins. In our proposed model, the machines are bins containing (produce) several product types, and the operators are bins containing (operate) several machines. The bin packing problem is one of the most widely studied problems in combinatorial optimization [4] and the references there.

In this study, repetitive (cyclic) production refers to a planning framework where all product types are manufactured in repeating cycles within a fixed time horizon, such as a week or a month. Each product is produced in batches that exactly match its demand for the cycle, and the production sequence repeats identically in each cycle. This cyclic structure simplifies scheduling and capacity planning and reflects real-world industrial practices in environments with stable and recurring customer orders. Our algorithm leverages this structure to optimize resource usage efficiently.

The rest of the paper is organized as follows. Section 2 provides a literature review. Section 3 presents the proposed model. Section 4 presents a case study, and Section 5 is a summary.

2. Literature Review

The literature review covers the following topics: the bin packing problem, production machines and human involvement, production management, the economic lot scheduling problem, and repetitive production.

2.1. Bin Packing Problem

The bin packing problem (BPP) is an optimization problem aimed at determining the minimum number of containers (bins) required to pack items of different sizes, where each item has a given and fixed capacity. This problem has numerous applications, such as determining the number of containers needed for transportation, truck capacity planning, and resource management across various industries. The one-dimensional BPP is one of the most well-known problems in combinatorial optimization. Its structure and applications have been studied since the 1930s [5].

BPP is classified as an NP-hard problem, meaning no polynomial-time algorithm guarantees an optimal solution for all cases. However, BPP remains a central topic in combinatorial optimization, drawing considerable attention in recent years. Ref. [6] addressed a set of 80 instances of BPP, widely regarded as algorithmically challenging, and demonstrated that effective solutions can be obtained using advanced heuristic methods. In a related context, Ref. [7] explored the complexity of dimension reduction on the probability simplex, offering valuable insights into reducing computational overhead. This idea holds potential relevance for high-dimensional or multi-parameter variants of the BPP. Ref. [8] contributed an alternative approach by formulating a two-dimensional cutting stock problem related to BPP using the Ising model. Their work illustrates the benefits of mapping complex combinatorial problems into physical models to explore novel solution methods. Together, these studies provide a solid foundation for the present work, both from an algorithmic perspective and broader practical implications.

The problem can be extended to multiple dimensions, with the simplest and most fundamental version being the one-dimensional bin packing problem (1BPP). In this case, each item has a single size parameter, and the objective is to pack a finite set of items into the smallest possible number of bins [9].

The process begins by establishing an upper bound (U) on the required number of bins, usually obtained via a heuristic approach. This serves both as an approximation of the optimal solution and a basis for subsequent optimization. Given the computational difficulty of solving large instances exactly, heuristic methods are typically employed to generate this initial estimate [10].

According to [11], the integer linear program (ILP), given in (1), may optimally solve small BPP problems.

$$\begin{array}{l}\mathit{min} {\displaystyle \sum _{i=1}^U{y}_i}\\ s.t. {\displaystyle \sum _{j=1}^n{w}_j\times x_{i,j}}\le c\times y_i \left(i=1,2,\dots ,U\right)\\ {\displaystyle \sum _{i=1}^U{x}_{i,j}}=1 \left(j=1,2,\dots ,n\right)\\ y_i\in \left\{0,1\right\} \left(i=1,2,\dots ,U\right)\\ x_{i,j}\in \left\{0,1\right\} \left(i=1,2,\dots ,U; j=1,2,\dots ,n\right)\end{array}$$

(1)

where,

$n$—the number of items should be packed in the bins.

$W_j$—the weight (or size) of item j $\left(j=1,2,\dots ,n\right)$.

$c$—the capacity of each bin.

The constraints impose that any used bin’s capacity is not exceeded and that each item is packed into exactly one bin. The variables $\left\{x_i,y_i\right\}$ are binary decision variables that are defined as:

$$y_i=\left\{\begin{array}{c}1\\ 0\end{array}\right.\begin{array}{c} \mathrm{if} \mathrm{bin} i \mathrm{is} \mathrm{used} \mathrm{in} \mathrm{the} \mathrm{solution};\\ \mathrm{otherwise}\end{array} \left(i=1,2,\dots ,U\right)$$

$$x_{i,j}=\left\{\begin{array}{c}1\\ 0\end{array}\right.\begin{array}{c} \mathrm{if} \mathrm{item} j \mathrm{is} \mathrm{packed} \mathrm{into} \mathrm{bin} i;\\ \mathrm{otherwise}\end{array} \left(i=1,2,\dots ,U; j=1,2,\dots ,n\right)$$

The BPP is classified as NP-hard [10,11], and therefore, applying exact solution methods is generally not recommended for large instances. One can apply the first-fit-decreasing (FFD), a well-known algorithm for the bin packing problem, to calculate the initial upper bound. Its input is a sorted list of items of different sizes. Its output is a partition of the items into bins of fixed capacity. For more details about the FFD, see [12] who proved that:

$$U\le {\displaystyle \frac{11}{9}}M*+{\displaystyle \frac{6}{9}}$$

where $M*$ is the optimal minimum number of needed bins.

The bin packing problem with conflicts (BPC) is an extended version of the BPP. BPC aims to minimize the number of bins required to pack a given set of items while introducing the additional constraint that certain items cannot be placed in the same bin due to compatibility restrictions (for further details, see [13], and references therein). In our proposed model, we apply the BPP, where each production batch is treated as an “item” that needs to be processed on a machine (the bin). In the second phase, our model is formulated as a BPC, where each machine is considered an “item” to be operated by an operator (the bin), with the additional constraint that a single operator cannot manage two machines under his supervision, if the setup times required for two jobs on different machines overlap. Extensions of the classical BPP to higher dimensions were proposed by [14], who developed exact methods for two-dimensional bin packing, while [15] addressed the three-dimensional case. These models are relevant for applications involving spatial constraints in packing and loading.

Recent advances in bin packing algorithms and cyclic manufacturing systems have introduced novel approaches that improve efficiency and adaptability. Ref. [16] developed a flexible reinforced bin packing framework that incorporates automatic spacing selection. This approach uses reinforcement learning to dynamically adjust spacing variables, thereby improving the adaptability of packing strategies to dynamic environments. Ref. [17] presented a hybrid approach that combines quantum annealing and classical algorithms to solve real-world 3D bin packing problems. Their method addresses constraints such as overweight limits and item affinities and demonstrates improved performance in complex scenarios. Ref. [18] proposed a virtual force-based swarm algorithm to address balanced circular bin packing problems. Their method aims to minimize the radius of circular containers while satisfying equilibrium constraints and offers a novel solution for applications requiring balanced packing. Ref. [19] studied the problem of basket packing under uncertainty by presenting scenarios. They proposed approximation algorithms and heuristics to efficiently handle changing conditions, contributing to the robustness of basket packing solutions in uncertain environments. Ref. [20] presented a pattern-based learning approach to optimize online basket packing problems. Their method emphasizes the reuse of efficient patterns under changing conditions, thereby improving the efficiency of online basket packing algorithms.

2.2. Production Machines and Human Involvement

Modern manufacturing systems integrate advanced technologies, automation, and data-driven methodologies to create adaptable, efficient, and responsive production processes. This approach emphasizes the critical role of human involvement, fostering synergy between human operators and machines [21,22]. While automated reconfiguration is essential for quickly responding to changes, certain adjustments still require human input in collaboration with computerized systems. Despite advancements in Industry 4.0, many production environments still require human oversight and intervention, particularly for reconfiguration, maintenance, and setup tasks [23].

Integrating machines and human labor is fundamental to modern manufacturing, influencing the production of diverse products across various industries. Manufacturing processes increasingly rely on machines to improve efficiency, precision, and speed. As technology progresses, the roles of machines and human workers evolve, highlighting the importance of their collaboration in achieving optimal outcomes. Numerous studies have explored the integration of machines and human labor in manufacturing. For instance, ref. [23] examined human-robot collaboration in industrial environments, focusing on safety, interaction, and trust. Similarly, ref. [24] analyzed the impact of the Fourth Industrial Revolution on productivity and growth in manufacturing, particularly integrating intelligent machines with human workers.

While automated production lines reduce reliance on manual labor, hybrid systems where operators manage multiple machines remain prevalent in textiles, automotive, and semiconductor manufacturing industries. Machines like injection molding equipment, CNC tools, and automated packaging systems enhance productivity but require periodic human intervention. Studies have emphasized optimizing the interaction between machines and human workers for maximum efficiency [24].

Recent studies have further enriched the literature on production and scheduling optimization, especially in the context of Industry 4.0. Ref. [25] conducted a comprehensive review of simulation optimization applied to production scheduling, outlining its potential to improve responsiveness and decision-making in dynamic industrial environments. Ref. [26] reviewed learning-based optimization in smart manufacturing systems, focusing on AI-driven strategies for scheduling, maintenance, and quality control. These contributions reinforce the significance of intelligent and adaptive planning tools and complement the current study’s emphasis on cyclic, resource-constrained scheduling in modern production systems.

2.3. Production Management

Production management plays an increasingly important role in modern industry. A key aspect of production management is determining the optimal number of machines and operators needed to meet the total demand for various products in a [27]. According to [28], researchers have long sought to solve the challenge of determining the optimal number of products to produce using a shared resource (machine) with limited capacity.

A central model in this area is the economic production quantity (EPQ) model, introduced by [29]. This model uses one machine to determine the optimal production quantity for a single product. Over time, the EPQ model has been adapted to handle more complex situations. For instance, ref. [30] extended the EPQ model to account for fluctuating demand over time rather than assuming a constant demand. Refs. [31,32] presented multi-product economic order quantity (EOQ) inventory models for reusable items, incorporating real-world constraints such as budget, warehouse space, and holding costs. These studies also provide a comprehensive review of extensions to the EOQ and EPQ models.

A particularly important extension is the economic lot scheduling problem (ELSP), which addresses the scheduling of multiple product types on a single machine while minimizing total costs, including setup and inventory holding costs [33]. This problem highlights trade-offs between production sequencing and inventory management and emphasizes the need for intelligent scheduling strategies [34,35]. Several studies have extended EPQ to tackle ELSP, focusing on lot size determination and production scheduling to reduce costs and avoid overlapping [28]. However, as noted by Rossi et al. (2017) [28], many of these models lack explicit consideration of scheduling complexities, such as sequence-dependent setups or workforce allocation.

To address these complexities, recent works have incorporated labor constraints and physical layout considerations. For example, ref. [36] proposed a mixed-integer linear programming (MILP) model for lot-sizing and scheduling using reconfigurable machine tools (RMTs), accounting for manpower limitations. Ref. [37], as well as [38], showed that limited labor availability could significantly affect scheduling efficiency. Ref. [3] further developed a scheduling model that integrates the physical distance between workers on parallel machines, aiming to maximize workforce utility while maintaining safety and productivity.

Overall, ELSP remains a foundational framework in production management, continuously evolving to reflect the real-world constraints of modern manufacturing systems, including multi-product environments, human resource limitations, and dynamic production demands.

2.4. Repetitive and Cyclic Production

The repetitive production of multiple product types on one or more machines is a critical component of modern manufacturing systems. A central challenge in such environments is determining the optimal number of machines and workers while scheduling production sequences to minimize costs and maximize efficiency. Ref. [39] survey the computational complexity of cyclic scheduling problems, highlighting their NP-hard nature, especially in robotic cell scheduling. They emphasize the challenges in finding optimal solutions and the need for heuristic approaches. These insights support our study, which tackles cyclic scheduling by optimizing resource allocation and minimizing the number of machines and operators. Ref. [40] focus on cyclic scheduling in discrete, repetitive manufacturing systems, blocking tasks without intermediate buffers between machines. They propose a mixed-integer programming model incorporating sequence-dependent setups and show how blocking conditions significantly impact optimal schedules. Their model effectively addresses small to medium-sized problems, highlighting key real-world scheduling constraints.

The complexity of scheduling repetitive production increases when a finite number of workers operate the machines, requiring efficient coordination between machine usage and labor allocation. Several studies have developed models that integrate these aspects to improve production planning. For instance, ref. [41] proposed a mixed-integer linear programming (MILP) model to optimize scheduling in multi-product, multi-machine environments while accounting for labor constraints. Their approach significantly improved production efficiency and resource utilization. Similarly, ref. [42] introduced a hybrid scheduling method that combines genetic algorithms with simulation techniques to manage the complexity of multi-product, multi-machine manufacturing systems. Refs. [43,44] extended this approach by developing a multi-objective scheduling method for distributed and flexible job shop scheduling problems, further enhancing efficiency under dynamic production conditions. Ref. [42] proposed a multi-objective particle swarm optimization approach for solving mixed no-idle, flow-shop scheduling problems, offering improved performance in complex manufacturing settings. These studies collectively emphasize the significance of heuristic algorithms, hybrid methods, and advanced scheduling models in optimizing production processes, particularly in environments with multiple machines, labor constraints, and dynamic demand patterns.

The role of labor in ELSP-based scheduling has been widely studied. Ref. [38] extended the ELSP framework to account for labor constraints, demonstrating that optimal scheduling depends not only on lot sizes but also on worker allocation and workload distribution. Ref. [37] further integrated job scheduling with machine allocation to improve labor efficiency while maintaining stable cyclical production. Research on cyclical manufacturing has underscored the need to synchronize production scheduling with workforce availability. Ref. [45] emphasized the importance of aligning production sequences with worker shift patterns, fatigue levels, and machine configuration requirements. Advanced methodologies, including mixed-integer programming and heuristic algorithms, continue to refine scheduling models by incorporating both machine and labor constraints, further optimizing production efficiency.

Recent literature continues to broaden the understanding of production management by incorporating modern priorities such as sustainability, digital integration, and smart planning. Ref. [46] offer a systematic literature review on advanced manufacturing management, emphasizing the integration of innovative technologies to improve production efficiency and adaptability. Ref. [47] focuses on the integration of production planning and scheduling under Industry 4.0, presenting how machine learning and analytics can enhance real-time responsiveness and operational control. Additionally, ref. [48] highlight the importance of sustainable entrepreneurship and the development of relevant performance metrics for managing manufacturing systems, aiming to balance environmental, social, and economic goals. These recent contributions complement the current study by emphasizing the need for flexibility, sustainability, and intelligent resource allocation in contemporary production environments.

3. The Proposed Algorithm

We aim to determine the minimum number of machines needed to fulfil production needs and the minimum number of operators required to perform the machines’ setup. We deal with a production problem with n different product types, all of which must be produced in every cycle. The products can be manufactured using the same type of machines, subject to the availability of the machines. Upon completing the production of one product, the machine requires an operator to set it up to produce a different product.

The proposed algorithm for a solution consists of two stages:

Stage 1: Determine the minimum number of machines needed to fulfill the production needs and the production schedule of the products on each machine.

Stage 2: Determine the minimum number of operators required to perform the machines’ setups as determined in Stage 1.

3.1. Assumptions

• Shortage is prohibited. All the required demands must be met.
• The machines are identical. Each machine can produce all product types but can handle only one at a time.
• The setup times are identical and fixed and do not depend on the schedule of the product or the machine. During setup, the machine is idle.
• Each product’s production rate (machine time) is continuously fixed. Each product may have a different production rate.
• The demand rate is constant, continuous, and known.
• A machine can produce the required demand of any product type in one cycle. In other words, the production rate of one machine is higher than the demand rate for each product type.
• The production plan is continuous and cyclic for a period (month, quarter, etc.). The batch size of one product in each cycle is identical to its demand.
• One machine produces all the units to be supplied of the same product type without splitting production between several machines.

3.2. Notations

$n$—the number of product types.

$M$—the number of machines required to meet the demands of the $n$ product types.

$O$—number of operators required to operate the $M$ machines.

${\psi }_j$—the periodical production rate of product $j \left(j=1,2,\dots ,n\right)$ on any machine.

${\lambda }_j$—the periodical demand rate for product $j \left(j=1,2,\dots ,n\right)$. According to our assumptions, ${\psi }_j>{\lambda }_j.$

$T_{{\psi }_j}$—the production time for producing of product $j$ in one cycle.

$T_{{\lambda }_j}$—the time in one cycle that the machine produces other products (and does not produce products $j$) or is idle.

$T_{S_j}$—the setup time for producing products $j$. According to our assumptions, the setup times are identical and fixed and do not depend on the schedule.

$Q_j$—the batch size of product $j$ produced in each cycle (equal to demand for product $j$. In other words, $Q_j={\lambda }_j$).

$T_j$—the cycle time of product $j$ $\left(T_j=T_{{\psi }_j}+T_{{\lambda }_j}\right)$. The cycle time is equal to 1 for each product $j$.

$M^{*}$— the optimal (minimum) number of machines required to meet the demands of the $n$ product types.

$C$—the number of machines that is determined by a heuristic method, which is a “good” feasible solution to $M^{*}$, $C\ge M^{*}.$

3.3. Economic Production Quantity

A system in which a product is manufactured on a machine while simultaneously consumed during production can be modeled by the economic production quantity (EPQ) model, initially developed by [40]. However, we adjust the EPQ model to a case where, for each product type $j \left(j=1,2,\dots ,n\right) ,$ the quantity produced in a cycle is identical to the demand for that specific product type $\left(Q_j={\lambda }_j\right)$, meaning the production cycle time is 1 for each product type $T_j=1 \forall j$. Our model defines a production cycle as a fixed-length period (e.g., one month or one quarter) during which all product types must be produced precisely once to satisfy their demand. The term cycle refers to this recurring, standardized interval. For simplicity and normalization purposes, we assume that the cycle time is set to 1, meaning that each machine’s total available production time during a cycle is treated as a one-time unit. Each product’s production and setup times are then expressed as fractions of this unit. This convention allows us to model the machines as bins of capacity one in the bin packing formulation. Figure 1 illustrates how this cycle-based production framework governs inventory levels and production timing. This adjustment allowed us to calculate the production time $\left(T_{\psi j}\right)$ and the idle time when the machine is neither producing the product nor being set up for it $\left(1-T_{\psi j}-T_S\right)$. The idle time can be used to produce other products on the same machine if the available time is sufficient to produce a quantity sufficient for a complete cycle of different products (this and additional constraints will be detailed later). Figure 1 illustrates the EPQ model for a single product type under a cycle time of 1.

Since the production is continuous and cyclic, and due to the special form of the problem as formulated, several products $\left(n_i\right)$ can be assigned to one machine, denoted $i$, as long as the following condition is fulfilled: ${\displaystyle \sum _{j=1}^{n_i}\left(T_{\psi j}+T_S\right)}\le 1$.

3.4. Model Development for the Number of Machines Needed

For any product, the batch size must be sufficient for the entire cycle period (e.g., month, quarter, etc.). Therefore, the cycle time for each product type can be set as 1, and each product has only one setup $\left(T_S\right)$ in every production cycle. The time that a machine is busy setting up and producing the product type $j$ in one cycle is (2):

$$\left(T_S+{\displaystyle \frac{{\lambda }_j}{{\psi }_j}}\right)$$

(2)

The total time needed for producing all the n types of products is (3):

$${\displaystyle \sum _{j=1}^n\frac{{\lambda }_j}{{\psi }_j}}+n\times T_s$$

(3)

Therefore, the minimum number of machines required to theoretically meet the production plan (lower bound-LB) in one period is (4):

$$L{B}_M={\left[{\displaystyle \sum _{j=1}^n\frac{{\lambda }_j}{{\psi }_j}}+n\times T_s\right]}^{+}\le M\le n$$

(4)

The upper bound (UB) for the number of machines is the number of product types (each produces one product type). Therefore, the number of machines M is in the range: $L{B}_M\le M\le n.$

This problem of minimizing the number of machines required to produce n products is a special case of the BPP and the cyclic scheduling problem. In this context, each machine can be viewed as a circular “container” with a perimeter (capacity) of 1, and each product represents an “item” that must be placed in one container (produced by one machine). Since the problem is continuous and the cycle time for all products is 1, we can model the task of determining the minimum number of machines equivalent to solving a BPP. In this model, each machine is a “container” with a maximum capacity of 1, and the production time of each product, including the required setup time, represents an “item” to be packed into these containers. The goal is to allocate each product + setup time to a minimum number of machines so that the total time assigned to any single machine does not exceed its capacity within each cycle. As mentioned, the BPP is classified as NP-HARD, meaning no efficient algorithm exists to solve it. However, many heuristic algorithms exist to provide approximate solutions. For relatively small instances of the BPP, it can be solved optimally by formulating it as a binary linear programming problem. To obtain an optimal solution, we formulate an Integer Linear Programming (ILP) model that represents our adapted version of the bin packing problem. This formulation is presented later as Equation (5).

The first step for optimization of (1) is to find a “good” feasible solution for the number of machines C, commonly by a heuristic method. This ensures that a feasible solution exists, even if it is not optimal. One can apply the First-fit-decreasing (FFD), a well-known algorithm for the bin packing problem, to calculate the initial C. Its input is a sorted list of items of different sizes, where the biggest is the first. Its output is a partition of the items into bins of fixed capacity. For more details about the FFD see [12], who proved that $C\le {\displaystyle \frac{11}{9}}M*+{\displaystyle \frac{6}{9}}$. Therefore, one can set $C$ as an upper bound in the linear programming formulation (1). If the result of the FFD is $C=L{B}_M$, then $M*=C$ and the linear programming of (1) is not needed.

Applying the FFD algorithm, in our case, needs the following steps:

Step 1: Rank the product types $(j=1,\dots ,n)$ in descending order according to (2).

Step 2: Assign the product type ranked first to the first machine.

Step 3: Try to assign the product type ranked second to the first machine. If it cannot be assigned to the first machine due to a lack of capacity (the setup time + the processing time of the first product type and the setup time + the processing time of the second product type is more than 1), then assign this product type to the next machine.

Step 4: Do step 3, with the necessary adjustments, until all the product types have been assigned to a machine.

The number of machines needed to assign all the product types according to this algorithm is C, which is used as an upper bound to a linear integer programming problem (5) that yields the optimal number of machines. If C equals the lower bound $C=\left(L{B}_M\right)$, then C and the product type assignment on the machines are an optimal solution.

The linear integer programming problem formulation is:

$$\begin{array}{l}Min M={\displaystyle \sum _{i=1}^C{y}_i}\\ s.t. {\displaystyle \sum _{j=1}^n\left(T_s+\frac{{\lambda }_j}{{\psi }_j}\right)\times x_{1,j}}\le y_1\\ {\displaystyle \sum _{j=1}^n\left(T_s+\frac{{\lambda }_j}{{\psi }_j}\right)\times x_{2,j}}\le y_2\\ \dots \\ {\displaystyle \sum _{j=1}^n\left(T_s+\frac{{\lambda }_j}{{\psi }_j}\right)\times x_{C,j}}\le y_C\\ {\displaystyle \sum _{i=1}^C{x}_{i,1}}=1\\ {\displaystyle \sum _{i=1}^C{x}_{i,2}}=1\\ \dots \\ {\displaystyle \sum _{i=1}^C{x}_{i,n}}=1\\ y_i\in \left\{0,1\right\} \left(i=1,2,\dots ,C\right)\\ x_{i,j}\in \left\{0,1\right\} \left(i=1,2,\dots ,C; j=1,2,\dots ,n\right)\end{array}$$

(5)

where,

$$y_i=\left\{\begin{array}{c}1\\ 0\end{array}\right.\begin{array}{c} \mathrm{if} \mathrm{machine} i \mathrm{is} \mathrm{used} \mathrm{in} \mathrm{the} \mathrm{solution};\\ \mathrm{otherwise}\end{array} \left(i=1,2,\dots ,C\right)$$

$$x_{i,j}=\left\{\begin{array}{c}1\\ 0\end{array}\right.\begin{array}{c} \mathrm{If} \mathrm{product} \mathrm{type} j \mathrm{is} \mathrm{assigned} \mathrm{to} \mathrm{machine} i;\\ \mathrm{otherwise}\end{array} \left(i=1,2,\dots ,C; j=1,2,\dots ,n\right)$$

The number of binary variables in (2) is $C\left(n+1\right)$. The output of (5) is the number of machines needed and a partition of the product types among the machines.

A flow diagram of Stage 1 of the algorithm, the minimum number of needed machines, is illustrated in Figure 2.

Our modeling is unique because our container (the machine) is designed like a circle. As a result, the cycle time of all products is 1, even though their production occurs sequentially, one product after another. Figure 3 illustrates a situation where two products are produced on a single machine. The setup time for each product is $T_s=0.330,$ out of the total cycle time of 1, and the production time for each product is $T_{\psi j}=0.167 j=1,2$. On the second machine, a different product is produced, with the same setup time $T_s=0.330,$ but the production time is $T_{\psi j}=0.670 j=3$. Figure 3 presents a possible partition of three product types between two machines and conveys the concept that each machine functions as a circular container.

3.5. The Number of Needed Operators

The number of operators can be $O=M$ (M obtained in the previous section) if a single operator is assigned to each machine. But, if a single operator can perform all the setups for all the M machines and meet the production plan, then O = 1. Therefore, the number of workers is in the range $1\le O\le M$.

Determining the minimum number of operators required to operate M machines, as established in the previous step (including the internal scheduling in each machine), can also be modeled as a special case of the bin packing problem. In this scenario, each machine functions as a different “item” to be packed, while each operator serves as a “container”. Even though the machines are identical, since each machine has been assigned several different types of products, the machines can be considered as not identical “items.”

For a single operator to effectively operate multiple machines, two critical conditions must be fulfilled:

(1)

The cumulative setup time across all his/her assigned machines must be 1 or less than 1.

(2)

Under a single operator’s responsibility, no two setup operations occur simultaneously on any machine.

Consequently, this special case of the bin packing problem evolves into a conflict-based problem, necessitating a more complex approach than standard bin-packing algorithms. This variant accounts for both capacity constraints (total setup time) and scheduling conflicts (simultaneous setups), adding complexity to the optimization process.

The problem where a single operator must operate several machines is the machine interference problem (see, for example, [1]). In our case, machine interference is forbidden. Here are some claims to demonstrate the problem of assigning several machines to a single operator without interference.

Claim 1. 

If the cumulative setup time across all the assigned machines is 1 or less, and only one product is produced on each machine, then a single operator can operate up to ${⌊{\displaystyle \frac{1}{T_S}}⌋}^{-}$machines without overlap. Therefore, if there are M machines, each produces only one product, then a single operator will operate $\mathit{min}\left\{{⌊{\displaystyle \frac{1}{T_S}}⌋}^{-},M\right\}$ machines.

Proof. 

There is a simple way to schedule the M setups without overlap. Since the cycle time with the setup is 1 for all product types, and each cycle on each machine is represented by a circle with a perimeter of 1, the setup for the first machine can be completed, and then immediately the setup for the second machine can be performed, and so on, without any overlap. Since each machine requires only one setup and the total setup time across all machines does not exceed 1, the cycles can be scheduled across all machines without conflicts in setup timing. □

Claim 2. 

Even in a situation with two machines, with two products on one machine and one product on the other, and the necessary condition is met, a single operator will not necessarily be able to operate both machines due to overlapping setup times.

Proof. 

Here is an example of such a situation. Three products must be produced on two machines, where each product needs $T_S=0.33$ for setup. The total setup of the two machines is $3T_S=3\times 0.33=0.99<1$, so the first condition that a single operator can operate these two machines is fulfilled. Moreover, the production time of the two products on the first machine are $T_{\psi ,1}=T_{\psi ,2}=0.167$ and the production time of the product on the second machine is $T_{\psi ,3}=0.670$. This example is illustrated in Figure 3, and it is easy to verify that there is no continuous range on machine 1 with a length of at least 0.330 that enables scheduling the setup of the second machine without setup overlapping. □

3.6. A Heuristic Algorithm for the Assignment of Machines to Operators

The term $i$ is an index of the machines $i=1,2,\dots ,M$ and $n_i$ is the number of the product types that were assigned to machine $i$ in the previous section.

Step 1: Calculate the value $n_i\times T_S$ for each machine. This is the total time that machine $i$ needs an operator for setup. Since the cycle time is 1, $n_i\times T_S$ it is also the load caused by machine $i$ on the operator.

Step 2: Rank the M machines according to $n_i\times T_S$ in ascending order. This ranking facilitates assigning more machines to a single operator, assuming a machine that causes a low load is more likely to be adopted by the current operators.

Step 3: Assign the machine that was first ranked to Operator 1. Check if the machine ranked second can also be assigned to Operator 1. If yes, assign this machine to Operator 1; if no, assign this machine to Operator 2.

Step 4: Check if the machine that ranked third can be assigned to Operator 1. If so, assign it to Operator 1 and proceed to assign the next machine. If no, check if it can be assigned to Operator 2; if so, assign it to Operator 2; if not, add an additional operator and assign this machine to a new operator. The procedure for checking whether a single operator can operate a specific group of machines will be presented in the next paragraph.

Step 5: Repeat the process until all the machines have been assigned to an operator. At the end of this step, we get the number of operators and a partition of the M machines among the operators.

Checking whether a single operator can operate a specific group of machines G $\left(G\subset M\right)$ should be done in the following two steps:

(1)

The initial and simplest examination is to assess whether an additional machine can be assigned to group G by verifying that the necessary condition is met—specifically, that the total load does not exceed 1, $T_S{\displaystyle \sum _{i\in G}{n}_i}\le 1$.

(2)

If the first condition is fulfilled, we propose a mathematical programming formulation (6) to examine whether the addition of another machine to an operator is feasible without setup overlap.

The machine assignment procedure described in Section 3.4 determined the required number of machines and the internal production schedule for each machine. Based on this assignment, the following additional data can be derived:

$\left[i,j\right]$—the scheduling of the product that was ranked $[j]$ on machine $i.$

$a_{i,\left[j\right]}$—the start time of the setup of the product that was scheduled $\left[j\right]$ on a machine $i.$

$b_{i,\left[j\right]}$—the completion time of the setup of the product that was scheduled $\left[j\right]$ on a machine $i,$ where $b_{i,\left[j\right]}=a_{i,\left[j\right]}+T_S.$

The values of $a_{i,\left[j\right]}$ and $b_{i,\left[j\right]}$ are computed such:

The setup timing of the product that ranked first on machine $i$ is $a_{i,\left[1\right]}=0$ and $b_{i,\left[1\right]}=T_S.$ The setup timing of the second ranked product is $a_{i,\left[2\right]}=T_S+T_{\psi ,\left[1\right]}$ and $b_{i,\left[2\right]}=2T_S+T_{\psi ,\left[1\right]}.$ Similarly, $a_{i,\left[j\right]}$ and $b_{i,\left[j\right]}$ for $\forall i,j$ can be calculated.

To enable a single operator to run multiple machines, ensuring no overlap in the operator’s setup time on two machines (machine interference) is essential. One way to check if overlap can be avoided is to examine whether it is possible to rotate the cycle of the machines like rings. Define:

${\theta }_i$—a decision variable that represents the rotation angle of the cycle on machine $i$, with the aim of preventing overlap among setups on several machines, $0\le {\theta }_i<1 i=1,2,\dots ,M.$

When the cycle on machine $i$ is rotated by ${\theta }_i$, the setup timing is also rotated by ${\theta }_i$ according to the following formulas: $a_{i,\left[j\right]}^{\prime }=\left(a_{i,\left[j\right]}+{\theta }_i\right)\mathit{mod}1$ and $b_{i,\left[j\right]}^{\prime }=\left(b_{i,\left[j\right]}+{\theta }_i\right)\mathit{mod}1 i=1,2,\left[j\right]\in i,$ where mod 1 denotes the fractional part obtained from division by 1.

Here is the mathematical formulation of the problem, considering G is a subgroup of the M machines $\left(G\subset M\right)$, where the cycle of each machine $i$ contains $n_i$ setup segments that may need rotation to avoid overlap:

$$\mathit{min}{\displaystyle \sum _{i\in G}{\theta }_i}$$

(6)

For any segments, $(i,j)$ on machine $i\in G,$ use the parameter $a_{i,j}$ $i\in G, j=1,\dots ,n_i$ to calculate:

$$\begin{array}{l}{b}_{i,j}=\left(a_{i,j}+TS\right)Mod1 \\ {a^{\prime }}_{i,j}=\left(a_{i,j}+{\theta }_i\right)Mod1\\ {b^{\prime }}_{i,j}=\left(b_{i,j}+{\theta }_i\right)Mod1 \end{array}$$

For any two segments, $(i,j)$ on machine $i$ and $(k,l)$ on machine $k,$ $i,k\in G,$ the non-overlap constraints are:

$$\begin{array}{l}\left({b^{\prime }}_{i,j}-{a^{\prime }}_{k,l}\right)Mod1\le 1-Ts\\ \left({a^{\prime }}_{i,j}-{b^{\prime }}_{k,l}\right)Mod1\le 1-Ts\\ \left({b^{\prime }}_{k,l}-{a^{\prime }}_{i,j}\right)Mod1\le 1-Ts\\ \left({a^{\prime }}_{k,l}-{b^{\prime }}_{i,j}\right)Mod1\le 1-Ts\end{array}$$

The rotation ${\theta }_i$ is a real value between 0 and 1.

$$0\le {\theta }_i\le 1 i=1,\dots M, i\in G.$$

End.

If the mathematical programming problem has a feasible solution, a single operator can operate the group of G machines that were examined. If that mathematical programming problem is not feasible, a single operator cannot operate G due to setup overlap. At the end of the process, we get a partition of the M machines among operators.

A flow diagram of Stage 2 of the algorithm, the minimum number of operators required, is illustrated in Figure 4.

3.7. Theoretical Justification and Computational Efficiency

Given that the real-world case analyzed in this study involves a relatively small instance (17 product types) and that the solution obtained is optimal, we assess the effectiveness of the proposed algorithm through analytical means, focusing on performance and computational complexity.

The first stage, which determines the minimum number of machines, begins with the heuristic FFD, which runs in $O(n\log n)$ time and has a well-established performance bound. In our case study, the result obtained by FFD matched the theoretical lower bound, thus proving optimality. In general, if the FFD result does not match the lower bound, an integer linear programming (ILP) model may be used to verify optimality. However, since the BPP is NP-hard, solving its ILP formulation can require exponential time in the worst case and may become computationally impractical for larger instances. In such cases, the FFD solution offers a fast, effective, and practical approximation.

The second stage, which assigns machines to operators while avoiding overlapping setup intervals, is also NP-hard in the general case. The assignment process involves evaluating, for each of the M machines, whether it can be added to one of the existing operator groups without conflicts. This is done by first checking a simple capacity condition and, when needed, solving a small ILP with cyclic non-overlap constraints. In the worst case, up to M ILP problems of size $O(K^2\cdot G^2)$ may be solved for each machine (where K is the number of setups per machine and $G\le M$ is the size of the operator group), resulting in an overall complexity of $O(K^2\cdot G^2)$. Nevertheless, since most assignments are rejected early via simple feasibility checks and the ILPs involve small groups (typically three to five machines per operator), the algorithm performs efficiently in practice. Suppose an ILP instance fails to solve or becomes too time-consuming. In that case, the algorithm can fall back to the heuristic assignment by simply allocating the machine to the next operator, ensuring progress and maintaining low computational overhead.

Combining both stages, the overall computational complexity of this heuristic algorithm is: $O(n\log n)+O(K^2\cdot G^2)$. This hybrid approach balances optimality, feasibility, and runtime performance. It is particularly well-suited for real-world manufacturing environments and can be extended in future work to incorporate larger instances or alternative solution techniques.

Although no formal benchmarking has been conducted against metaheuristics in this study, the presented algorithm demonstrates practical efficiency in the real-world case examined. Future research will explore systematic performance comparisons with established heuristics and metaheuristics.

4. A Real Case Study

A factory continuously produces 17 product types $\left(j=1,2,\dots ,17\right)$. The demand for each product is continuous, and the production is made in batches. The setup time for each product is $T{S}_j=0.0288 \mathrm{months}, \forall j=1,2,\dots ,17$ (about 5.76 h). The setup time is fixed for each type of product and does not depend on the production schedule.

The monthly production rate for each type of product manufactured ${\psi }_j, j=1,2,\dots ,17$ was calculated by dividing the number of working hours per machine in 1 cycle (200 working hours in 1 month) by the production time needed to produce one unit in hours, obtained by work-study methods. The demand rate monthly for each type of product ${\lambda }_j$ is determined by long-range customers’ orders.

Table 1. Demand and production rate for 17 product types and ranking.

	Demand Rate	Production Rate	Setup time	Production Time in Months	Ranking Criterion	Ranking
$j$	${\lambda }_j$	${\psi }_j$	$T{S}_j$	$T{\psi }_j$	$\left(T_s+{\displaystyle \frac{{\lambda }_j}{{\psi }_j}}\right)$	$R_J$
1	2265	5824	0.0288	0.3889	0.4177	3
2	1851	5358	0.0288	0.3454	0.3742	5
3	766	7814	0.0288	0.0980	0.1268	14
4	2165	6467	0.0288	0.3347	0.3635	6
5	3499	7624	0.0288	0.4590	0.4878	1
6	1974	7880	0.0288	0.2506	0.2794	8
7	1524	5824	0.0288	0.2616	0.2904	7
8	2702	6252	0.0288	0.4321	0.4609	2
9	2616	7269	0.0288	0.3598	0.3886	4
10	366	5753	0.0288	0.0637	0.0925	17
11	1092	5262	0.0288	0.2076	0.2364	10
12	572	6698	0.0288	0.0854	0.1142	15
13	936	7099	0.0288	0.1318	0.1606	12
14	1014	4951	0.0288	0.2049	0.2337	11
15	1265	5402	0.0288	0.2341	0.2629	9
16	368	5110	0.0288	0.0721	0.1009	16
17	624	5417	0.0288	0.1151	0.1439	13

presents the monthly production rate and the monthly demand rate for each of the 17 types of products that should be produced. The monthly production time required to produce a batch of each type of product is $T{\psi }_j={\displaystyle \frac{Q_j}{{\psi }_j}}$ (see Figure 1). In our case, $Q_j={\lambda }_j$, so $T{\psi }_j={\displaystyle \frac{{\lambda }_j}{{\psi }_j}}$.

4.1. The Number of Needed Machines

The first step in our model is to calculate the number of machines needed to produce these 17 product types. As proposed, applying the FFD algorithm needs the following steps:

Step 1: Rank the product types in descending order according to (2). The ranking criterion and the ranking are given in Table 1.

Step 2: Assign the product type that is ranked first to the first machine. In our case, product $j=5$ that was ranked first was assigned to machine 1, see Table 2.

Step 3: Try to assign the product type that is ranked second to the first machine. In our case, product $j=8$ that was ranked second can also be assigned to machine 1, $\left(\left(T_s+{\displaystyle \frac{{\lambda }_5}{{\psi }_5}}\right)+\left(T_s+{\displaystyle \frac{{\lambda }_8}{{\psi }_8}}\right)=0.4878+0.4609=0.9487<1\right)$, see Table 2.

Step 4: Do step 3, with the necessary adjustments, until all the product types have been assigned to any machine. Similarly, all the product types were assigned, see Table 2.

Table 2. Assignment of the 17 product types among the machines.

Products	Ranking Criterion	Ranking	M1	M2	M3	M4	M5
$j$	$\left(T_s+{\displaystyle \frac{{\lambda }_j}{{\psi }_j}}\right)$	$R_j$	$i=1$	$i=2$	$i=3$	$i=4$	$i=5$
1	0.4177	3		0.4177
2	0.3742	5			0.3742
3	0.1268	14					0.1268
4	0.3635	6			0.3635
5	0.4878	1	0.4878
6	0.2794	8				0.2794
7	0.2904	7				0.2904
8	0.4609	2	0.4609
9	0.3886	4		0.3886
10	0.0925	17					0.0925
11	0.2364	10			0.2364
12	0.1142	15					0.1142
13	0.1606	12		0.1606
14	0.2337	11					0.2337
15	0.2629	9				0.2629
16	0.1009	16					0.1009
17	0.1439	13				0.1439
SUM	4.5344		0.9487	0.9670	0.9741	0.9766	0.6681
$n_i$			2	3	3	4	5
$n_i\times T_s$			0.0576	0.0864	0.0864	0.1152	0.1440
Ranking			1	2	2	4	5

Table 2. Assignment of the 17 product types among the machines.

Products	Ranking Criterion	Ranking	M1	M2	M3	M4	M5
$j$	$\left(T_s+{\displaystyle \frac{{\lambda }_j}{{\psi }_j}}\right)$	$R_j$	$i=1$	$i=2$	$i=3$	$i=4$	$i=5$
1	0.4177	3		0.4177
2	0.3742	5			0.3742
3	0.1268	14					0.1268
4	0.3635	6			0.3635
5	0.4878	1	0.4878
6	0.2794	8				0.2794
7	0.2904	7				0.2904
8	0.4609	2	0.4609
9	0.3886	4		0.3886
10	0.0925	17					0.0925
11	0.2364	10			0.2364
12	0.1142	15					0.1142
13	0.1606	12		0.1606
14	0.2337	11					0.2337
15	0.2629	9				0.2629
16	0.1009	16					0.1009
17	0.1439	13				0.1439
SUM	4.5344		0.9487	0.9670	0.9741	0.9766	0.6681
$n_i$			2	3	3	4	5
$n_i\times T_s$			0.0576	0.0864	0.0864	0.1152	0.1440
Ranking			1	2	2	4	5

In our case, the lower bound of the number of machines needed is: $LB={\left[{\displaystyle \sum _{j=1}^{17}\left(T_s+\frac{{\lambda }_j}{{\psi }_j}\right)}\right]}^{+}={\left[4.5344\right]}^{+}=5$. Therefore, our heuristic solution that gives 5 machines is also optimal. i.e., $M^{*}=5$. The internal order of the product type on each machine is preserved to the next step.

4.2. The Number of Needed Operators

We applied the allocation procedure described in Section 3.5 to determine the number of operators needed. The load imposed by each machine on an operator was calculated as the product of the number of product types assigned to the machine and the fixed setup time per product. These values, representing the total setup time per machine, are presented in Table 2 and were used to guide the machine-to-operator assignment.

The feasibility of assigning multiple machines to a single operator was evaluated in two steps:

(1) Verifying that the total load for a group of machines does not exceed one unit.

(2) Applying the mathematical programming model (5) to ensure that the sequence of setup and production times across machines does not result in time conflicts (machine interference).

Our analysis indicates that machines 1 through 4 can be assigned to a single operator without violating the total load or setup-time overlap constraints. However, machine 5 must be assigned to a second operator. The mathematical model (5) failed to yield a feasible solution when all five machines were assigned to one operator. Therefore, the result of our algorithm is a solution that requires two operators.

Specifically, Operator 1 is assigned to machines 1–4, and Operator 2 is assigned to machine 5. We note that this solution is not necessarily optimal and is not balanced between the two operators. The heuristic algorithm does not explore all possible assignments; it maintains the original production sequence and does not permit reallocation of slot times to minimize the number of operators further. In addition, the algorithm preserves all idle times at the end of the cycle rather than distributing them throughout the schedule, which may further limit optimization.

The assignments are illustrated in Figure 5 and Figure 6 and summarized in

Table 3. The production plan.

Operator 1					Operator 2
$i$	$j$	$a_{ij}$	$b_{ij}$	$b_{ij}+T{\psi }_j$	$i$	$j$	$a_{ij}$	$b_{ij}$	$b_{ij}+T{\psi }_j$
1	5	0.0000	0.0288	0.4878	5	14	0.0000	0.0288	0.2337
	8	0.4878	0.5166	0.9487		3	0.2337	0.2625	0.3605
2	1	0.0288	0.0576	0.4465		12	0.3605	0.3893	0.4747
	9	0.4465	0.4753	0.8351		16	0.4747	0.5035	0.5756
	13	0.8351	0.8639	0.9957		10	0.5756	0.6044	0.6681
3	2	0.1520	0.1808	0.5262
	4	0.5262	0.5550	0.8897
	11	0.8897	0.9185	1.1261
4	7	0.0861	0.1149	0.3765
	6	0.3765	0.4053	0.6559
	15	0.6559	0.6847	0.9188
	17	0.9188	0.9476	1.0627

. These figures confirm the result obtained via mathematical programming: machines 1–4 can be managed by a single operator without overlapping setup times, but adding machine 5 would violate the non-overlap constraint. The doughnut diagram (Figure 6) illustrates that machine 5’s setup intervals conflict with those of machines 1–4. Thus, a second operator is required.

Table 3 presents the allocation of products to machines and machines to operators, along with the start and end times of each product’s production during a single cycle. Figure 5 provides a Gantt chart illustrating the production schedule for a representative cycle assigned to the first operator. It shows no overlapping setup times for the twelve products produced on these four machines. The schedule in Figure 5 can be directly translated into an operational timeline for the operator: starting with the setup of product 2 on machine 3, followed, after 0.1957 of the cycle, by the setup of product 6 on machine 4, and so forth.

The machine utilization rates (excluding setup times) are as follows:

$${\mu }_1=89.11\%, {\mu }_2=88.05\%, {\mu }_3=88.77\%, {\mu }_4=86.14\%, {\mu }_4=52.41\%.$$

The operators’ workload is:

$$B_1=12\times 0.0288\times 100=34.56\%, B_2=5\times 0.0288\times 100=14.40\%.$$

Figure 6 illustrates the allocation of machines 1–5 to operators using a donut chart. The red segments represent setup times, the yellow segments indicate idle times, and the blue/gray segments denote production times. It is clearly visible that the setup times for machine 5 overlap with those of machines 1–4, reinforcing the conclusion that a second operator is required. This visual evidence complements the results of the mathematical programming model and enhances the transparency of the operator assignment decision.

4.3. The Number of Required Operators

We applied the allocation procedure described in Section 3.5 to determine the number of operators needed. The load imposed by each machine on an operator was calculated as the product of the number of product types assigned to the machine and the fixed setup time per product. These values, representing the total setup time per machine, are presented in Table 2 and were used to guide the machine-to-operator assignment. The feasibility of assigning multiple machines to a single operator was explained in Section 4.2.

Our analysis indicates that machines 1 through 4 can be assigned to a single operator without violating either the total load constraint or setup-time overlap constraints. However, machine 5 must be assigned to a second operator. The mathematical model (5) failed to yield a feasible solution when all five machines were assigned to one operator. Therefore, the result of our algorithm is a solution that requires two operators.

Specifically, Operator 1 is assigned to machines 1–4, and Operator 2 is assigned to machine 5. We note that this solution is not necessarily optimal and is not balanced between the two operators. The heuristic algorithm does not explore all possible assignments; it maintains the original production sequence and does not permit reallocation of slot times to further minimize the number of operators. In addition, the algorithm preserves all idle times at the end of the cycle rather than distributing them throughout the schedule, which may further limit optimization.

5. Summary of Conclusions and Future Research

This study examined a manufacturing scenario with multiple product types, each with a different production rate and a predetermined, cyclical demand. All the products can be produced using identical machines operated by several operators. Each machine can produce any product, and changing between product types requires an operator’s fixed time for a setup process. The goal is to determine the minimum number of machines and operators needed to meet production requirements while ensuring that all product types are produced in every cycle. The problem is classified as NP-hard because it is analogous to the BPP with conflicts.

To tackle this challenge, we developed a two-stage algorithm. In the first stage, the algorithm identifies the minimum number of machines needed to meet production requirements and creates a production schedule for each machine. This process includes determining the order in which different product types will be produced on each machine, utilizing a well-known heuristic algorithm. In the second stage, the algorithm calculates the number of operators required to carry out the setup processes defined in the first stage. This stage is also addressed using heuristic methods. We examined both the upper and lower bounds to evaluate the quality of the solution and assess its potential optimality.

The algorithm was validated using a real-world test case. In the first stage, the heuristic algorithm identified the optimal number of machines needed. The second stage presented some complexity, as it is a special case of the BPP problem with constraints. We illustrate the solution to the second-stage problem using rings to demonstrate that overlapping is prevented.

The model provides practical tools for industrial managers seeking to reduce costs and optimize production under resource constraints. Its adaptability to various manufacturing contexts, including industries facing high product variety and cost pressures, highlights its strategic value. Although this study focuses on a manufacturing system, the model can also be applied to other contexts.

Limitations and Future Research

Although the proposed algorithm yields promising results and demonstrates practical applicability, it has several limitations. It is a heuristic approach that does not guarantee optimal solutions in all instances. Additionally, it assumes a fixed production sequence and does not allow for the reallocation of idle time, which may reduce its flexibility in more dynamic or uncertain production environments.

Future research should aim to enhance the algorithm’s adaptability and performance by exploring hybrid metaheuristic approaches or integrating dynamic scheduling capabilities. Another direction involves applying the model in scenarios where production quantities are optimized based on trade-offs among inventory holding costs, setup costs, and limited storage capacity. Moreover, extending the model to non-manufacturing domains—such as healthcare, logistics, and services—could further validate its versatility and broaden its impact. These efforts would contribute to developing a more robust and generalizable framework for resource optimization in cyclic systems.