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

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, although the unit price of a raw material unit is low. If raw materials have many different items and stock-keeping units (SKUs), it results in complex problems. Supply chain management decisions depend on the procurement policy of the organization. It comprises operating on minimum inventory cost while considering whether or not to use an expanded storage. 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 inventory is over, it must be kept in another area, such as the production line; notwithstanding, this result is with late disbursement, lost materials, and incorrect counting of the number of remaining materials. 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 [11], raw-material perishability in composites [22] 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 [26], 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, such as: the number of ending inventory only, and the sum of the number for the beginning inventory and replenishment. Firstly, most researchers proposed the storage capacity to be based on the number of ending inventory only. Secondly, other researchers introduced the storage capacity to be 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 the real world problem, raw material stores usually receive the replenishment at the beginning of the period and keep the inventory of the previous period together to be not 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 ending inventory, and the other on the sum of 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 [18] in 1958. In his seminal paper, he presented a mathematical model for the dynamic lot-sizing problem, which develop in production planning and inventory control. Meanwhile,Wagner and Whitin [19] 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 have been implemented by various researches to solve the single-item dynamic lot size problem. Love [1] 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(T³) 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 [21] presented an efficient O(T²) algorithm for the general single-item dynamic lot-sizing problem with limited inventory levels and nonzero initial and safety stock levels. Loparic et al. [2] 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. [12] 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 [13] 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 O(T³). Önal et al. [5] modified dynamic programming procedure that restores optimality for the general bounded-inventory lot- sizing problem in O(T²). However, this study did not include any computational experiments to validate the practical performance of the corrected method. Chu and Chu [14] proposed the dynamic programming approach for the inventory-bounded outsourcing and inventory-bounded outsourcing models. These models execute overall complexity time with O(T² log T) and O(T²), respectively. The limitation of this approach is impractical for planning horizons longer than a few dozen periods. Hwang and Heuvel [15] presented the O(T²) algorithm based on dynamic programming and the Monge property for solving a dynamic lot-sizing problem with backlogging and inventory bounds when 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. [16] developed the first polynomial-time O(T⁴) 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 [23] 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 [3] 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.[20] extended the classical Wagner–Whitin model by time-varying storage capacities and allowing backlogging. They developed a dynamic programming algorithm with time complexity of O(T³), 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 [4] 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(T²) and O(T²nLogT), respectivity, 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. [6] 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(T³) 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.[8] 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⋅T²+T⋅I_max), where I_max 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 [24] 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 [27] proposed the smoothing approach. They developed the push and pull operations if all weight or volume of 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 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 [25] 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. [7] improved the dynamic programming running in O (2ⁿTⁿ⁺¹) time with a polynomial growth rate if the number of items (n) is fixed to solve the MULSP-IB. However, the Tⁿ⁺¹ factor makes the algorithm impractical for larger multi-item instances. Gutiérrez et al. [17] extended the smoothing technique of Dixon and Poh[27]. 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 [9] 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[10] 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 on the case of tight capacity constraints. Therefore, the authors are interested in near-minimal storage capacity constraints, which occur in the automotive assembly industry [26].

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 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 [23] 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 by the modified push and pull operation. It improves comparison with the push operation by Gutiérrez et al. shown in Section 3, and this heuristic is examined by Gutiérrez’s example 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 Gutiérrez et al.’s algorithm 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 d_it 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 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. This means that the inventory at the beginning of a period plus the replenish-ment 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 the demands are satisfied at the end of the period.

Assumption 4. Number of items is independent of the quantity of demand and the number of procurement planning horizon.

Assumption 5. Initial inventory in the first period and ending inventory in the last period are zero.

Assumption 6. Backlogging is not allowed.

Assumption 7. There is no consideration of lead time.

2.3. Decision Variables and Parameters

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 d_it the demand of item i at period t

D_i,t the accumulative demand of item i from period t to period T

f_i,t the fixed ordering cost of item i at period t

h_i,t the holding cost of item i at period t

p_i,t the cost of procuring raw materials of item i at period t

I_i,t the inventory level of item i at period t

w_i the unit weight of item i

U_t the storage capacity at period t

Decision variables x_i,t the procurement quantity of item i at period t Y_i,t if the replenishment of item i at period t occurs, Y_it is 1. Otherwise, Y_it is 0.

2.4 Mathematical Model

his study proposes the model by Gutiérrez et al. [17], which states the MIP formulation as follows:

(1)

(2)

(3)

(4)

(5)

(6)

(7)

The objective function of MULSP-IB minimizes the sum of ordering, 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 are always kept first, before moving to production/customers following its demand in constraint (3). Constraint (4) link the purchased variables with the binary variables Y_it and accumulated demand ($D_{it}={\displaystyle \sum _{k=t}^T{d}_{ik}}$) 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, Y_it is 1. Otherwise, Y_it is 0.

3. The Proposed Heuristic

The push and pull strategies of Dixon and Poh [27] consider that excess storage capacity 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 (SIR_allitems) 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 SIR_{al litems} is less than the storage capacity, called the pull strategy. The push method focuses on reducing SIR_allitems in the existing period until success only. Therefore, each iteration enables the reduction of SIR_allitems prominently, while ordering cost will grow as necessary, causing total inventory cost to expand as necessary. Furthermore, Gutiérrez et al.’s he ristic extend the push strategy in so far that a replenishment quantity can be moved from any period t to t+k,$k\in (1,\mathrm{...},T-t)$. For any iteration, Gutiérrez et al.’s heuristic possibly moves a replenishment quantity from a non-existing period to the next period, resulting inSIR_allitems in the existing period not also reducing. However, ordering costs still expanding is unnecessary. 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 (SIR_max). Consider an item of SIR_max condition, called iSIR_max that has an inventory cost of zero at period t+k,$k\in (1,\mathrm{...},T-t)$called on t_zero. 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 t_zero. After that, the replenishment quantity of the existing item is balanced for all periods. It runs repeatedly until all SIR_allitems are less than storage capacities. This procedure is called the push method.

For the pull strategy, find the periods (t_min and t_max) with the minimum and maxi mum differences between SIR_allitems and their storage capacities (U), called SIR_allitems_U_min and SIR_allitems_U_max. If the index of period t_min is higher than the index of period t_max, consider a SIR_min item called iSIR_min for period t_min. Return the replenished quantity, which is the demand of iSIR_min of period t_min, to add the original replenished quantity of the same item at period t_max. Then, calculate all SIR_allitems again. If a new SIR_allitems for period t_max is still greater than storage capacity at that period, find a new item with SIR_max called iSIR_max. Next, determine the period t_zero on iSIR_max and calculate the round-up of the new SIR_allitems_U for period t_max divided by its weight, called SIR_allitems_U_roundup. Move the replenished quantity, SIR_allitems_U_roundup for period t_max, to period t_zero. 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 t_zero on iSIR_max and calculate the round-up of the new SIR_allitems_U for period t_max divided by its weight, called SIR_allitems_U_roundup. Move the replenished quantity, SIR_allitems_U_roundup for period t_max, to period t_zero. 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 (SIR_allitems) 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\in (1,\mathrm{...},T-t)$, then ${\displaystyle \sum _{i=1}^N(I_{i,t-1}+x_{i,t})<U_t}$.

Proof of Theorem 1.

For a contradiction method, the assumption is ${\displaystyle \sum _{i=1}^N(I_{i,t-1}+x_{i,t})\ge 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}\ne D_{i,t}-D_{i,t+k}$, $k\in (1,\mathrm{...},T-t)$, then ${\displaystyle \sum _{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 ${\displaystyle \sum _{i=1}^N(I_{i,t-1}+x_{i,t})\ne U_t}$. In the case of ${\displaystyle \sum _{i=1}^N(I_{i,t-1}+x_{i,t})<U_t}$, given $I_{i,t-1}+x_{i,t}\ne 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 ${\displaystyle \sum _{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}\ne 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-algorithms as follows:

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, pseudo code of dynamic programming based on network flow can be shown in Appendix A.1. The logical sequence including selection rules of the push method can be explained in Figure 1.

In Figure 1, the algorithm stops computing if the difference (diff) between the sum of previous inventory plus replenishment quantity (SIR_alitem) 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, dynamic programming based on network flow algorithm has time complexity $O(NT{D}_{\max }^2)$ that depends on D_max​, 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\cdot T\cdot 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 period to the previous period so that the sum of inventory and 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 algorithms as follows

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, orderingCosts)

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(N²T²) 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), 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. [17] 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 [22]. 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, SIR_allitems values of periods 1, 3, and 4 are positive and their SIR_allitems 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 (SIR_max) of 567, and find period t_zero = 5 on item 1, which has an inventory cost of zero.
• Insert the replenished quantity, which equals the demand of item 1 for period t_zero =
• 136 units, on a replenished plan on item 1 for period t_zero. 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,SIR_allitems, SIR_allitems_U, and total inventory cost (see Table 4).
• SIR_allitems_U for period 1 is reduced to 987-756 = +231. Afterward, go to steps 1-4.

Iteration 2

• Select item 2, which has SIR_max of 556, and find period t_zero = 2 on item 2, which has an inventory cost of zero.
• Insert the replenished quantity, which equals the demand of item 2 for period t_zero = 52 units, on a replenished plan on item 2 for period t_zero. 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, SIR_allitems, SIR_allitems_U, and
• total inventory cost (see Table 5).
• SIR_allitems_U for period 2 is still reduced to 779-756 = +23. Then, go to steps 1- 4.

Iteration 3

• Select item 1, which has SIR_max of 431, and find period t_zero = 4 on item 1, which has an inventory cost of zero.
• Insert the replenished quantity, which equals the demand of item 2 for period t_zero= 106 units, on a replenished plan on item 1 for period t_zero. 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,SIR_allitems, SIR_allitems_U, and total
• inventory cost (see Table 6).
• SIR_allitems_U for period 1 is reduced to 673-756 = -83. Stop the iteration and select period 3, which has the SIR_allitems_U value of +947. Proceed to steps 1-4 for period 3.

Period 3

Iteration 1

• Select item 2, which has SIR_max of 1,484, and find period t_zero = 5 on item 2, which has
• an inventory cost of zero.
• Insert the replenished quantity, which equals the demand of item 2 for period t_zero=118 units, on a replenished plan on item 2 at period t_zero. For balance demand, decrease the replenishment of item 2 for period 3 to 371-118 = 253 units.
• Balance a replenished plan and update inventory, SIR,SIR_allitems, SIR_allitems_U,
• and total inventory cost (see Table 7).
• SIR_allitems_U for period 3 is still reduced to 1,108-633 = +475. Afterward, go to steps 1- 4.

Iteration 2

• Select item 2, which has SIR_max of 348, and find period t_zero = 4 on item 2,
• which has an inventory cost of zero.
• Insert the replenishment, which equals the demand of item 2 at period t_zero =
• 142 units on a replenished plan on item 2 at period t_zero. For balance demand, decrease the replenishment of item 2 at period 3 to 253-142 = 111 units.
• Balance a replenished plan and update inventory, SIR,SIR_allitems, SIR_allitems_U,
• and total inventory cost (see Table 8).
• SIR_allitems_U for period 3 is reduced to 540-633= = -93. Stop the loop at
• period 3. Then, find the next SIR_allitems_U to be positive. However, all SIR_allitems_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 8,977. However, the GAMS/CPLEX solver can execute this problem with an optimal solution of 8,521. The gap between these solutions is $\left[{\displaystyle \frac{8,977-8,521}{8,521}}\right]\mathrm{x}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 SIR_allitems_U are negative or zero. Therefore, the pull method can generate an improved replenished plan. The procedure for this method can beexplained as follows.

• Search the SIR_allitems_U_min and SIR_allitems_SC_max to be -255 and -83 for periods 2 and 1 from Table 8. So,the index of both periods is t_min=2 and t_max=1. So, t_min is more than t_max.
• Find the SIR_min for period t_min 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 t_max=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 t_min is reduced to zero (see Table 9).

3. Recalculate SIR,SIR_allitems, SIR_allitems_U, and total inventory cost (see Table 9).

4. SIR_allitems_U of item 2 for period 1 (= +125) is still a positive number. Thus, search the item with SIR_max (= 325) excluding item 2 at period 1, to be 1.

5. For reducing SIR_allitems_U to zero at period 1, the SIR_allitems_U is divided by the weight of item 1 for period 1 (+125 / 1=125) on item 1 at period t_min =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.

6. Recalculate SIR,SIR_allitems, SIR_allitems_U, and total inventory cost (see Table 10).

7. SIR_allitems_U of period 1 is zero and SIR_allitems_U of period 2 (t_min) is still -255 (see Table 10), which is the same as Table 9.

8. Find the SIR_allitems_U_min and SIR_allitems_U_max to be -255 and -84 in periods 2 and 3 from Table 10. The index of both periods is t_min=2 and t_max=3. So, t_min is less than t_max. Then, stop the iteration.

Therefore, the inventory cost is effectively improved to 8,683. The GAMS/CPLEX solver can calculate the optimal solution of 8,521 units. Both the proposed heuristic and Gutiérrez et al. [17] can also calculate the approximate solution the same as 8,683 and the smoothing method of Nixon and Poh [27] can run about 9,494 (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. [17], the smoothing method [27], and GAMS/CPLEX are 1.9 %, 1.9 %, and 11.45 %, respectively. Both the proposed heuristic and Gutiérrez et al. [17] 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[18] 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={\displaystyle \sum _{n=1}^N{w}_i{d}_{i,t},}{U}_t=\left[A+B\cdot ({\displaystyle \sum _{n=1}^N{w}_i{D}_{i,t+1}})\right]$ a fixed fraction B =10%. In the format for the storage capacity, parameter A is the sum of the demand onall items at period t with the lower bound (B=1%). Authors generate the example data following Minner [18] procedure as shown in Table 12.

A instance of Minner [18] 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. [17], which has a gap of 1.27 %, and the smoothing method [27], with a gap of 1.02 %. The proposed heuristic places about three replenishment orders, whereas both Gutiérrez et al. [17] 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., and GAMS/CPLEX solver. The set of randomly generated problems is identical to the cost framework of Minner [18]. 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 Gutiérrez et al.’s 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 [31]. The solution for the GAMS/CPLEX solver compares all the results of the experiment. It can be explained with the solution gap equation below.

$$\mathrm{Solution}\mathrm{gap}(\%)=\left[{\displaystyle \frac{\mathrm{Solution}\mathrm{of}\mathrm{heuristic}\text{-}\mathrm{Solution}\mathrm{of}\mathrm{GAMS}/\mathrm{CPLEX}}{\mathrm{Solution}\mathrm{of}\mathrm{GAMS}/\mathrm{CPLEX}}}\right]\mathrm{x}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.1. 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. Gutiérrez et al.’s heuristic generates solution gaps of about 2.41%, 1.23% and 0.55 %. When comparing the solution gaps, the proposed heuristic performs better than Gutiérrez et al.’s heuristic. 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. Gutiérrez et al.’s heuristic sometimes moves the replenished quantity from any period to period t+k, when $k\in \{1,2,\mathrm{...},T-t\}$.Ordering cost must be paid more frequently when inserting the replenished quantity for period t+k in more time, causing total inventory cost to grow. Unfortunately, the amount of SIR_allitem _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 zero inventory cost, it can certainly reduce the replenished quantity for period t so that the amount of SIR_allitems _U reduces.

5.2. Worst Cases Analysis

For the robust condition of the push & 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 Gutiérrez et al.’s heuristic to execute any random instances with near-minimal storage capacities. It can calculate only one and two from five and ten instances, such as 20x24, 30x24, and 40x24 problems (NxT). 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, Gutiérrez et al.’s heuristic 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 [27] , 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 10x24 case, with gaps of about 1.27% and 0.34% under storage capacities B = 1% and 20%, respectively. In comparison, Gutiérrez et al.’s heuristic 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.3. Computation Time

This study implements the codes based on the state-of-the-art methods for both heuristics. Both the push & pull heuristic and the heuristic by Gutiérrez et al. have the same time complexity, denoted as $O(W\cdot N\cdot T^2)$. Therefore, the running times of the two heuristics are nearly the same. The time complexity for the network flow based on dynamic programming algorithm [22] has $O(NT{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\mathrm{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 [28] 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.4. 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.5. 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. Pior heuristics did not directly consider the tight storage capacity constraints. The just-in-time operation in the assembly automobile industry is difficult to share 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 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, Gutiérrez et al.’s heuristic 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 problem, whereas GAMS/CPLEX solver run with minimal run time on small-and medium-scale problem. 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 for applying this proposed heuristic then evaluating in a assembly automobile plant to improve the practical applicability and credibility. Another extension, it could run with the stochastic demand or lead time constraints to make it applicable across a wider range of academic settings.

Appendix A.1

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:

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

22:

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]

26:

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

37:

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

70:

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

94:

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

112:

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

124:

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

131:

132: END PROCEDURE