Next Article in Journal
Application of AI in Date Fruit Detection—Performance Analysis of YOLO and Faster R-CNN Models
Previous Article in Journal
Advanced Deep Learning Framework for Predicting the Remaining Useful Life of Nissan Leaf Generation 01 Lithium-Ion Battery Modules
Previous Article in Special Issue
Sliding Window-Based Randomized K-Fold Dynamic ANN for Next-Day Stock Trend Forecasting
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Effective Heuristics for Solving the Multi-Item Uncapacitated Lot-Sizing Problem Under Near-Minimal Storage Capacities

by
Warut Boonphakdee
1,
Duangrat Hirunyasiri
2,* and
Peerayuth Charnsethikul
1
1
Department of Industrial Engineering, Faculty of Engineering at Kamphaeng Saen, Kasetsart University, Nakhon Pathom 73140, Thailand
2
Department of Textile Science, Faculty of Agro-Industry, Kasetsart University, Bangkok 10900, Thailand
*
Author to whom correspondence should be addressed.
Computation 2025, 13(6), 148; https://doi.org/10.3390/computation13060148
Submission received: 23 April 2025 / Revised: 27 May 2025 / Accepted: 4 June 2025 / Published: 13 June 2025

Abstract

In inventory management, storage capacity constraints complicate multi-item lot-sizing decisions. As the number of items increases, deciding how much of each item to order without exceeding capacity becomes more difficult. Dynamic programming works efficiently for a single item, but when capacity constraints are nearly minimal across multiple items, novel heuristics are required. However, previous heuristics have mainly focused on inventory bound constraints. Therefore, this paper introduces push and pull heuristics to solve the multi-item uncapacitated lot-sizing problem under near-minimal capacities. First, a dynamic programming approach based on a network flow model was used to generate the initial replenishment plan for the single-item lot-sizing problem. Next, under storage capacity constraints, the push operation moved the selected replenishment quantities from the current period to subsequent periods to meet all demand requirements. Finally, the pull operation shifted the selected replenishment quantities from the current period into earlier periods, ensuring that all demand requirements were satisfied. The results of the random experiment showed that the proposed heuristic generated solutions whose performance compared well with the optimal solution. This heuristic effectively solves all randomly generated instances representing worst-case conditions, ensuring robust operation under near-minimal storage. For large-scale problems under near-minimal storage capacity constraints, the proposed heuristic achieved only small optimality gaps while requiring less running time. However, small- and medium-scale problems can be solved optimally by a Mixed-Integer Programming (MIP) solver with minimal running time.

Graphical Abstract

1. Introduction

In supply chain management, the inventory bound, or limitation storage is an im-portant constraint. Raw materials cannot be stored in huge volumes, even though the unit price of a raw material unit is low. If the raw materials comprise many different items and stock-keeping units (SKUs), complex problems result. Supply chain management decisions depend on the procurement policy of the organization. It comprises operating on the minimum inventory cost while considering whether or not to use an expanded storage area. An expanded storage area is a feasible solution, which operates at the lowest inventory cost. However, the investment cost for land lease and acquisition, including the rack and shelving supply, must be considered as well. In the case of not considering an expanded storage area, there are two feasible solutions. Firstly, when the inventory is over capacity, it must be kept in another area, such as the production line; notwithstanding, this results in late disbursement, lost materials, and the incorrect counting of the number of remaining materials. The total inventory cost is still low. Secondly, keep the amount of inventory under the storage capacity, but the order frequency must grow evidently. As a result, the storage cost continues to be high. When the number of items or SKUs increase, deciding how much of each item to order without exceeding capacity becomes more difficult. In many process industries such as paper manufacturing, petrochemical manufacturing, refineries, food processing, and pharmaceutical manufacturing, storage capacity has become a limiting factor.
In practice, industries such as trailer assembly processes [1] and raw-material perishability in composites [2] must all contend with limited inventory bounds. Tight inventory bounds or near-minimal storage capacities that slightly exceed demand require specialized heuristics. Industries operating under just-in-time assembly, such as automotive plants [3], are especially sensitive to these constraints. Therefore, the authors introduce a dynamic programming approach based on network flow to generate an initial replenishment plan for each single item and develop a new heuristic to manage the multi-item lot-sizing problem under near-minimal storage capacities.
Storage capacity has been defined by researchers as comprising two distinct categories: the number of the ending inventory only, and the sum of the number for the beginning inventory and replenishment. Firstly, most researchers proposed that the storage capacity should be based on the number of the ending inventory only. Secondly, other researchers defined the storage capacity as the total of the number of the beginning inventory and replenishment. Thus, many researchers have defined inventory as the quantity of goods on hand at the end of a specific period. However, in a real-world scenario, raw material stores usually receive the replenishment at the beginning of the period and keep the inventory of the previous period together so as not to be over the storage capacity. Consequently, this paper suggests that the total number of inventory in each period depends on the sum of inventory and replenishment at the beginning of the period. There are two definitions of storage capacity: one based on the number of the ending inventory, and the other on the sum of the beginning inventory plus replenishment. These different definitions not only affect how inventory is calculated but also directly impact the formulation of inventory planning models. As a result, various algorithms have been developed to solve these models.
Lot-sizing problems are typically solved using exact methods such as MIP, dynamic programming, and heuristic techniques. The earliest known MIP formulation for the lot-sizing problem in the U. S. petroleum refining industry was introduced by Manne [4] in 1958. In his seminal paper, he presented a mathematical model for the dynamic lot-sizing problems which develop in production planning and inventory control. Meanwhile, Wagner and Whitin [5] introduced a forward algorithm based on the dynamic programming approach to search for optimal lot size decisions. They established the optimal lot sizes for a single item when demand, inventory holding charges, and setup costs change over time. For the management of procurement of materials with storage capacity, consider both the single item and multi-item.
The dynamic programming approach has been implemented by various researches to solve the single-item dynamic lot size problem. Love [6] introduced the first dynamic programming formulation for the Economic Lot-Sizing Problem with Bounded Inventory (ELSB), where inventory levels are constrained by the lower and upper bounds. His model considers both production capacities and storage limitations, which are common in practical applications. It solved in O(T3) time considering backlogging, time-dependent inventory bounds and piecewise concave production, and storage costs when T is the number of periods in the planning horizon. Toczylowski [7] presented an efficient O(T2) algorithm for the general single-item dynamic lot-sizing problem with limited inventory levels and nonzero initial and safety stock levels. Loparic et al. [8] derived a dynamic program or the shortest path problem using regeneration intervals to solve a single-item lot-sizing problem with sales constraints and lower bounds on safety stocks. The limitation of this research is that, in practice, safety stock levels often fluctuate. Sedano-Noda et al. [9] introduced an O(T logT) greedy algorithm to provide optimal policies assuming reorder and linear holding costs without setup costs or backlogging. However, the limitation of this research is that it considers only zero setup costs, which is not practical. Liu and Tu [10] proposed the capacity production-planning (CPP) problem where the production quantity was limited by inventory capacity and stockout. This problem occurs in petrochemical and glass manufacturing, crude oil refining, and food processing. They applied a minimum-cost flow algorithm to construct the network. By applying standard successive-shortest-path methods, they achieved an overall time complexity of O(T3). Önal et al. [11] modified the dynamic programming procedure that restores optimality for the general bounded-inventory lot-sizing problem in O(T2). However, this study did not include any computational experiments to validate the practical performance of the corrected method. Chu and Chu [12] proposed the dynamic programming approach for the inventory-bounded outsourcing models. These models execute overall complexity time with O(T2 log T) and O(T2), respectively. The limitation of this approach is impractical for planning horizons longer than a few dozen periods. Hwang and Heuvel [13] presented the O(T2) algorithm based on dynamic programming and the Monge property for solving a dynamic lot-sizing problem with backlogging and inventory bounds when the general production and inventory cost structures are concave. In addition, they introduced the O(T log T) algorithm using the points-approach and a geometric technique for fixed-charge cost structure as well as the O(T) algorithm using a line-segments approach, including a geometric technique for the fixed-charge cost structure without speculative motives. However, their algorithm does not provide an optimal solution for the ULS-IB problem. Hwang et al. [14] developed the first polynomial-time O(T4) dynamic-programming algorithm to solve the single-item deterministic Economic Lot-Sizing problem with lost sales and bounded inventory (ELS-LB), under the assumption that each period’s inventory capacity is fixed. A drawback of their DP algorithm is that it requires a long running time and a large amount of memory to execute. Boonphakdee and Charnsethikul [15] developed a network flow based on the dynamic programming approach to solve the single-item uncapacitated lot-sizing problem. In this study, the authors introduce their DP algorithm to generate the initial replenishment plan. Atamtürk and Küçükyavuz [16] proposed a linear programming formulation that achieves tighter relaxations for the single-item lot-sizing problem with inventory bounds and fixed costs. Gutiérrez et al. [17] extended the classical Wagner–Whitin model by time-varying storage capacities and allowing backlogging. They developed a dynamic programming algorithm with a time complexity of O(T3), where T is the number of periods in the planning horizon. Their algorithm applies only when both the production cost and the holding or stockout cost functions are concave. Guan and Liu [18] introduced two stochastic models for the single-item lot-sizing problem under uncertainty including inventory-bound only and the other both inventory-bound and constant order-capacity constraints. They developed dynamic programming algorithms from them with the time complexity O(T2) and O(T2nLogT), respectively, where T is the number of time periods and n is the number of possible order capacities. However, stochastic DP requires complete and precise probability distributions of demand for every period. Chu et al. [19] proposed a single-item dynamic lot-sizing model integrating backlogging, outsourcing, and limited inventory. They developed a dynamic programming algorithm that solves the lot-sizing problem in polynomial time with O(T3) time complexity, where T is the number of periods in the planning horizon. As a result, their algorithm cannot support concave setup or volume discount cost structures. Brahimi et al. [20] introduced the Two-Level dynamic Lot-Sizing Problem with Bounded Inventory (2LLSP-BI), integrating raw-material procurement and finished-product production planning under finite warehouse capacity constraints. They introduced a new Lagrangian-relaxation heuristic which decomposes 2LLSP-BI into N single-item lot-sizing subproblems. Each subproblem is solved by a dynamic programming. The time per Lagrangian iteration is O(N⋅T2 + T⋅Imax), where Imax is the number of the capacity bounds. The raw-material inventory has a single static bound, whereas finished-goods storage is unbounded. Finally, Di Summa and Wolsey [21] studied a mixed-integer program that provides a new convex-hull characterization for the single-item discrete lot-sizing problem with a variable upper bound on the initial stock. However, this formulation is in general too large to be practically useful.
In practice, it is hard to handle only a single item in raw material storage or on the production line. Consequently, managing multiple items can be quite complex. It is difficult to keep each item and to balance holding costs against ordering costs. Heuristic algorithms are commonly used to solve the multi-item dynamic lot-sizing problem. Many researchers have been interested in creating the heuristic algorithm for solving the multi-item uncapacitated lot-sizing problem with inventory bound (MULSP-IB) due to the practical problem in the real world. This problem is like the multi-item capacitated lot-sizing problem (MCLSP), where the items allocate to a machine with a production capacity constraint. The MULSP-IB only has the limitation of on-hand inventory. Dixon and Poh [22] proposed the smoothing approach. They developed the push and pull operations if all weight or volume of the inventory is maintained at more than the storage capacity. For the push operation, replenishment in the existing period t is moved to the consecutive period t + 1. On the other hand, the pull operation postpones the replenishment in a backward direction from the existing period t to a previous period t - 1 so that all the weight or volume of the inventory is maintained at less than the storage capacity. This procedure runs in O(n⋅T). The authors apply the principle of this smoothing method to implement the push and pull procedures. The push procedure postpones replenishment from the current period to the next period, whereas the pull procedure shifts it back to the previous period. Moreover, the authors compare this heuristic’s performance against other heuristics. Park [23] studied the two systems together. He presented the solutions of integrated production and distribution planning and investigated the effectiveness of their integration in a multi-plant, multi-retailer, multi-item, and multi-period logistic environment. Additionally, he introduced the optimization models and a heuristic solution for both integrated and decoupled planning. Akbalik et al. [24] improved the dynamic programming running in O (2nTn+1) time with a polynomial growth rate if the number of items (n) is fixed to solve the MULSP-IB. However, the Tn+1  factor makes the algorithm impractical for larger multi-item instances. Gutiérrez et al. [25] extended the smoothing technique of Dixon and Poh [22] and explored the multi-item dynamic lot-sizing problem with storage capacities or inventory bounds. The problem has been presented to bound applying the weight of inventory in a previous period plus the weight of replenishment in the current period. Its average solution is over around 5% of the solution computed by CPLEX. The authors also compare its performance against the proposed heuristics. Melo and Ribeiro [26] presented the multi-item uncapacitated lot-sizing problem with shared inventory bounds. They developed two MIP-based heuristics: a rounding scheme for generating the feasible solution and a relax-and-fix heuristic for improving the solution. These MIP-based heuristics yield only near-optimal solutions on average within about 2–4% of the true optimum. Witt [27] introduced a mathematical model for the Multi-Level Capacitated Lot-Sizing Problem with Inventory Constraints (MLCLSP-IC). His model integrates capacity bounds at each level of a product bill-of-materials and explicit work-in-process inventory limits. Although it is multi-level, the approach supports only a single item per level; it cannot accommodate product families that share capacities or complex bills-of- materials with alternative subassemblies. Finally, heuristics and MIP-based heuristics for solving MULSP-IB are further explained in Table 1 as below.
In Table 1, the researchers considered only limited storage capacity and did not specifically consider the issue of tight capacity constraints. Therefore, the authors are interested in near-minimal storage capacity constraints, which occur in the automotive assembly industry [3].
This study proposes a new heuristic for computing the approximate replenishment plan for multiple items in each period under storage capacity constraints. The novelty of this study considers the proposed procedure, which can be executed effectively under a near-minimal or worst-case storage capacity constraint. Storage capacity is defined as the sum of the weight (or volume) of all items carried over from the previous period and the weight (or volume) of all replenishments in the current period. The authors introduce a dynamic programming approach based on network flow [15] to determine the replenishment plan for each item and propose two methods for computing a multi-item replenishment schedule under storage-capacity constraints. The proposed heuristics consist of a push method and a pull method. The push method postpones replenishments forward from period t to period t + k whenever the inventory level in period t exceeds the limited capacity, and repeats this until the inventory in every period does not exceed its capacity. Then the pull method refines the plan by moving replenishments backward from period t to earlier periods
The second section describes the mathematical formulation of MULSP-IB. The proposed heuristic is effective for solving this problem using the modified push and pull operation. It improves comparison with the push operation by Gutiérrez et al. [25] shown in Section 3, and this heuristic is examined by the Gutiérrez et al.example [25] in Section 4. In Section 5, the randomly generated data has been implemented for solving the different problem sizes. The performance of this proposed heuristic is compared with the result of the Gutiérrez et al. algorithm [25] and the smoothing method. For the robustness condition, the worst-case condition is analyzed, which is the near-minimal storage capacity. In the sensitivity analysis, varying the storage capacities affects the total cost and inventory levels. Finally, conclusions are provided in Section 6.

2. Problem Description

2.1. Problem Statement

The problem of MULSP-IB can be stated as this: Each demand dit must be partly or entirely replenished at a period t by inventory. In this study, consider that demands and inventory bounds are time-varying, and the total actual weight/volume of the inventory is not over storage capacity. The problem is to find the periods and the number of raw materials delivered within these periods. The objective is to construct a replenished plan such that the total cost is minimized.

2.2. Problem Assumptions

Assumptions are provided to define certain parameters and decision variables as follows:
Assumption 1.
Storage capacity is the upper bound of stock.
Assumption 2.
A replenished item is stored first before it is used to satisfy demand. Thismeans that the inventory at the beginning of a period plus the replenishment is the actual inventory at the end of the periods.
Assumption 3.
The sum of demand is not over storage capacity in all periods, and thedemands are satisfied at the end of the period.
Assumption 4.
The number of items is independent of the quantity of demand and the number of procurement planning horizon.
Assumption 5.
The initial inventory in the first period and the ending inventory in the last periodare zero.
Assumption 6.
Backlogging is not allowed.
Assumption 7.
There is no consideration of lead time.

2.3. Decision Variables and Parameters

An explanation of decision variables and parameters can be noted in the following:
  • Indices
  • i the number of items indexed from 1 to N
  • t the number of periods indexed from 1 to T
  • Parameters
  • dit the demand of item i at period t
  • Di,t the accumulative demand of item i from period t to period T
  • fi,t the fixed ordering cost of item i at period t
  • hi,t the holding cost of item i at period t
  • pi,t the cost of procuring raw materials of item i at period t
  • Ii,t the inventory level of item i at period t
  • wi the unit weight of item i
  • Ut the storage capacity at period t
  • Decision variables
  • xi,t the procurement quantity of item i at period t
  • Yi,t if the replenishment of item i at period t occurs, Yit is 1. Otherwise, Yit is 0.

2.4. Mathematical Model

This study proposes the model by Gutiérrez et al. [25], which states the MIP formulation as follows:
min i = 1 N t = 1 T f i , t Y i , t + p i , t x i , t + h i , t I i , t
s . t     I i , t 1 I i , t + x i , t = d i , t ,             i = 1 , , N , t = 1 , , T
i = 1 N w i ( I i , t 1 + x i , t ) U t ,             t = 1 , , T
x i , t Y i , t D i , t ,             i = 1 , , N , t = 1 , , T
I i , 0 = I N , T = 0 ,             i = 1 , , N
x i , t , I i , t 0 = 0 ,             i = 1 , , N , t = 1 , , T
Y i , t { 0 , 1 } ,             i = 1 , , N , t = 1 , , T
The objective function of MULSP-IB minimizes the sum of ordering, and purchased and holding costs in constraint (1). Constraint (2) is the balance of the inventory equation. Each purchased unit and inventory unit at the beginning of the period is always kept first, before moving to production/customers following its demand in constraint (3). Constraint (4) link the purchased variables with the binary variables Yit and accumulated demand ( D i t = k = t T d i k ) of item i from periods t to T. Constraint (5) is the initial inventory in the first period and the ending inventory in the last period are zeroes. Constraint (6) defines the purchased quantity and inventory, which are not negative. In constraint (7), if replenishment occurs at any period, Yit is 1. Otherwise, Yit is 0.

3. The Proposed Heuristic

The push and pull strategies of Dixon and Poh [22] consider that excess storage ca pacity has occurred. This is reduced by moving a replenishment quantity from the existing period t to t + 1 when the sum of both inventory and replenishment of all items (SIRallitems) for the existing period is over the storage capacity, called the push operation. On the other hand, a replenishment quantity from period t is returned to a previous period when SIRal litems is less than the storage capacity, called the pull strategy. The push method focuses on reducing SIRallitems in the existing period until success only. Therefore, each iteration ena- bles the reduction of SIRallitems prominently, while the ordering cost will grow as necessary, causing the total inventory cost to expand as necessary. Furthermore, the Gutiérrez et al. heuristic [25] extends the push strategy in so far that a replenishment quantity can be moved from any period t to t + k, k ( 1 , , T t ) . For any iteration, the Gutiérrez et al. heuristic [25] possibly moves a replenishment quantity from a non-existing period to the next period, resulting in SIRallitems in the existing period also not reducing. However, it is unnecessary to maintain expanding ordering costs.
This study also applies Dixon and Poh’s approach to both the push and pull strategies. For the push strategy, consider a replenishment item in the existing period, which has the maximum sum of inventory and the replenishment quantity (SIRmax). Consider an item of SIRmax condition, called iSIRmax that has an inventory cost of zero at period t + k, k ( 1 , , T t ) called on tzero. Therefore, a replenishment quantity is equal to its demand in the existing period, then it moves so as to add the original replenished quantity at period tzero. After that, the replenishment quantity of the existing item is balanced for all periods. It runs repeatedly until all SIRallitems are less than storage capacities. This procedure is called the push method.
For the pull strategy, find the periods (tmin and tmax) with the minimum and maximum differences between SIRallitems and their storage capacities (U), called SIRallitems_Umin and SIRallitems_Umax. If the index of period tmin is higher than the index of period tmax, consider a SIRmin item called iSIRmin for period tmin. Return the replenished quantity, which is the demand of iSIRmin of period tmin, to add the original replenished quantity of the same item at period tmax. Then, calculate all SIRallitems again. If a new SIRallitems for period tmax is still greater than the storage capacity at that period, find a new item with SIRmax called iSIRmax. Next, determine the period tzero on iSIRmax and calculate the round-up of the new SIRallitems_U for period tmax divided by its weight, called SIRallitems_Uroundup. Move the replenished quantity, SIRallitems_Uroundup for period tmax, to period tzero. Finally, balance the replenished plan again. This procedure is called the pull method. It can effectively improve the solution generated by the push method. Next, determine the period tzero on iSIRmax and calculate the round-up of the new SIRallitems_U for period tmax divided by its weight, called SIRallitems_Uroundup. Move the replenished quantity, SIRallitems_Uroundup for period tmax, to period tzero. Finally, balance the replenished plan again. This procedure is called the pull method. It can effectively improve the solution generated by the push method.
This study proposes a new procedure for solving MULSP-IB. It has a property suggesting that the sum of both the inventory and the replenished quantity for all items (SIRallitems) agree with less storage capacity, satisfying all demands for the existing period or equal storage capacity for that period. This property is presented to clarify the logical flow of arguments as follows:
Theorem 1.
If t is a period such that  x i , t > 0  for some items i satisfying  I i , t 1 + x i , t = D i , t D i , t + k k ( 1 , , T t ) then  i = 1 N ( I i , t 1 + x i , t ) < U t .
Proof of Theorem 1.
For a contradiction method, the assumption is i = 1 N ( I i , t 1 + x i , t ) U t . □
Given I i , t 1 + x i , t = D i , t D i , k . It implies that the total inventory is sufficient to satisfy or exceed the storage limitation. However, some x i , t > 0 and I i , t 1 + x i , t = D i , t D i , t + k are used to satisfy the demands such that no additional replenishments can exceed the storage limitation. Therefore, there is no additional inventory available to satisfy or exceed the limitation.
Theorem 2.
If t is a period such that  x i , t > 0  for some items i satisfying   I i , t 1 + x i , t D i , t D i , t + k ,   k ( 1 , , T t ) ,  then   i = 1 N ( I i , t 1 + x i , t ) = U t .
Proof of Theorem 2.
For a contradiction method, let us study a replenishment ( x i , t > 0 ) that there is an item i, for which the assumption is i = 1 N ( I i , t 1 + x i , t ) U t . In the case of i = 1 N ( I i , t 1 + x i , t ) < U t , given I i , t 1 + x i , t D i , t D i , t + k , the inventory level and extended replenishments ( I i , t 1 + x i , t ) are not sufficient to satisfy the sum of the consecutive demand ( D i , t D i , t + k ). Further, in the case of i = 1 N ( I i , t 1 + x i , t ) > U t , there is additional inventory to be over the storage capacity. However, the given condition I i , t 1 + x i , t D i , t D i , k does not satisfy the demand. Therefore, the sum of inventory and replenished quantity cannot exceed the storage capacity. □
To satisfy demand, the sum of the inventory and replenished quantity of all items in each period must either be less than or equal to the storage capacity explained by Theorems 1 and 2, respectively.

3.1. The Push Method

The objective of this method is to seek the approximate solution of MULSP-IB. The procedure for this method can be explained by the pseudo-algorithm in Algorithm 1 and the flowchart in Figure 1 as follows:
Algorithm 1 Push method
1: procedure InitialSolution(N, T, U, d, h, f)
2:  Input:
3:   N       ← number of items
4:   T       ← number of periods
5:   U[1..T]    ← inventory bounds per period (network-flow based)
6:   d[1..N][1..T]  ← demand of item i in period t
7:   h[1..N][1..T]  ← holding cost of item i in period t
8:   f[1..N][1..T]  ← ordering cost of item i in period t
9:  Output:
10:   x[1..N][1..T]   ← initial replenishment plan
11:  for i ← 1 to N do
12:   x[i][1..T] ← NetworkFlowDP(i, U, d[i], h[i], f[i])
13:  end for
14:  return x
15: end procedure
16: procedure PushAlgorithm(N, T, U, d, h, f, x)
17:  Input:
18:   N       ← number of items
19:   T       ← number of periods
20:   U[1..T]     ← storage capacity per period
21:   d[1..N][1..T]  ← demand of item i in period t
22:   x[1..N][1..T]  ← initial replenishment plan
23:  Output:
24:   x[1..N][1..T], TotalCost
25:  for t ← 1 to T do
26:   // Compute SIR for each item at period t
27:   for i ← 1 to N do
28:    if t == 1 then
29:     inv[i] ← x[i][1] - d[i][1]
30:    else
31:     inv[i] ← inv_prev[i] + x[i][t] - d[i][t]
32:    end if
33:    tailDemand ← 0
34:    for k ← t to T do
35:        tailDemand ← tailDemand + d[i][k]
36:    end for
37:    SIR[i] ← inv[i] + tailDemand
38:    inv_prev[i] ← inv[i]
39:   end for
40:   SIRall ← Σ_{i=1..N} SIR[i]
41:   slack ← SIRall - U[t]
42:   while slack > 0 do
43:    iMax ← argmax_{i=1..N} SIR[i]
44:    Δ ← d[iMax][t]
45:    x[iMax][t] ← x[iMax][t] - Δ
46:    if t < T then
47:        x[iMax][t+1] ← x[iMax][t+1] + Δ
48:    end if
49:    // Recompute inventory and SIR
50:    SIRall ← 0
51:    for i ← 1 to N do
52:     if t == 1 then
53:      inv[i] ← x[i][1] - d[i][1]
54:     else
55:      inv[i] ← inv_prev[i] + x[i][t] - d[i][t]
56:     end if
57:     tailDemand ← 0
58:     for k ← t to T do
59:           tailDemand ← tailDemand + d[i][k]
60:      end for
61:     SIR[i] ← inv[i] + tailDemand
62:     inv_prev[i] ← inv[i]
63:     SIRall ← SIRall + SIR[i]
64:    end for
65:    slack ← SIRall - U[t]
66:   end while
67:  end for
68:  // Calculate total cost
69:  TotalCost ← 0
70:  for i ← 1 to N do
71:   for t ← 1 to T do
72:    if x[i][t] > 0 then
73:        TotalCost ← TotalCost + f[i][t]
74:     end if
75:    TotalCost ← TotalCost + inv_prev[i] ∗ h[i][t]
76:   end for
77:  end for
78:  return x, TotalCost
79: end procedure
In line No. 16, the pseudocode of the dynamic programming based on network flow is shown in Appendix A. The logical sequence including the selection rules of the push method is explained in Figure 1
In Figure 1, the algorithm stops computing if the difference (diff) between the sum of the previous inventory plus the replenishment quantity (SIRalitem) and the storage capacity (U) for each period is less than or equal to zero. This selection rule determines whether to perform the next step of the algorithm. From the pseudo code, the dynamic programming based on network flow algorithm has time complexity O ( N T D max 2 ) that depends on Dmax, the largest demand value across all items i and all time periods t. Therefore, large demand values significantly influence the running time when solving large-scale problems. The push algorithm has time complexity O ( N T W ) where W is number of iterations of the while loop per period. If the total inventory exceeds the storage capacity by a large amount, many iterations (W) will be needed to reduce the overcapacity; otherwise, iteration stops. Therefore, in large-scale problems, inventory overcapacity is likely, causing the proposed algorithm to have a high running time. The replenishment plan generated by the push method can be improved to reduce the total cost using the pull method, which will be discussed in the next section.

3.2. The Pull Method

The objective of this method is to improve the replenishment plan, which is computed by the push method. Some replenishments may be returned from the existing pe riod to the previous period so that the sum of the inventory and the replenished quantity of all items for the previous period is added to equal its storage capacity. The procedure for the pull method shows the pseudocode of Algorithm 2 and the flowchart in Figure 2 as follows:
Algorithm 2 Pull method
1: PROCEDURE Pull method
2:  INPUT:
3:    X [i, t]         ← initial replenished quantity for item i in period t        
    computed by the push method
4:    demand[i, t]      ← demand of item i in period t 
5:    SIR[i, t]        ← the sum of previous inventory and replenished 
    quantity of item i in period t 
6:    U          ← storage capacity for period t 
7:    w[i, t]        ←weight (or size) of item i in period t 
8:    T          ←total number of periods 
9:  OUTPUT:
10:    replenishment plan[i, t] ←adjusted replenished quantities 
11:    inventoryCost     ←updated total inventory cost 
12:  // Compute initial aggregate SIR per period
13:  FOR t ← 1 TO T DO
14:   SIRallitems[t] ← Σᵢ SIR[i, t]
15:   SIRallitems_SC[t] ← Σᵢ (SIR[i, t] · w[i, t])
16:  END FOR
17:  // Find periods with min/max aggregate SC usage
18:  Tmin ← arg minₜ SIRallitems_SC[t]
19:  Tmax ← arg maxₜ SIRallitems_SC[t]
20:  // Loop until the lightest-loaded period index is not after the heaviest
21:  IF Tmax< Tmin DO
22:   // 1) Move the smallest-rate demand from Tmin to Tmax
23:   i_min ← arg minᵢ SIR[i, Tmin]
24:   qty ← demand[i_min, Tmin]
25:   X[i_min, Tmax] ← X[i_min, Tmin] + qty
26:   X[i_min, Tmin] ← X[i_min, Tmin] - qty
27:   // 2) Rebalance and update all metrics
28:   CALL UpdateMetrics()
29:   // 3) If Tmax still exceeds capacity, boost its replenishment
30:   IF SIRallitems_SC[Tmax] > U THEN
31:    i_max ← arg maxᵢ SIR[i, Tmax]
32:    adjustment ← ⌈SIRallitems_SC[Tmax] / w[i_max, Tmax]⌉
33:    X[i_max, Tmax] ← X[i_max, Tmax] + adjustment
34:    CALL UpdateMetrics()
35:   END IF
36:   // 4) Recompute Tmin and Tmax for next iteration
37:   Tmin ← arg minₜ SIRallitems_U[t]
38:   Tmax ← arg maxₜ SIRallitems_U[t]
39:  END IF
40:  RETURN (X, inventoryCost)
41: END PROCEDURE
42: // Subroutine to recalculate inventory levels, SIR, aggregate metrics, and cost
43: PROCEDURE UpdateMetrics
44:  FOR t ← 1 TO T DO
45:   FOR each item i DO
46:    // Recompute SIR[i, t] based on new replenishment qty and demand
47:    SIR[i, t] ← ComputeSIR(X[i, t], demand[i, t])
48:   END FOR
49:   SIRallitems[t]  ← Σᵢ SIR[i, t]
50:   SIRallitems_U[t] ← Σᵢ (SIR[i, t] · w[i, t])
51:  END FOR
52:  inventoryCost ← ComputeTotalCost(X, demand, holdingCosts, order
   ingCosts)
53: END PROCEDURE
In Figure 2, the algorithm proceeds to compute an improved solution if the index of the period with the minimum diff (Tmin) is greater than the index of the period with the maximum diff (Tmax). This selection rule determines whether to perform the next step of the algorithm. The push algorithm has time complexity O(N2T2) when L  N T, where L is the number of loop. The total running time depends on how many iterations L the algorithm performs to balance the load between periods. If L grows large (close to N·T in the worst case), the running time can grow quadratically. To explain the heuristic algorithm, the authors use a numerical example to demonstrate it in the next section.

4. A Numerical Example

This study presents the simple example by Gutiérrez et al. [25] to explain the procedure for both proposed methods. Data from this example is shown in Table 2.

4.1. The Initial Solution

The optimal replenished plan for each item, which is independent, can be solved by the network flow based on a dynamic programming approach [15]. Thus, the optimal replenished plan is the initial solution for this example, as shown in Table 3.

4.2. Solution of the Push Method

From Table 3, SIRallitems values of periods 1, 3, and 4 are positive and their SIRallitems values are certainly excess. Next, the replenished quantity for period one is moved as follows.
  • Period 1
  • Iteration 1
  • Select item 1, which has the maximum SIR (SIRmax) of 567, and find period tzero = 5 on item 1, which has an inventory cost of zero.
  • Insert the replenished quantity, which equals the demand of item 1 for period tzero = 136 units, on a replenished plan on item 1 for period tzero. For balance demand, de crease the replenishment of item 1 for period 1 to 567 − 136 =431 units.
  • Balance a replenished plan and update inventory, SIR,SIRallitems, SIRallitems_U, and total inventory cost (see Table 4).
  • SIRallitems_U for period 1 is reduced to 987 − 756 = +231. Afterward, go to steps 1–4.
  • Iteration 2
  • Select item 2, which has SIRmax of 556, and find period tzero = 2 on item 2, which has an inventory cost of zero.
  • Insert the replenished quantity, which equals the demand of item 2 for period tzero = 52 units, on a replenished plan on item 2 for period tzero. For balance demand, decrease the replenishment of item 2 for period 1 to 139 − 52 =87 units.
  • Balance a replenished plan and update inventory, SIR, SIRallitems, SIRallitems_U, and total inventory cost (see Table 5).
  • SIRallitems_U for period 2 is still reduced to 779 − 756 = +23. Then, go to steps 1–4.
  • Iteration 3
  • Select item 1, which has SIRmax of 431, and find period tzero = 4 on item 1, which has an inventory cost of zero.
  • Insert the replenished quantity, which equals the demand of item 2 for period tzero= 106 units, on a replenished plan on item 1 for period tzero. For balance demand, decrease the replenishment of item 1 for period 1 to 431 − 106 = 325 units.
  • Balance a replenished plan and update inventory, SIR,SIRallitems, SIRallitems_U, and total inventory cost (see Table 6).
  • SIRallitems_U for period 1 is reduced to 673 − 756 = −83. Stop the iteration and select period 3, which has the SIRallitems_U value of +947. Proceed to steps 1–4 for period 3.
  • Period 3
  • Iteration 1
  • Select item 2, which has SIRmax of 1484, and find period tzero = 5 on item 2, which has an inventory cost of zero.
  • Insert the replenished quantity, which equals the demand of item 2 for period tzero = 118 units, on a replenished plan on item 2 at period tzero. For balance demand, decrease the replenishment of item 2 for period 3 to 371 − 118 = 253 units.
  • 3. Balance a replenished plan and update inventory, SIR, SIRallitems, SIRallitems_U, and total inventory cost (see Table 7).
  • SIRallitems_U for period 3 is still reduced to 1108 − 633 = +475. Afterward, go to steps 1–4.
  • Iteration 2
  • Select item 2, which has SIRmax of 348, and find period tzero = 4 on item 2, which has an inventory cost of zero.
  • Insert the replenishment, which equals the demand of item 2 at period tzero = 142 units on a replenished plan on item 2 at period tzero. For balance demand, decrease the replenishment of item 2 at period 3 to 253 − 142 = 111 units.
  • 3. Balance a replenished plan and update inventory, SIR, SIRallitems, SIRallitems_U, and total inventory cost (see Table 8).
  • SIRallitems_U for period 3 is reduced to 540 − 633 = = −93. Stop the loop at period 3. Then, find the next SIRallitems_U to be positive. However, all SIRallitems_U values are negative and zero (−83, −255, −93, −84, 0). Thereafter, stop all iterations of the push method.
From Table 8, the push method can generate a total inventory cost equal to 8977.
However, the GAMS/CPLEX 46.3.0 solver can execute this problem with an optimal solution of 8521. The gap between these solutions is 8977 8521 8521 × 100 % = 5.35%. This gap is still high. Therefore, this study proposes the pull method to improve the solution.

4.3. Solution of the Pull Method

From Table 8, all SIRallitems_U are negative or zero. Therefore, the pull method can generate an improved replenished plan. The procedure for this method can be explained as follows.
  • Search the SIRallitems_Umin and SIRallitems_SCmax to be −255 and −83 for periods 2 and 1 from Table 8. So, the index of both periods is tmin = 2 and tmax = 1. So, tmin is more than tmax.
  • Find the SIRmin for period tmin to be 208 on item 2 from Table 8. Return the replenishment of item 2 at period 2 to add the original replenished quantity on item 2 for period tmax = 1. Thus, the new amount replenished quantity of item 2 for period 1 is 87 + 52 = 139 units. For balance demand, the replenished quantity of item 2 for period tmin is reduced to zero (see Table 9).
  • Recalculate SIR,SIRallitems, SIRallitems_U, and total inventory cost (see Table 9).
  • SIRallitems_U of item 2 for period 1 (= +125) is still a positive number. Thus, search the item with SIRmax (= 325) excluding item 2 at period 1, to be 1.
  • For reducing SIRallitems_U to zero at period 1, the SIRallitems_U is divided by the weight of item 1 for period 1 (+125/1 = 125) on item 1 at period tmin =2 to be 0 + 125 = 125 units (see Table 9). For balance demand, reduce the replenishment of item 1 in the previous period (t = 1) to be = 325 − 125 = 200 units.
  • Recalculate SIR,SIRallitems, SIRallitems_U, and total inventory cost (see Table 10).
  • SIRallitems_U of period 1 is zero and SIRallitems_U of period 2 (tmin) is still −255 (see Table 10), which is the same as Table 9.
  • Find the SIRallitems_Umin and SIRallitems_Umax to be −255 and −84 in periods 2 and 3 from Table 10. The index of both periods is tmin = 2 and tmax = 3. So, tmin is less than tmax. Then, stop the iteration.
Therefore, the inventory cost is effectively improved to 8683. The GAMS/CPLEX solver can calculate the optimal solution of 8521 units. Both the proposed heuristic and Gutiérrez et al. [25] can also calculate the approximate solution the same as 8683 and the smoothing method of Dixon and Poh [22] can run about 9494 (see Table 11). Its replenished plan is shown in Table 11.
From Table 10 and Table 11, the gaps between the proposed heuristic, Gutiérrez et al. [25], the smoothing method [22], and GAMS/CPLEX are 1.9%, 1.9%, and 11.45%, respectively. Both the proposed heuristic and Gutiérrez et al. [25] execute approximately five replenishment orders, whereas the smoothing method executes about six. Consequently, the smoothing method incurs a higher total inventory cost than the other approaches due to the increased ordering cost. For further testing, Minner [4] recommended generating test instances as follows: products varied between 3 and 10 and periods varied between 4 and 18, demands are drawn from a uniform (or normal) distribution over a specified range (e.g., \U[0,100], setup costs are drawn similarly (e.g., \U[50,150], unit production costs are drawn from U[1,10], holding costs are held constant h = 1, weights are drawn from U[1,N], and warehouse capacity bounds are taken as A = n = 1 N w i d i , t ,   U t = A + B ( n = 1 N w i D i , t + 1 ) a fixed fraction B =10%. In the format for the storage capacity, parameter A is the sum of the demand on all items at period t with the lower bound (B = 1%). Authors generate the example data following Minner [4] procedure as shown in Table 12.
An instance of Minner [4] was computed by heuristics and the resulting solutions are presented in Table 13.
In Table 13, the push-and-pull heuristic achieves an optimality gap of approximately 0%, outperforming Gutiérrez et al. [25], which has a gap of 1.27%, and the smoothing method [22], with a gap of 1.02%. The proposed heuristic places about three replenishment orders, whereas both Gutiérrez et al. [25] and the smoothing method place around four. Consequently, the push-and-pull heuristic’s performance is further validated in Section 5 on a set of randomly generated problem instances.

5. Computational Result

For confidence in using heuristics, this study compares the solutions for the proposed heuristic, algorithm by Gutiérrez et al. [25], and GAMS/CPLEX solver. The set of randomly generated problems is identical to the cost framework of Minner [4]. Each problem runs on formatting parameters, as shown in Table 14.
The parameter B is the additional capacity generated from the accumulative demand of period t + 1 with the upper bound. If the upper bound is high, such as B = 20%, the problem can be solved more easily. Otherwise, it is more difficult to address.
This study implements MATLAB 2024 A software to solve the network flow algorithm based on dynamic programming for the initial solution, the proposed algorithm [28], and the Gutiérrez et al. algorithm [29]. The solution for the MIP model is generated by GAMS 46.3.0 licensed for continuous and discrete problems. An HP Pavilion X360 Notebook running Windows 10 with an Intel Core i7 64-bit processor at 1.99 GHz and 24 GB of RAM was used to execute both the heuristics and MIP formulation. MATLAB software uses general-purpose programming that is more flexible and allows users to apply specified code. For generating the optimization solution, the GAMS/CPLEX solver is concentrated on optimization, which is less flexible but powerful for LP, MIP, and NLP problems [30].
The solution for the GAMS/CPLEX solver compares all the results of the experiment. It can be explained with the solution gap equation below.
Solution   gap   ( % ) = Solution   of   heuristic - Solution   of   GAMS / CPLEX Solution   of   GAMS / CPLEX ×   100

5.1. Experiment Results

This study divides the category for the random example into three sub-categories: a small-scale problem based on the number of periods N = 6, a medium-scale problem based on the number of periods N = 12, and a large-scale problem based on the number of periods N = 24. This experiment shows their solution gaps and computation times varying the parameter B in Table 15, Table 16, Table 17 and Table 18, as follows.

5.2. Solution Gap

In Figure 3, the average solution gaps for the push and pull algorithm on large-scale problem are 0.55%, 0.38%, and 0.20% for parameter B = 5%, 10%, and 20%, respectively. The Gutiérrez et al.heuristic [25] generates solution gaps of about 2.41%, 1.23%, and 0.55%. When comparing the solution gaps, the proposed heuristic performs better than the Gutiérrez et al. heuristic [25]. The performance of the solution gap depends on the value of parameter B. If parameter B increases, the solution gap is lower. The proposed algorithm can determine the number of replenished quantities to move relaxed while satisfying all demands with a high parameter B. The Gutiérrez et al.heuristic [25] sometimes moves the replenished quantity from any period to period t + k, when k { 1 , 2 , , T t } . Ordering cost must be paid more frequently when inserting the replenished quantity for period t + k in more time, causing the total inventory cost to grow. Unfortunately, the amount of SIRallitem _U for period t does not also decline. While the push and pull heuristic moves each replenished quantity from period t to a consecutive period only with a zero inventory cost, it can certainly reduce the replenished quantity for period t so that the amount of SIRallitems _U reduces.

5.3. Worst Cases Analysis

For the robust condition of the push and pull heuristic, this study introduces the near-minimal storage capacity. The performance of a heuristic depends on the value of the storage capacity. Suppose each storage capacity is likely near the sum of demand for each period, called near-minimal storage capacity. Moving the partial or whole replenished quantities to the next period is difficult.
In Table 15, it is difficult for the Gutiérrez et al.heuristic [25] to execute any random instances with near-minimal storage capacities. It can calculate only one and two from five and ten instances, such as 20 × 24, 30 × 24, and 40 × 24 problems (N × T). Other solutions cannot satisfy the demand. Meanwhile, the push and pull heuristic can calculate all random instances with these storage capacities. Its solution gap performs well on the small-and medium-scale problem, at about 1.15% and 1.33%, the same as the other instances with high storage capacities (parameter B = 5–20%). At the same time, the Gutiérrez et al. heuristic [25] gap solution is about 3.99% and 5.57%. Therefore, the push and pull heuristic enables computing the replenished plan significantly better with near-minimal storage capacities.
For large-scale problems (T = 24), MATLAB cannot run on the extension of the number of periods due to being out-of-memory. When increasing the number of periods, its memory usage exceeds 76 GB. The limitation of the system memory space (RAM and swap file) used by MATLAB for this computer is about 76 GB.
To strengthen empirical benchmarking and provide better justification, compare the proposed heuristics with additional baseline methods, including the smoothing heuristic [22], implemented using the state-of-the-art code [31]. The authors compare their solution gap performance, which is shown in Table 19.
In Table 19, the proposed heuristic shows good average gap performance on large-scale problems, such as the 10 × 24 case, with gaps of about 1.27% and 0.34% under storage capacities B = 1% and 20%, respectively. In comparison, the Gutiérrez et al. heuristic [25] has gaps of approximately 6.89% and 1.07%, while the smoothing heuristic has gaps of about 5.97% and 1.35%, respectively. As a result, the gap performances of Gutiérrez et al.’s and the smoothing heuristics differ by only a small amount. Therefore, the proposed heuristic is able to compute an approximate replenishment plan that is better than the previous heuristics.

5.4. Computation Time

This study implements the codes based on the state-of-the-art methods for both heuristics. Both the push and pull heuristic and the heuristic by Gutiérrez et al. [25] have the same time complexity, denoted as O ( W N T 2 ) . Therefore, the running times of the two heuristics are nearly the same. The time complexity for the network flow based on the dynamic programming algorithm [15] has O ( N T D max 2 ) for generating the initial solution. The computation time of both heuristics combines the running time for the network flow based on dynamic programming for the initial solution with the running time of each heuristic. The worst-case complexity of the GAMS/CPLEX solver has O ( 2 N x T ) , which is an exponential growth rate. However, this solver enhances performance with the branch-cut and benders decomposition algorithm for reducing the running time efficiency in large-scale problems [30] when compared with MATLAB software. For computation time, this study focuses on small-to-medium and large-scale problems with near-minimal storage capacity. Therefore, the data in Figure 4 include both small-to-medium and large-scale problems (see Table 15) with storage capacities parameter B = 1–20%. Both the heuristics and MIP solver generate solutions under storage capacities. The computation time for these conditions is shown in Figure 4, Figure 5, Figure 6 and Figure 7, as follows:
In Figure 4 the computation time generated by the GAMS/CPLEX solver increases exponentially for the large-scale problem under near-minimal storage capacities (B = 1%). In general, the CPLEX solver must execute effectively with a branch-and-cut algorithm and special heuristic. However, the running time for solving a large-scale problem includes poor performance with near-minimal storage capacities. The MIP solver must determine lot size with high running time to generate an optimal solution.
This is a limitation of the MIP solver. In contrast, the computation time for both heuristics, which generate approximate solutions for large-scale problems, performs well compared to the MIP solver. Nevertheless, the computation time of the MIP solver on small- to medium-scale and large-scale problems performs well compared to both heuristics when the storage capacities have higher B values (see Figure 5, Figure 6 and Figure 7 The running times for both heuristics are nearly the same due to their similar time complexity.
Therefore, considering the storage capacity constraints, both heuristics perform well under near-minimal capacity for large-scale problems, whereas the MIP solver computes efficiently with shorter running times for small- and medium-scale problems. For high storage capacity constraints (B = 5–20%), the MIP solver performs well with shorter running times across all problem scales.

5.5. Sensitivity Analysis

Authors present a sensitivity analysis on the varied parameter B to show its impact on the cost performance of the proposed heuristics, order frequency, and inventory levels. The results of this analysis are shown in Figure 8, Figure 9 and Figure 10 below.
In Figure 8, the total cost for each problem size is high when the storage capacity is near minimal, and it decreases as the storage capacity increases. Under the near-minimal storage capacity constraint, the inventory level for each problem size is low due to the limited storage space (see Figure 9). This results in more frequent orders with smaller replenishment quantities to meet all demand. The higher order frequency causes an increase in the total cost (see Figure 10). Under high storage capacity constraints, the total cost for each problem size is low, but the inventory level is higher due to the increased storage space. The order frequency is also lower in order to reduce the total cost. In summary, tight storage space leads to higher total costs due to increased order frequency. On the other hand, larger storage capacity results in lower total costs but requires higher investment to expand the storage space.

5.6. Statistical Validation of Heuristic Stability and Reliability

For validation of heuristic stability and reliability, the authors evaluate the total cost and running time of the proposed heuristic using statistical parameters such as average, standard deviation, minimum and maximum values, and confidence intervals, as shown in Table 20.
Table 20 and Table 21, all total cost and running time values fall within the lower and upper bounds of the 99.7% confidence intervals around the average values. It indicates that the heuristic’s performance is reliable, and low variability is a direct measure of its stability.

6. Conclusions

This study proposes a novel push–pull heuristic for solving the multi-item un-capacitated lot-sizing problem under near-minimal storage capacities. When capacity constraints are nearly minimal across multiple items, novel heuristics are required. Prior heuristics did not directly consider the tight storage capacity constraints. The just-in-time operation in the assembly automobile industry is difficult with regard to sharing the storage capacity on the multi-item parts. The proposed heuristic can be applied to manage tight storage capacity while keeping multiple items. To compute the initial replenishment plan, authors implement a dynamic programming based on network flow to generate a single-item lot size plan for all periods under unlimited storage capacity of each period. The push procedure identifies iteratively the maximal sum of the beginning inventory plus the replenishment quantity which moves to the next period without violating the near-minimal storage capacity. Each iteration will increase inventory cost with the ordering cost. The push and pull procedure requires fewer iterations during computation. In comparison, the Gutiérrez et al. heuristic [25] selects successive periods, resulting in more iterations and increased ordering costs to meet the near-minimal capacity constraints. The result of computation shows that the proposed heuristic performs well on the gap solution under near-minimal storage capacities. The running time of the proposed heuristic performs well on large-scale problems, whereas GAMS/CPLEX solver runs with minimal run time on small-and medium-scale problems. However, in the sensitivity analysis, a near-minimal storage capacity constraint results in high inventory costs due to the increased frequency of orders.
Future research could expand this proposed heuristic by applying and evaluating it in an assembly automobile plant to improve the practical applicability and credibility. As another extension, it could run with the stochastic demand or lead time constraints to make it applicable across a wider range of academic settings.

Author Contributions

Conceptualization, W.B., D.H. and P.C.; methodology, W.B. and D.H.; software, W.B.; validation, W.B. and D.H.; formal analysis, W.B. and D.H.; investigation, W.B. and D.H.; resources, D.H.; data curation, W.B. and D.H.; writing—original draft preparation, W.B. and D.H.; writing—review and editing, W.B., D.H. and P.C.; visualization, W.B. and D.H.; supervision, P.C.; project administration, W.B. and D.H.; funding acquisition, W.B. and D.H. All authors have read and agreed to the published version of the manuscript.

Funding

This study received no external funding.

Data Availability Statement

The data presented in this study are available from the corresponding author on request.

Acknowledgments

We, the authors, would like to express our sincere appreciation for all the constructive comments and recommendations from reviewers which led to the improved final version of this manuscript. This study was supported by the Faculty of Engineering at Kamphaeng Saen, Kasetsart University, Thailand.

Conflicts of Interest

The authors declare no conflicts of interest.

Appendix A

Pseudo code of dynamic programming based on network flow
1: PROCEDURE MultiItemLotSizing
2:  //  d[N][T]    ← demand matrix (rows: items, cols: periods)
3:  //  order[N][T]  ← fixed ordering cost matrix
4:  //  weight[N]   ← per-item weight (for capacity constraint)
5:  //  pc[N][T]   ← per-unit production cost matrix
6:  //  h       ← unit holding cost
7:  // Output:
8:  //  sol[N][T]   ← lot-sizes for each item and each period
9:  //  invencost[N] ← total inventory cost per item
10:  CONST M ← 10^10       // “infinite” penalty
11:  CONST extra ← 1       // cost offset for indexing
12:  // 1. Start iteration
13:  FOR g ← 1 TO N DO      // for each item
14:   // 2. Compute sumdemand and cumdemand
15:   FOR k ← 1 TO T DO
16:    sumdemand[g][k] ← Σ_{i=1..T} d[g][i]
17:   END FOR
18:   cumdemand[g][1] ← sumdemand[g][1]
19:   FOR k ← 2 TO T DO
20:    cumdemand[g][k] ← cumdemand[g][k−1] + sumdemand[g][k]
21:   END FOR
23:   // 3. Build DP network of size S = T + Σ_k sumdemand[g][k] + 1
24:   S ← T + Σ_{k=1..T} sumdemand[g][k] + 1
25:   ALLOCATE dcost[1..S][1..S]
27:   // 4. Fill dcost for “period 0” (building initial inventory)
28:   FOR inv ← 0 TO sumdemand[g][1] DO
29:    lot ← inv − 0 + 0
30:    IF lot > 0 THEN
31:     y ← 1
32:    ELSE
33:     y ← 0
34:    END IF
35:    dcost[1][inv+1] ← inv*h + lot*pc[g][1] + y*order[g][1] + extra
36:   END FOR
38:   // 5. Fill dcost for periods 1..T−1
39:   node_i ← 1
40:   FOR p ← 1 TO T−1 DO
41:    prev_node_i ← node_i
42:    FOR inv_prev ← 0 TO sumdemand[g][p] DO
43:     node_i ← prev_node_i + inv_prev
44:     FOR inv_curr ← 0 TO sumdemand[g][p+1] DO
45:      lot ← inv_curr − inv_prev + d[g][p]
46:      IF lot > 0 THEN
47:       y ← 1
48:      ELSE
49:       y ← 0
50:      END IF
51:      // compute holding penalty
52:      IF lot == 0 AND inv_prev − inv_curr == d[g][p] THEN
53:       hold ← inv_curr * h
54:      ELSE IF lot > 0 AND inv_prev − inv_curr + lot == d[g][p] THEN
55:       hold ← inv_curr * h
56:      ELSE
57:       hold ← M
58:      END IF
59:      // assemble cost
60:      IF hold == M THEN
61:       cost ← M
62:      ELSE
63:       cost ← hold + lot*pc[g][p] + y*order[g][p]
64:      END IF
65:      dcost[node_i][node_i + sumdemand[g][p+1] + 1] ← cost + extra
66:     END FOR
67:    END FOR
68:    node_i ← node_i + sumdemand[g][p+1] + 1
69:   END FOR
71:   // 6. Fill dcost for final period T
72:   FOR inv_prev ← 0 TO sumdemand[g][T] DO
73:    node_i ← node_i + inv_prev
74:    lot ← 0 − inv_prev + d[g][T]     // end inventory is forced to 0
75:    IF lot > 0 THEN
76:     y ← 1
77:    ELSE
78:     y ← 0
79:    END IF
80:    IF lot == 0 AND inv_prev − 0 == d[g][T] THEN
81:     hold ← 0 * h
82:    ELSE IF lot > 0 AND inv_prev − 0 + lot == d[g][T] THEN
83:     hold ← 0 * h
84:    ELSE
85:     hold ← M
86:    END IF
87:    IF hold == M THEN
88:     cost ← M
89:    ELSE
90:     cost ← hold + lot*pc[g][T] + y*order[g][T]
91:    END IF
92:    dcost[node_i][S] ← cost + extra
93:   END FOR
95:   // 7. Solve DP by backward recursion
96:   ALLOCATE fn[1..S+1] ← 0
97:   ALLOCATE fnmat[1..S][1..S]
98:   // 7.1 Initialize last column
99:   FOR i ← 1 TO S DO
100:   fnmat[i][S] ← dcost[i][S]
101:  END FOR
102:  fn[S] ← MIN_{i=1..S} fnmat[S][i]
103:  // 7.2 Recurrence
104:  FOR i ← S−1 DOWNTO 1 DO
105:   FOR j ← i TO S DO
106:    IF dcost[i][j] > 0 THEN
107:     fnmat[i][j] ← dcost[i][j] + fn[j+1]
108:    END IF
109:   END FOR
110:   fn[i] ← MIN_{j=i..S} fnmat[i][j]
111:  END FOR
113:  // 8. Trace optimal path
114:  INITIALIZE optimalsol[0..T+1][1..5] ← 0
115:  current_node ← 1
116:  FOR period ← 0 TO T DO
117:   // find next node j where fn[current_node] == fnmat[current_node][j]
118:   SELECT smallest j ≥ current_node such that fn[current_node] == fnmat[current_node][j]
119:   lot ← corresponding lot-size on arc (current_node→j)
120:   inv ← previous_inv − demand + lot
121:   optimalsol[period+1] ← (prev_inv, lot, demand, inv, arc_cost − extra)
122:   current_node ← j + 1
123:  END FOR
125:  // 9. Record item-level solution
126:  FOR p ← 1 TO T DO
127:   sol[g][p] ← max(0, optimalsol[p+1].lot)
128:  END FOR
129:  invencost[g] ← fn[1] − extra
130: END FOR
132: END PROCEDURE

References

  1. Mohammadi, M.; Shegarian, E. A Mixed Integer Linear Programming Model for the Multi-Item Uncapacitated Lot-Sizing Problem: A case study in the trailer manufacturing industry. Int. J. Multivar. Data Anal. 2017, 1, 173–199. [Google Scholar] [CrossRef]
  2. Ojeda, A. Multi-Level Production Planning with Raw-Material Perishability and Inventory Bounds. Ph.D. Thesis, Concordia University, Montreal, QC, Canada, September 2019. [Google Scholar]
  3. Emde, S. Sequencing Assembly Lines to Facilitate Synchronized Just-In-Time Part Supply. J. Sched. 2019, 22, 607–621. [Google Scholar] [CrossRef]
  4. Minner, S. A Comparison of Simple Heuristics for Multi-Product Dynamic Demand Lot-Sizing with Limited Warehouse Capacity. Int. J. Prod. Econ. 2009, 118, 305–310. [Google Scholar] [CrossRef]
  5. Wagner, H.M.; Whitin, T.M. Dynamic Version of the Economic Lot Size Model. Manag. Sci. 1958, 5, 89–96. [Google Scholar] [CrossRef]
  6. Love, S.F. Bounded Production and Inventory Models with Piecewise Concave Costs. Manag. Sci. 1973, 20, 313–318. [Google Scholar] [CrossRef]
  7. Toczylowski, E. An O (T2) Algorithm for the Lot-Sizing Problem with Limited Inventory Levels. In Proceedings of the International Conference on Emerging Technologies and Factory Automation (ETFA), Paris, France, 10–13 October 1995; pp. 78–85. Available online: https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=496709&tag=1 (accessed on 9 September 2024).
  8. Loparic, M.; Pochet, Y.; Wolsey, L.A. The Uncapacited Lot-Sizing Problem with Sales and Safety Stocks. Math. Program. 2001, 89, 487–504. [Google Scholar] [CrossRef]
  9. Sedeno-Noda, A.; Gutierrez, J.; Abdul-Julbar, B.; Sicilia, J. An O (T log T) Algorithm for the Dynamic Lot Size Problem with Limited Storage and Linear Costs. Comput. Optim. Appl. 2004, 28, 311–323. [Google Scholar] [CrossRef]
  10. Liu, X.; Tu, Y. Production Planning with Limited Inventory Capacity and Allow Stockout. Int. J. Prod. Econ. 2008, 111, 180–191. [Google Scholar] [CrossRef]
  11. Önal, M.; Heuvel, W.V.D.; Liu, T. A Note on the Economic Lot Sizing Problem with Inventory Bounds. Eur. J. Oper. Res. 2012, 223, 290–294. [Google Scholar] [CrossRef]
  12. Chu, F.; Chu, C. Single-Item Dynamic Lot-Sizing Models with Bounded Inventory and Outsourcing. IEEE Trans. Syst. Man. Hum. 2008, 38, 70–77. [Google Scholar]
  13. Hwang, H.-C.; Heuvel, W.V.D. Improved Algorithms for a Lot-Sizing Problem with Inventory Bounds and Backlogging. Nav. Res. Logist. 2012, 59, 244–253. [Google Scholar] [CrossRef]
  14. Hwang, H.-C.; Heuvel, W.V.D.; Wagelmans, A.P.M. The Economic Lot- Sizing Problem with Lost Sales and Bounded Inventory. IIE Trans. 2013, 45, 912–924. [Google Scholar] [CrossRef]
  15. Boonphakdee, W.; Charnsethikul, P. Column Generation Approach for Solving Uncapacitated Dynamic Lot-Sizing Problems with Time-Varying Cost. Int. J. Math. Oper. Res. 2022, 23, 55–75. [Google Scholar] [CrossRef]
  16. Atamtürk, A.; Küçükyavuz, A. Lot Sizing with Inventory Bounds and Fixed Costs: Polyhedral Study and Computation. Oper. Research. 2005, 53, 711–730. [Google Scholar] [CrossRef]
  17. Gutiérrez, J.; Sedeño-Noda, A.; Colebrook, M.; Sicilia, J. A Polynomial Algorithm for the Production/Ordering Planning Problem with Limited Storage. Comput. Oper. Res. 2007, 34, 934–937. [Google Scholar] [CrossRef]
  18. Guan, Y.; Liu, T. Stochastic Lot-Sizing Problem with Inventory-Bounds an Constant Order-Capacities. Eur. J. Oper. Res. 2010, 207, 1398–1409. [Google Scholar] [CrossRef]
  19. Chu, C.; Chu, F.; Zhong, F.; Yang, S. A Polynomial Algorithm for a Lot-Sizing Problem with Backlogging, Outsourcing, and Limited Inventory, Comput. Ind. Eng. 2013, 64, 200–210. [Google Scholar] [CrossRef]
  20. Brahimi, N.; Absi, N.; Dauzère-Pérès, S.; Kedad-Sidhoum, S. Models and Lagrangian Heuristics for a Two-Level Lot-Sizing Problem with Bounded Inventory. OR Spectr. 2015, 37, 983–1006. [Google Scholar] [CrossRef]
  21. Di Summa, M.; Wolsey, L.A. Lot-Sizing with Stock Upper Bounds and Fixed Charges. SIAM J. Discret. Math. 2010, 24, 853–875. [Google Scholar]
  22. Dixon, P.S.; Poh, C.L. Heuristic Procedures for Multi-Item Inventory Planning with Limited Storage. IIE Trans. 1990, 22, 112–123. [Google Scholar] [CrossRef]
  23. Park, Y.B. An Integrated Approach for Production and Distribution Planning in Supply Chain Management. Int. J. Prod. Res. 2005, 43, 1205–1224. [Google Scholar] [CrossRef]
  24. Akbalik, A.; Penz, B.; Rapine, C. Multi-Item Uncapacitated Lot Sizing Problem with Inventory Bounds. Optim. Lett. 2015, 9, 143–154. [Google Scholar] [CrossRef]
  25. Gutiérrez, J.; Colebrook, M.; Abdul-Jalbar, B.; Sicilia, J. Effective Replenishment Policies for the Multi-Item Dynamic Lot-Sizing Problem with Storage Capacities. Comput. Oper. Res. 2013, 40, 2844–2851. [Google Scholar] [CrossRef]
  26. Melo, R.A.; Ribeiro, C.C. Formulations and Heuristics for the Multi-Item Uncapacitated Lot-Sizing Problem with Inventory Bounds. Int. J. Prod. Res. 2015, 55, 576–592. [Google Scholar] [CrossRef]
  27. Witt, A. A Heuristic for the Multi-Level Capacitated Lot Sizing Problem with Inventory Constraints. Int. J. Manag. Sci. Eng. Manag. 2019, 14, 249–252. [Google Scholar]
  28. MATLAB. Heuristic for the Multi-Item Lot-Sizing with Storage Cap. MATLAB Central File Exchange. Available online: https://www.mathworks.com/matlabcentral/fileexchange/179289-heuristic-for-the-multi-item-lot-sizinng-with-storage-cap (accessed on 18 January 2025).
  29. MATLAB. Heurictic of Gutierrez et al. 2013 Algorithm. MATLAB Central File Exchange. Available online: https://www.mathworks.com/matlabcentral/fileexchange/179294-heurictic-of-gutierrez-et-al-2013-algorithm (accessed on 18 January 2025).
  30. CPLEX Solver. Available online: https://documentation.aimms.com/platform/solvers/cplex.html (accessed on 23 December 2024).
  31. MATLAB. Smoothing Heuristic Multi-Item Lot Size with Storage Cap. MATLAB Central File Exchange. Available online: https://www.mathworks.com/matlabcentral/fileexchange/181148-smoothing-heuristic-multi-item-lot-size-with-storage-cap (accessed on 15 May 2025).
Figure 1. Flow chart of the push method.
Figure 1. Flow chart of the push method.
Computation 13 00148 g001
Figure 2. Flow chart of the pull method.
Figure 2. Flow chart of the pull method.
Computation 13 00148 g002
Figure 3. Average solution gap of both heuristics under storage capacities when parameter B = 1, 5, 10, and 20%.
Figure 3. Average solution gap of both heuristics under storage capacities when parameter B = 1, 5, 10, and 20%.
Computation 13 00148 g003
Figure 4. Average computation time with near-minimal storage capacity (B = 1%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25] and GAMS/CPLEX solver.
Figure 4. Average computation time with near-minimal storage capacity (B = 1%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25] and GAMS/CPLEX solver.
Computation 13 00148 g004
Figure 5. Average computation time with near-minimal storage capacity (B = 5%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25], and GAMS/CPLEX solver.
Figure 5. Average computation time with near-minimal storage capacity (B = 5%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25], and GAMS/CPLEX solver.
Computation 13 00148 g005
Figure 6. Average computation time with near-minimal storage capacity (B = 10%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25], and GAMS/CPLEX solver.
Figure 6. Average computation time with near-minimal storage capacity (B = 10%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25], and GAMS/CPLEX solver.
Computation 13 00148 g006
Figure 7. Average computation time with near-minimal storage capacity (B = 20%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25], and GAMS/CPLEX solver.
Figure 7. Average computation time with near-minimal storage capacity (B = 20%) using the push and pull heuristic, the Gutiérrez et al. heuristic [25], and GAMS/CPLEX solver.
Computation 13 00148 g007
Figure 8. Total cost vs. storage capacity parameter B (1–20%) for different problem scales.
Figure 8. Total cost vs. storage capacity parameter B (1–20%) for different problem scales.
Computation 13 00148 g008
Figure 9. Inventory level vs. storage capacity parameter B (1–20%) for different problem scales.
Figure 9. Inventory level vs. storage capacity parameter B (1–20%) for different problem scales.
Computation 13 00148 g009
Figure 10. Order frequency vs. storage capacity parameter B (1–20%) for different problem scales.
Figure 10. Order frequency vs. storage capacity parameter B (1–20%) for different problem scales.
Computation 13 00148 g010
Table 1. A systematic overview of heuristics and MIP-based approaches.
Table 1. A systematic overview of heuristics and MIP-based approaches.
ReferencesModel.Stor.Algo.Cap.
Dixon and Poh [22]I&PBegInv.DP.&Heu.Limit.Inv.
Park [23]I&P&R&VEndInv.LR.Heu. Limit.Inv&P&R
Akbalik et al. [24]I&PEndInv.DP.Limit.Inv.
Gutiérrez et al. [25]I&PBegInv.DP.&Heu.Limit.Inv.
Melo and Ribeiro [26]I&P&PT&VEndInv.LP.R.Heu.&Heu.Limit.Inv.
Witt [27]I&PEndInv.Heu.Limit.Inv.
Abbreviations: Model. Model formulation I&P = inventory and production constraints. I&P&R&V = inventory, production, retailer and vehicle constraints I&P&PT&V = inventory, production, production time and vehicle constraints. Stor. Storage capacity EndInv. = ending inventory. BegInv. = sum of beginning inventory and replenishment. Algo. Algorithm DP. = Dynamic programming. DP.&Heu. = Dynamic programming and heuristic. LR.Heu. = Lagrangian-relaxation-based heuristic. LP.Heu.&Heu = Linear programming-relaxation-based heu-ristic and heuristic. Heu. = Heuristic. Cap. Capacity. Limit.Inv = Limited inventory. Limit.Inv&P&R = Limited inventory, plant and vehicle.
Table 2. A simple example by Gutiérrez et al. [25].
Table 2. A simple example by Gutiérrez et al. [25].
Periods t12345
Ut756673633758608
Item 1, w1 = 1
d1,t11511496106136
D1,t567452338242136
f1,t595100969240945
p1,t479104
h1,t11111
Item 2, w1 = 4
d2,t8752111142118
D2,t510423371260118
f2,t255696125637249
p2,t33084
h2,t11111
Table 3. Initial solution for each item.
Table 3. Initial solution for each item.
Periods tItem12345
Replenished plan15670000
2139037100
Inventory14523382421360
25202601180
Inventory cost1(4 × 567) + (1 × 452) + 595
= 3315
3382421360
2(3 × 139) + (1 × 52) + 255 = 72403851180
Sum of inventory and replenishment (SIR)1567 × 1 = 567452338242136
2139 × 4 = 55620814841040472
SIRallitems112366018221282608
SC756673633758608
SIRallitems_U+367−1311895240
Table 4. Execution flow of iteration 1 for period 1 using the push method.
Table 4. Execution flow of iteration 1 for period 1 using the push method.
Periods tItem12345
Replenished plan1567 − 136 = 431000136
2139037100
Ending
inventory
131620210600
25202601180
Inventory cost1(4 × 431) + (1 × 316) + 595
= 2635
20210601489
272403851180
Sum of
inventory and
replenishment (SIR)
11 × 431 = 431316202106136
255620814841040472
SIRallitems 98752416861146608
SC 756673633758608
SIRallitems_U +231−149+1053+3880
Table 5. Execution flow of iteration 2 for period 1 using the push method.
Table 5. Execution flow of iteration 2 for period 1 using the push method.
Periods tItem12345
Replenished plan1431000136
2139 − 52
= 87
5237100
Ending
inventory
131620210600
2002601180
Inventory cost1263520210601489
2(3 × 87) + 255
= 516
(3 × 52) + 696
= 852
(3 × 371) + (1 × 260) + 125
= 385
1180
Sum of
inventory and
replenishment (SIR)
1431316202106136
24 × 87 = 3484 × 87=20814841040472
SIRallitems 77952416861146608
SC 756673633758608
SIRallitems_U +23−149+1053+3880
Table 6. Execution flow of iteration 3 for period 1 using the push method.
Table 6. Execution flow of iteration 3 for period 1 using the push method.
Periods tItem12345
Replenished plan1431 − 106 = 32500106136
2875237100
Ending inventory121096000
2002601180
Inventory cost14 × 325 + 1 × 210 + 595
= 2105
96013001489
25168523851180
Sum of
inventory and replenishment (SIR)
132521096106136
234820814841040472
SIRallitems 67341815801146608
SC 756673633758608
SIRallitems_U −83−255+947+3880
Table 7. Execution flow of iteration 1 for period 3 using the push method.
Table 7. Execution flow of iteration 1 for period 3 using the push method.
Periods tItem12345
Replenished plan132500106136
28752371 − 118 = 2530118
Ending inventory121096013001489
20014200
Inventory cost1210596013001489
2516852(1 × 142) + 125 = 2670721
Sum of
inventory and replenishment (SIR)
132521096106136
23482084 × 253 = 1012568472
SIRallitems 6734181108674608
SC 756673633758608
SIRallitems_U −83−255+475−840
Table 8. Execution flow of iteration 2 for period 3 using the push method.
Table 8. Execution flow of iteration 2 for period 3 using the push method.
Periods tItem12345
Replenished plan132500106136
28752253 − 142 = 111142118
Ending
inventory
121096000
200000
Inventory cost1210596013001489
25168521258 × 142 + 637
= 1773
721
Sum of
inventory and replenishment (SIR)
132521096106136
23482084 × 111 = 444568472
SIRallitems673418540674608
SC756673633758608
SIRallitems_U−83−255−93−840
Table 9. Execution flow in steps 1 to 4 using the pull method.
Table 9. Execution flow in steps 1 to 4 using the pull method.
Periods tItem12345
Replenished
plan
132500106136
287 + 52
= 139
52 − 52
= 0
111142118
Ending
inventory
121096000
2520000
Inventory cost1210596013001489
2(3 × 139) + (1 × 52) + 255
= 724
01251773721
Sum of inventory and replenishment (SIR)11 × 325
= 325
21096106136
24 × 139
= 556
208444568472
SIRallitems 881418540674608
SC 756673633758608
SIRallitems_U +125−255−93−840
Table 10. Execution flow in steps 5 to 8 using the pull method.
Table 10. Execution flow in steps 5 to 8 using the pull method.
Periods tItem12345
Replenished
plan
1325 − 125
= 200
0 + 125 = 1250106136
21390111142118
Ending
inventory
18596000
2520000
Inventory cost1(4 × 200) + (1 × 85) + 595
= 1480
1071013001489
272401251773721
Sum of
inventory and
replenishment (SIR)
11 × 200
= 200
21096106136
2556208444568472
SIRallitems 756418540674608
SC 756673633758608
SIRallitems_U 0−255−93−840
Table 11. Replenished plan solved by Gutiérrez et al. [25] and smoothing method [22].
Table 11. Replenished plan solved by Gutiérrez et al. [25] and smoothing method [22].
Gutiérrez et al. [25]Inventory Cost
Period12345
Item 120012501061365340
213901111421183343
Total inventory cost8683
Dixon and Poh [22]Inventory cost
Period12345
Item 111521001061365510
287521111421183987
Total inventory cost9497
Table 12. A simple example by formatted data of Minner [4].
Table 12. A simple example by formatted data of Minner [4].
Periods t123456
Ut1161529768973721806
Item 1, w1 = 2
d1,t44476467679
f196
p16
h11
Item 2, w2 w2= 5
d2,t832136877088
f274
p210
h21
Item 3, w1 w3= 4
d3,t881258653987
f367
p39
h31
Table 13. Total cost and gap solution obtained by the proposed heuristic, Gutiérrez et al. [25] and smoothing [22].
Table 13. Total cost and gap solution obtained by the proposed heuristic, Gutiérrez et al. [25] and smoothing [22].
Heuristics/MIP SolverGAMS/
CPLEX
Push and PullGutiérrez et al. [25]Smoothing [22]
Total cost9928992810,05410,030
% Gap solution001.271.02
No. of additional
orders
0344
Table 14. Formatting parameters.
Table 14. Formatting parameters.
Number of Periods, T61224
Number of items, N10, 20, 40, 60, 80, …, 16010, 20, 30, …, 8010, 20, …, 160
Number of instances10105
Weight distribution, w i Uniform, w i ~ [ 1 , 10 ]
Demand distribution, d i , t Uniform, d i , t ~ [ 30 , 150 ]
Ordering cost distribution, f i , t Uniform, f i , t ~ [ 100 , 150 ]
Inventory bounds, Ut A = n = 1 N w i d i , t ,   U t = A + B ( n = 1 N w i D i , t + 1 ) ,
B = {1%, 5%, 10%, 20%}
Cost of procuring raw materials, pi,t = zero and holding cost, hi,t = 1
Table 15. Computation times and solution gaps with near-minimal storage capacity using parameter B = 1%.
Table 15. Computation times and solution gaps with near-minimal storage capacity using parameter B = 1%.
N × TAvg. Push and Pull
Heuristic Time (s.)
Avg.
Gutiérrez’s Heuristic Time (s.)
Avg. GAMS/CPLEX Time (s.)Min. Gap (%)Max. Gap (%)Avg. Gap (%)
Push and Pull HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s Heuristic
10 × 66.266.240.490.000.212.773.780.571.89
20 × 6611.4511.160.880.381.035.298.301.04
40 × 621.9021.242.560.282.870.885.020.723.48
60 × 632.4830.995.310.442.241.054.530.823.57
80 × 644.2541.817.270.672.651.134.470.913.44
100 × 656.2451.9111.920.473.141.174.990.923.82
120 × 669.4260.8212.280.552.901.154.600.893.64
140 × 684.9971.3315.840.523.031.765.050.944.07
160 × 6100.7281.9857.130.042.988.5111.902.085.09
36.7334.536.26 1.163.99
10 × 1261.8564.780.850.222.541.327.270.795.36
20 × 12131.74140.633.670.732.441.687.311.234.53
30 × 12204.64216.348.571.244.211.937.171.515.66
40 × 12260.38273.5539.661.084.141.897.851.425.54
50 × 12328.35321.7774.411.154.891.776.641.395.71
60 × 12409.28458.70102.651.184.981.906.161.395.65
70 × 12495.31679.99380.500.234.971.466.771.245.61
80 × 12520.24537.582388.11.214.221.486.561.305.67
271.5370.23333.20 1.335.57
10 × 243037.373429.142.310.956.04 **1.587.73 **1.276.89 **
20 × 246507.965765.7359.681.587.16 *2.207.16 *1.837.16 *
30 × 247303.468694.353549.21.117.42 *2.217.421.847.42 *
40 × 2412,903.5513,484.4057,788.20.917.49 *2.077.49 *1.547.49 *
5994.425357.8812,280 1.667.30
*, ** One and two instances, 10 × 6–160 × 6 small-scale problem, 10 × 12–80 × 12 medium-scale problem, and 10 × 24–40 × 24 large-scale problem.
Table 16. Computation times and solution gaps when parameter B = 5%.
Table 16. Computation times and solution gaps when parameter B = 5%.
N × TAvg. Push and Pull
Heuristic Time (s.)
Avg.
Gutiérrez’s Heuristic Time (s.)
Avg. GAMS/CPLEX Time (s.)Min. Gap (%)Max. Gap (%)Avg. Gap (%)
Push and Pull HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s Heuristic
10 × 65.655.670.560.000.773.336.541.393.96
20 × 69.7710.361.040.891.662.359.301.595.33
40 × 621.4123.145.911.233.272.238.201.726.46
60 × 62931.9910.341.005.132.329.231.737.31
80 × 635.1336.2827.421.003.982.598.531.766.88
100 × 644.6546.0333.740.925.841.808.291.606.83
120 × 653.2054.5529.791.485.532.117.681.586.71
140 × 663.2364.9657.330.924.891.856.951.536.23
160 × 672.5876.8533.790.985.482.888.211.706.29
29.1130.3318.43 1.646.56
10 × 1271.5262.860.890.620.962.4912.531.477.01
20 × 12142.7132.492.330.732.181.627.891.214.69
30 × 12189.3213.943.900.651.501.357.761.024.91
40 × 12254.2256.257.000.632.901.236.240.934.38
50 × 12319.9339.7514.920.640.131.015.380.883.96
60 × 12417.6422.9718.730.662.911.275.620.934.30
70 × 12498.1526.0236.400.692.991.185.360.873.94
80 × 12523.7519.1524.030.672.111.156.650.824.01
272.22368.0812.03 0.924.43
10 × 241398.71578.050.450.141.681.685.010.943.19
20 × 246592.97140.056.220.311.620.793.080.592.48
30 × 249608.89364.5947.160.241.060.802.460.581.95
40 × 2412,824.713,504.561.940.221.910.583.070.402.60
8117.588465.865.98 0.552.41
10 × 6–160 × 6 small-scale problem, 10 × 12–80 × 12 medium-scale problem, and 10 × 24–40 × 24 large-scale problem.
Table 17. Computation times and solution gaps when parameter B = 10%.
Table 17. Computation times and solution gaps when parameter B = 10%.
N × TAvg. Push and Pull
Heuristic Time (s.)
Avg.
Gutiérrez’s Heuristic Time (s.)
Avg. GAMS/CPLEX Time (s.)Min. Gap (%)Max. Gap (%)Avg. Gap (%)
Push and Pull HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s Heuristic
10×65.835.640.310.000.021.7112.280.844.93
20 × 610.1010.190.420.440.731.6213.441.115.00
40 × 620.4022.222.350.512.292.166.551.124.66
60 × 629.5128.042.040.542.121.887.131.103.97
80 × 635.2336.344.820.502.551.555.871.014.30
100 × 644.6845.507.190.482.001.286.220.874.06
120 × 654.6154.7411.240.632.194.055.381.124.06
140 × 662.9163.747.350.582.651.065.100.803.40
160 × 673.6873.687.300.562.452.045.250.963.63
29.2529.63.97 0.933.92
10 × 1266.4162.410.450.040.311.744.260.741.74
20 × 12141.27132.110.690.250.250.864.260.571.58
30 × 12187.59210.501.250.391.171.113.270.591.86
40 × 12264.08256.142.230.360.450.742.320.481.42
50 × 12325.22317.782.910.261.020.642.920.461.67
60 × 12414.79408.413.130.280.200.633.220.472.01
70 × 12496.28495.385.750.311.430.772.730.481.98
80 × 12517.69524.166.430.321.410.612.330.451.85
272.6358.762.58 0.491.81
10 × 243177.713508.170.531.601.082.522.650.561.74
20 × 246924.877841.101.720.980.881.901.740.451.15
30 × 249188.509681.132.380.140.280.451.820.311.10
40 × 2413,527.0613,764.703.320.161.030.651.780.341.24
8278.518773.252.14 0.381.23
10 × 6–160 × 6 small-scale problem, 10 × 12–80 × 12 medium-scale problem, and 10 × 24–40 × 24 large-scale problem.
Table 18. Computation times and solution gaps when parameter B = 20%.
Table 18. Computation times and solution gaps when parameter B = 20%.
N × TAvg. Push and Pull
Heuristic Time (s.)
Avg.
Gutiérrez’s Heuristic Time (s.)
Avg. GAMS/CPLEX Time (s.)Min. Gap (%)Max. Gap (%)Avg. Gap (%)
Push and Pull HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s HeuristicPull and Push HeuristicGutiérrez ’s Heuristic
10×65.855.710.290.000.652.504.830.832.48
20 × 610.0210.250.340.090.141.512.180.681.18
40 × 622.2222.941.740.261.071.292.400.571.76
60 × 629.5429.660.870.201.211.142.340.601.75
80 × 635.2435.710.900.441.181.032.170.621.71
100 × 645.1845.342.020.311.140.842.070.611.71
120 × 653.9055.091.870.361.530.891.530.651.72
140 × 662.9964.381.660.471.670.922.750.671.97
160 × 673.1374.911.810.351.531.662.820.761.87
37.5638.221.28 0.661.79
10 × 1236.1432.010.280.000.001.072.340.390.65
20 × 1271.5562.070.450.000.000.881.650.340.91
30 × 12185.60205.130.520.120.250.761.420.370.87
40 × 12264.97258.890.700.170.600.491.240.360.92
50 × 12330.85322.591.200.190.610.532.380.351.03
60 × 12491.05501.273.970.200.610.471.300.330.94
70 × 12491.05501.273.970.200.610.471.300.330.94
80 × 12515.24541.882.100.250.590.441.160.340.84
264.63358.401.61 0.360.87
10 × 243018.943196.810.630.820.081.641.070.340.60
20 × 247084.676422.941.140.170.162.410.730.280.47
30 × 249889.419612.801.400.150.380.610.750.310.57
40 × 2413,706.4912,863.771.780.130.410.310.730.200.56
8506.378101.122.12 0.270.55
10 × 6–160 × 6 small-scale problem, 10 × 12–80 × 12 medium-scale problem, and 10 × 24–40 × 24 large-scale problem.
Table 19. Gap performance of the proposed Gutiérrez et al.and smoothing heuristics under storage capacities with parameter B = 1%, 5%, 10%, and 20%.
Table 19. Gap performance of the proposed Gutiérrez et al.and smoothing heuristics under storage capacities with parameter B = 1%, 5%, 10%, and 20%.
Parameter BThe Push and Pull Heuristic
Problem Size10 × 6 Small-Scale
Problem
10 × 12
Medium- Scale Problem
10 × 24 Large-Scale
Problem
1%Avg.0.570.791.27
Max.0.731.321.58
5%Avg.1.391.470.94
Max.2.622.491.27
10%Avg.0.850.740.56
Max.1.811.741.2
20%Avg.1.840.340.34
Max.2.50.881.64
Gutiérrez et al. heuristic [25]
1%Avg.1.895.366.89
Max.3.517.277.73
5%Avg.3.9670.94
Max.6.5411.841.04
10%Avg.4.921.741.74
Max.12.284.262.65
20%Avg.2.480.650.6
Max.4.832.341.07
Smoothing heuristic [22]
1%Avg.1.894.245.97
Max.3.46.246.79
5%Avg.3.964.682.3
Max.6.547.532.46
10%Avg.4.132.042.8
Max.9.833.518.46
20%Avg.1.70.730.77
Max.3.351.531.35
Table 20. Statistics parameters of total cost computed by the push and pull methods under near-minimal storage capacities (B = 1%).
Table 20. Statistics parameters of total cost computed by the push and pull methods under near-minimal storage capacities (B = 1%).
ProblemAverage
(Currency)
Standard DeviationLower Confidence Interval (a)Upper Confidence Interval (a)Min. Total CostMax. Total Cost
10 × 67378.6158.16904.47852.771147640
20 × 614,570261.213,786.215,353.7914,20015,081
40 × 629,012.2340.227,991.630,032.828,40929,498
60 × 643,445400.042,244.944,645.142,93043,941
80 × 658,025.2544.156,393.159,657.357,05958,883
100 × 672,482.8565.970,784.974,180.671,49873,354
120 × 686,833607.585,010.588,655.585,55187,392
140 × 6101,220.8645.999,282.9103,158.799,805101,875
160 × 6115,562.2710.6113,430.5117,693.9114,175116,367
10 × 1214,405.9184.013,853.814,957.914,16014,742
20 × 1228,599.9232.327,902.929,296.928,13428,871
30 × 1242,776.4329.641,787.743,765.142,10643,239
40 × 1256,862.5365.555,765.957,959.156,16657,551
50 × 1270,941.3335.169,936.171,946.570,39371,384
60 × 1285,055.2584.183,302.986,807.583,92885,927
70 × 1299,057.1546.997,416.1100,698.197,85199,605
80 × 12113,184.8514.6111,641.1114,728.5112,018114,040
10 × 2427,987335.126,981.628,992.427,72228,410
20 × 2455,547.6460.654,165.756,929.554,82056,051
30 × 2482,909476.881,478.784,339.382,59083,730
40 × 24110,034.8762.3107,748.0112,321.6108,971111,105
(a) Lower and upper confidence interval = x ¯ ± 3   s with 99.7% confidence interval, s = standard deviation.
Table 21. Statistics parameters of running time computed by the push and pull methods under near-minimal storage capacities (B = 1%).
Table 21. Statistics parameters of running time computed by the push and pull methods under near-minimal storage capacities (B = 1%).
ProblemAverage
(Second)
Standard
Deviation
Lower Confidence Interval (a)Upper Confidence Interval (a)Min. Total CostMax. Total Cost
10 × 66.250.544.637.885.797.59
20 × 611.450.3110.5312.3811.0412.02
40 × 621.900.3720.7823.0421.3722.54
60 × 632.480.4631.0933.8731.7533.17
80 × 644.250.9341.4547.0543.0445.86
100 × 656.240.9453.4359.0555.0257.71
120 × 669.421.2665.6573.1867.9071.21
140 × 684.982.4977.5292.4682.4191.25
160 × 6100.721.4696.35105.0998.57103.74
10 × 1261.855.2746.0377.6855.4871.94
20 × 12131.744.84117.23146.26126.34141.33
30 × 12204.6316.03156.53252.74182.15236.27
40 × 12260.3823.67189.36331.41229.37311.10
50 × 12328.3534.155225.89430.82279.38402.51
60 × 12409.2840.99286.31532.24351.43492.47
70 × 12495.3140.97372.41618.22443.17585.65
80 × 12520.2426.18441.69598.79478.54566.50
10 × 243257.11608.491431.635082.592647.194108.03
20 × 246507.96340.9954857530.926159.206964.99
30 × 249103.45416.017855.4310,351.488471.779610.50
40 × 2414,628.151370.0310,518.0518,738.2511,694.7914,786.62
(a) Lower and upper confidence interval = x ¯ ± 3   s with 99.7% confidence interval, s = standard deviation.
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Boonphakdee, W.; Hirunyasiri, D.; Charnsethikul, P. Effective Heuristics for Solving the Multi-Item Uncapacitated Lot-Sizing Problem Under Near-Minimal Storage Capacities. Computation 2025, 13, 148. https://doi.org/10.3390/computation13060148

AMA Style

Boonphakdee W, Hirunyasiri D, Charnsethikul P. Effective Heuristics for Solving the Multi-Item Uncapacitated Lot-Sizing Problem Under Near-Minimal Storage Capacities. Computation. 2025; 13(6):148. https://doi.org/10.3390/computation13060148

Chicago/Turabian Style

Boonphakdee, Warut, Duangrat Hirunyasiri, and Peerayuth Charnsethikul. 2025. "Effective Heuristics for Solving the Multi-Item Uncapacitated Lot-Sizing Problem Under Near-Minimal Storage Capacities" Computation 13, no. 6: 148. https://doi.org/10.3390/computation13060148

APA Style

Boonphakdee, W., Hirunyasiri, D., & Charnsethikul, P. (2025). Effective Heuristics for Solving the Multi-Item Uncapacitated Lot-Sizing Problem Under Near-Minimal Storage Capacities. Computation, 13(6), 148. https://doi.org/10.3390/computation13060148

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop