Chvátal–Gomory Cuts Applied to the Nurse Rostering Problem

Abstract

The nurse rostering problem (NRP) has attracted significant research interest in recent decades due to both its practical relevance and computational complexity. While the branch-and-price algorithm has demonstrated effectiveness in solving NRPs, its column generation component frequently produces weak lower bounds for some problem instances, which consequently degrades overall computational performance. To strengthen the lower bound quality, we propose three classes of cutting planes derived from the column generation master problem formulation: SRCs, CG rank-1 cuts, and {0, ½}-cuts. For each cut type, the separation approaches enhanced with acceleration strategies are described. These cuts are typically classified as non-robust, meaning each cut added to the master problem requires introducing a new resource in the pricing subproblem’s labeling algorithm. We therefore developed problem-specific methods to update these resources and integrate them into the NRP dominance rules. Computational experiments were conducted on benchmark instances from two international nurse rostering competitions (INRC-I and INRC-II). The results indicate that SRCs are highly effective for two challenging INRC-I instances, including one where a tighter lower bound was identified. In contrast, the {0, ½}-cuts yield the strongest performance for most selected INRC-II instances. These findings demonstrate that the cutting plane method can be used to improve lower bounds for NRPs, and that the effectiveness of different cut types in improving lower bounds is closely tied to the problem formulation.

1. Introduction

The nurse rostering problem (NRP), also referred to as the nurse scheduling problem, seeks to create an efficient and fair roster for a group of nurses over a specified time period. A roster in this context consists of personalized schedules for each nurse, detailing their sequence of shifts and designated days off [1]. The NRP has been demonstrated to be NP-hard [2,3], encompassing multiple complex constraints and objectives. Given its practical significance and computational complexity, the NRP has attracted substantial research attention over recent decades. An extensive body of literature has emerged addressing both modeling approaches and solution methodologies for NRPs. For comprehensive reviews of these developments, readers are directed to [4,5,6].

Numerous heuristic approaches, particularly metaheuristics such as simulated annealing and variable neighborhood search, have been developed for various NRP variants over the past several decades [7,8,9]. Real-world NRPs must satisfy numerous constraints to balance patient care requirements with nurse satisfaction. Key constraints typically include (i) coverage requirements to meet patient demand, (ii) minimum and maximum limits on (consecutive) working days, and (iii) various considerations of staff preference. The complexity of NRPs’ constraints makes them particularly challenging to solve optimally, especially for large-scale instances. Consequently, during the early stages of algorithmic research, most adopted heuristic approaches as practical solutions. In the first and second international nurse rostering competitions (INRC-I in 2010 and INRC-II in 2015) [10,11], heuristic solutions demonstrated remarkable performance. Although heuristic approaches frequently generate high-quality solutions, they lack optimality guarantees. This limitation has motivated continued research into exact algorithms for NRPs.

Branch-and-price (B&P) is an exact algorithm combining branch-and-bound with column generation, where the latter consists of a master problem and a pricing subproblem. It has been demonstrated to be an effective approach for solving various combinatorial optimization problems, including the vehicle routing problem (VRP) [12] and the cutting stock problem [13]. If we treat an individual nurse’s schedule as a path for a vehicle, the NRP exhibits structural similarities to the VRP. Therefore, it is unsurprising that several researchers have attempted to develop B&P solutions for NRPs [14,15]. One of the most challenging aspects in implementing such solutions is developing an efficient algorithm to solve the pricing subproblem. Initial approaches typically employ integer programming [16,17], constraint programming [18], or heuristic methods [19,20]. However, these methods often face trade-offs between computational efficiency and solution optimality. Recent advances [21,22] have produced a dynamic programming (DP) algorithm that solves NRP pricing subproblems efficiently and optimally, resulting in faster column generation convergence and better B&P performance. As demonstrated in reference [21], such a DP-based B&P approach has achieved optimal solutions for a number of instances from the publicly available INRC-I and INRC-II benchmark sets. Nevertheless, some instances remain computationally intractable for optimal solutions.

One primary reason for instance intractability is that the lower bound obtained at the root node through column generation probably is not tight. When this bound remains far from the optimal objective value, it becomes ineffective for branch pruning or optimality verification. Similar to the NRP, column generation can yield weak lower bounds when applied to other problems, such as the VRP and the cutting stock problem. A common method for tightening the lower bound is to introduce valid inequalities to the master problem. Valid inequalities can be classified into two types based on their impact on the pricing subproblem’s complexity [23]: robust cuts and non-robust cuts. Robust cuts do not increase the complexity of the pricing subproblem, whereas non-robust cuts do, leading to a more computationally challenging subproblem. However, robust cuts have been shown to be potentially less effective, particularly for hard instances. Taking the VRP as an example, Fukasawa et al. [24] developed a branch-cut-and-price algorithm for the capacitated VRP, incorporating multiple robust cuts, such as rounded capacity cuts, strengthened comb inequalities, and multistar inequalities, to improve the lower bound. Their computational experiments demonstrated that only the rounded capacity cuts were highly effective. This is partly because many of the other cuts were already implicitly satisfied by the master problem’s formulation. Among non-robust cuts for the VRP, subset row cuts (SRCs) have been widely adopted since their introduction by Jepsen et al. [25]. In fact, SRCs have become a fundamental component in modern exact solvers for various VRPs [26]. For more details on formulating valid inequalities in column generation, we refer readers to Desaulniers, Desrosiers, and Spoorendonk [27].

To the best of our knowledge, few studies have reported the performance of cutting-plane methods for NRPs in the context of column generation. Santos et al. [28] proposed a compact formulation for the INRC-I problem and tested several types of cuts to strengthen the formulation. However, computational experiments on INRC-I instances demonstrate that the lower bounds produced by this formulation and its associated cuts are significantly weaker than those obtained through column generation alone. In this work, we aim to further strengthen column generation’s lower bound performance. Building on results established for the VRP, we focus our investigation on three classes of non-robust cuts: SRCs, Chvátal–Gomory rank-1 cuts, and {0, ½}-cuts. The main contributions of this paper are twofold. First, this work represents one of the first investigations of cutting plane methods to the NRP in the context of column generation. We introduce three classes of non-robust cutting planes to strengthen lower bounds. For each cut type, we provide its formal definition, detailed separation methods, and integration approaches for handling them in the labeling algorithm. Second, we present computational experiments using INRC-I and INRC-II benchmark instances. The results demonstrate the efficacy of these cutting planes across different problem classes while providing valuable insights for future research in this domain.

The remainder of this paper is organized as follows: Section 2 presents the problem formulation from which we derive our cutting planes. Section 3 introduces three classes of cutting planes for NRPs and develops corresponding separation methods for each type. As these cuts are non-robust, Section 4 describes approaches for incorporating them into the labeling algorithm for the pricing subproblem. Computational results using benchmark instances from INRC-I and INRC-II are presented in Section 5, followed by concluding remarks in Section 6.

2. Problem Formulation

The cutting plane method is an iterative algorithm for solving integer programming problems. At each step, it solves a linear relaxation of the problem, identifies violated inequalities (cuts) by the non-integer solution, and adds these cuts to exclude the non-integer solution. To describe the cuts developed for the NRP, we first present its problem formulation. While numerous NRP variants exist, we focus on the NRPs introduced in INRC-I and INRC-II. Given that INRC-II contains more instances where the lower bound obtained at the root node is not tight, we use it as the primary example to concisely illustrate the proposed cutting planes. Although we demonstrate these cuts on INRC-II, they can be directly adapted to INRC-I’s formulation. It is notable that the NRP formulation in INRC-II represents a dynamic variant, requiring multi-stage optimization where each stage corresponds to a planning week. In this work, we focus on its static version where all problem information is known a prior, enabling single-stage optimization. For conciseness, we do not reproduce the full problem here. We refer readers to the complete problem description provided in reference [11].

The master problem (MP) refers to the problem formulation that includes all possible columns (variables). However, due to the typically enormous number of columns in many practical applications, solving the MP directly is computationally intractable. Column generation solves a linear relaxation of the MP through an iterative process involving two key components. The restricted master problem (RMP) solves the MP’s linear relaxation using only a subset of columns, while the pricing subproblem (PSP) generates new columns with negative reduced costs to progressively improve the solution. This alternation continues until no further improving columns can be found. For the NRP, the PSP generates individual schedules (columns) where individual related constraints (e.g., consecutive work/rest limits) are addressed. Provided that all individual schedules are given, the MP selects an individual schedule for each nurse to meet all staffing requirements. Let N, D, S, and K denote the sets of nurses, days, shifts, and skills, respectively. As nurses $n\in N$ have heterogeneous scheduling constraints, each feasible individual schedule for nurse n is represented by $l\in L_n$, where $L_n$ is the nurse-specific feasible schedule set. The binary decision variable $x_{nl}\in \{0,1\}$ indicates whether schedule $l\in L_n$ is assigned to nurse n. The MP is formulated as the following integer linear programming model.

$$\begin{array}{cc}\hfill \left(\mathrm{MP}\right)min& \sum _{n\in N}\sum _{l\in Ln}{c}_{nl}·x_{nl}+\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}{p}^{opt}·u_{dsk}\hfill \end{array}$$

(1)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{n\in N}\sum _{l\in L_n}{a}_{nldsk}·x_{nl}⩾r_{dsk}^{min},\forall d\in D,s\in S,k\in K\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill & \sum _{n\in N}\sum _{l\in L_n}{a}_{nldsk}·x_{nl}+u_{dsk}⩾r_{dsk}^{opt},\forall d\in D,s\in S,k\in K\hfill \end{array}$$

(3)

$$\begin{array}{cc}\hfill & \sum _{l\in Ln}{x}_{nl}=1,\forall n\in N\hfill \end{array}$$

(4)

$$\begin{array}{cc}\hfill & x_{nl}\in \left\{0,1\},\forall n\in N,l\in L_n\right.\hfill \end{array}$$

(5)

$$\begin{array}{cc}\hfill & u_{dsk}\in N,\forall d\in D,s\in S,k\in K\hfill \end{array}$$

(6)

Constraint (2) enforces minimum staffing requirements $r_{dsk}^{min}$ by ensuring sufficient nurse coverage for each shift, while Constraint (3) tracks deficits $u_{dsk}$ when assignments fall below optimal staffing levels $r_{dsk}^{opt}$. The binary parameter $a_{nldsk}$ indicates whether nurse n’s individual schedule l includes an assignment to work shift s on day d while utilizing skill k. Constraint (4) enforces that each nurse is assigned exactly one individual schedule. Constraints (5) and (6) formally define the variables. The objective minimizes the sum of individual schedule penalties (for violating individual related constraints) and staffing deficit penalties (for deviations from optimal demand levels). The parameter $c_{nl}$ represents the penalty cost of individual schedule l of nurse n, which is calculated and returned by the PSP, and $p^{opt}$ denotes the unit penalty incurred per nurse deficit.

As mentioned previously, the PSP in our column generation approach for the NRP aims to generate new feasible individual schedules for nurses. More precisely, the PSP seeks individual nurse schedules with negative reduced costs, which is computed using the current dual values from the RMP. Let ${\lambda }_{dskm}$ be the dual variables for corresponding constraints (2) ($m=1$) and (3) ($m=2$) in the RMP. ${\lambda }_n$ denotes the dual variables for constraints (4). We can compute the reduced cost $c_{nl}^{*}$ of an individual schedule not currently present in the RMP for nurse n as:

$$c_{nl}^{*}=c_{nl}-\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}\sum _{m\in \{1,2\}}{a}_{nldsk}·{\lambda }_{dskm}-{\lambda }_n.$$

(7)

The column generation algorithm iteratively adds individual schedules with negative reduced costs to the RMP and reoptimizes. If no such schedules exist, the current RMP solution is provably optimal.

3. Cutting Planes

Algorithm 1 presents the pseudocode for our implementation of column generation with cutting planes. The key distinction between this method and the standard column generation framework is its iterative cut-generation mechanism: whenever no columns with negative reduced cost are identified, the algorithm searches for violated cutting planes instead of terminating immediately. The procedure terminates only when no further violated cuts are found or when a predefined time limit is reached.

As stated above, there are two types of cuts in the context of column generation: robust cuts and non-robust cuts. For VRPs, non-robust cuts demonstrate greater potential for significantly reducing integrality gaps. Therefore, we focus on constructing non-robust cuts for the NRP. Three types of non-robust cuts are developed for the NRP in this paper. First, we adapt SRCs [25], which have proven highly effective for VRPs, to the NRP. As SRCs are actually a special case of Chvátal–Gomory rank-1 cuts [29], we further investigate the performance of general Chvátal–Gomory rank-1 cuts for the NRP. Additionally, we examine {0, ½}-Chvátal–Gomory rank-1 cuts ({0, ½}-cuts) [30].

In the following sections, we detail the inequality definitions and separation algorithms for each cut type.

Algorithm 1 Column Generation with Cutting Planes.

1: Construct and initialize the RMP   2: Construct the PSP   3: loop   4:     $z^{*}$, $\lambda$ (dual variables for each constraint in RMP) ← Solve RMP   5:     $NL (\mathrm{set} \mathrm{of} \mathrm{generated} \mathrm{columns})\leftarrow \mathrm{Solve} \mathrm{PSP} \mathrm{with} \mathrm{dual} \mathrm{variables} \lambda$   6:     if $NL\ne \varnothing$ then   7:         Update RMP with columns in $NL$   8:     else   9:         if a predefined time limit is reached then 10:            break 11:         end if 12:         $CN (\mathrm{set} \mathrm{of} \mathrm{new} \mathrm{cuts})\leftarrow$ Verify violated cuts by evaluating the inequality conditions specific to each cut type. 13:         if $CN\ne \varnothing$ then 14:            Update RMP with cuts in $CN$ 15:         else 16:            break 17:         end if 18:     end if 19: end loop 20: return $z^{*}$

3.1. SRCs

The SRCs were first applied to solve VRPs [25]. Subsequently, numerous studies have applied SRCs or developed enhancements to improve their effectiveness [31,32]. In our formulation of the NRP, we derive SRCs from both the minimum coverage constraints 2 and optimal coverage constraints 3. These constraint sets are denoted as $V^{min}$ and $V^{opt}$, respectively. Each constraint is uniquely identified by day d, shift s, skill k, and an indicator $m\in \{1,2\}$, where $m=1$ corresponds to minimum coverage constraints and $m=2$ represents optimal coverage constraints. Given an index subset $C\subseteq V^{min}\cup V^{opt}$, the proposed SRCs for the NRP is defined as

$$\sum _{n\in N}\sum _{l\in L_n}\lfloor \gamma (\sum _{d,s,k,m=1\in C}{a}_{nldsk}+\sum _{d,s,k,m=2\in C}{a}_{nldsk})\rfloor x_{nl}-\sum _{d,s,k,m=2\in C}{u}_{dsk}\le \lfloor \gamma (\sum _{d,s,k,m=1\in C}{r}_{dsk}^{min}+\sum _{d,s,k,m=2\in C}{r}_{dsk}^{opt})\rfloor ,$$

(8)

where $\gamma =-1/g$, with $g\in \{1,\dots |C\left|\right\}$. In theory, different families of SRCs can be obtained by changing the cardinality of C and the parameter $\gamma$. However, for a given fixed value of $\left|C\right|$, the separation problem of finding the most violated SRCs is NP-complete, as proved by Jepsen et al. [25]. Therefore, the most widely used method for separating SRCs is to enumerate all possible subsets C with fixed values of $\left|C\right|$ and g, where $3\le \left|C\right|\le 5$.

In the NRP instances from INRC-II, the planning horizon spans either 4 or 8 weeks, with four distinct shifts and four skill types. Hence, the number of constraints in set $V^{min}\cup V^{opt}$ is $4\left(8\right)\times 7\times 4\times 4\times 2=896\left(1792\right)$, which significantly exceeds the number typically encountered in VRPs. Naturally, enumerating all possible subsets for such a large constraint set would be computationally prohibitive.

To address this challenge, we developed two strategies to enhance the efficiency of SRCs separation. Our first strategy establishes three pre-computation rules that identify and discard invalid SRCs prior to computing the left-hand side of Inequality (8). More precisely, three key properties optimize the SRCs separation process: (1) when the value of $\gamma ({\sum }_{d,s,k,m=1\in C}{r}_{dsk}^{min}+{\sum }_{d,s,k,m=2\in C}{r}_{dsk}^{opt})$ in Inequality (8) is an integer, the inequality necessarily holds, eliminating the need for left-hand side computation; (2) the inequality is invariably satisfied when subset C contains constraints sharing a common day index; and (3) for constraint pairs with identical day, shift, and skill indices but different m values, only one need be considered when some specific condition is met. Algorithm 2 presents the pseudocode for our implementation of separating SRCs, where $x_{nl}^{*}$ and $u_{dsk}^{*}$ are the solution values for the RMP. It details pre-computation rule (2) in lines 2–19 (valid when $\left|C\right|=3$) and pre-computation rules (1) and (3) in lines 22–31. Although our first strategy significantly reduces the number of candidate subsets, evaluating each remaining subset C remains computationally expensive. To address this computational challenge, our second strategy employs GPU-accelerated parallel processing. The evaluation of left-hand side values constitutes the most computationally demanding task, requiring intensive numerical operations. This type of computation is ideally suited for GPU implementation, as GPUs can execute thousands of parallel floating-point operations simultaneously, achieving orders-of-magnitude speedup compared to conventional CPU-based sequential processing.

3.2. Chvátal–Gomory Rank-1 Cuts

Chvátal–Gomory (CG) cuts represent a fundamental family of valid inequalities obtained through integer rounding of linear constraint combinations in integer programs [33]. Consider a polyhedron $P:=\{x\in R^n:Ax\le b,x\ge 0\}$, where $A\in Z^{m\times n}$ and $b\in Z^m$. Let $P_I:=P\cap Z^n$. A CG rank-1 cut for $P_I$ is defined as:

$$\lfloor \gamma A\rfloor x\le \lfloor \gamma b\rfloor$$

(9)

where $\gamma \ge 0$ is the CG multiplier vector. The term “rank-1” refers to the fact that these cuts are derived directly from the original constraints $Ax\le b$ and $x\ge 0$. Moreover, it has been proven that only multipliers $\gamma \in [0,1)$ need to be considered when generating all valid CG cuts [34].

For the NRP, based on constraints (2) and (3), we define CG rank-1 cuts as:

$$\sum _{n\in N}\sum _{l\in L_n}⌊\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}\sum _{m\in \{1,2\}}{\gamma }_{dskm}·a_{nldsk}⌋x_{nl}+\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}\lfloor {\gamma }_{dsk2}\rfloor ·u_{dsk}\le ⌊\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}({\gamma }_{dsk1}·r_{dsk}^{min}+{\gamma }_{dsk2}·r_{dsk}^{opt})⌋,$$

(10)

where ${\gamma }_{dskm}\in (-1,0]$ represents the CG multiplier for the corresponding constraint. In fact, SRCs represent a specialized class of CG rank-1 cuts where the multiplier vector $\gamma$ contains exactly $\left|C\right|$ nonzero components. As shown by Eisenbrand [35], CG cuts separation is NP-hard in general. Researchers typically reformulate the separation problem as an integer program solvable via commercial optimization solvers.

Algorithm 2 Separation of SRCs.

1: $CN\leftarrow \varnothing$, $\mathrm{maxCutsToAdd}\leftarrow 5$, $\mathcal{M}\leftarrow \mathrm{empty} \mathrm{array}$, $\mathrm{row}\_\mathrm{index}\leftarrow 0$   2: for each $d\in D$ do   3:     for each $s\in S$ do   4:         for each $k\in K$ do   5:            $ga{p}_{min}\leftarrow \lfloor \gamma (r_{dsk}^{opt}-r_{dsk}^{min})\rfloor +u_{dsk}^{*}$   6:            $ga{p}_{opt}\leftarrow \lfloor \gamma (r_{dsk}^{opt}-r_{dsk}^{min}-1)\rfloor +u_{dsk}^{*}$   7:            if $ga{p}_{min}\ge 0$ then   8:                $\mathcal{M}[\mathrm{row}\_\mathrm{index}]\leftarrow r_{dsk}^{min}$   9:            else if $ga{p}_{opt}\le 0$ then 10:                $\mathcal{M}[\mathrm{row}\_\mathrm{index}]\leftarrow r_{dsk}^{opt}$ 11:            else 12:                $\mathcal{M}[\mathrm{row}\_\mathrm{index}]\leftarrow r_{dsk}^{min}$ 13:                $\mathrm{row}\_\mathrm{index}\leftarrow \mathrm{row}\_\mathrm{index}+1$ 14:                $\mathcal{M}[\mathrm{row}\_\mathrm{index}]\leftarrow r_{dsk}^{opt}$ 15:            end if 16:            $\mathrm{row}\_\mathrm{index}\leftarrow \mathrm{row}\_\mathrm{index}+1$ 17:         end for 18:     end for 19: end for                                  ▹pre-computation rule (2) 20: $ACB\leftarrow$ Enumerate all combinations of the indices of array M with cardinality $\left|C\right|$ 21: $CB (\mathrm{set} \mathrm{of} \mathrm{combinations} \mathrm{for} \mathrm{GPU} \mathrm{computation})\leftarrow \varnothing$ 22: for each $C\in ACB$ do 23:     $\mathrm{rightHandSum}\leftarrow {\sum }_{\mathrm{row}\_\mathrm{index}\in C}\mathcal{M}[\mathrm{row}\_\mathrm{index}].r_{dsk}$ 24:     if $\mathrm{rightHandSum}·\gamma mod1=0$ then 25:         continue 26:     end if 27:     if all $\mathcal{M}[\mathrm{row}\_\mathrm{index}].r_{dsk}$ for $\mathrm{row}\_\mathrm{index}\in C$ share the same d then 28:         continue 29:     end if 30:     $CB\leftarrow CB\cup \left\{C\right\}$ 31: end for                             ▹ pre-computation rules (1) and (3) 32: $VC\leftarrow \mathrm{calculate} \mathrm{violated} \mathrm{cuts} \mathrm{by} \mathrm{GPU} \mathrm{according} \mathrm{to} \mathrm{the} \mathrm{SRCs} \mathrm{inequality}$ 33: if   $VC\ne \varnothing$then 34:     Sort $VC$ in descending order of violation degree 35:     for  $i\leftarrow 0$ to$min(\mathrm{maxCutsToAdd},|VC\left|\right)-1$ do 36:         $cut\leftarrow$ Construct a cutting plane inequality for $VC\left[i\right]$ 37:         $CN\leftarrow CN\cup \left\{cut\right\}$ 38:     end for 39: end if 40: return $CN$

To separate the most violated CG rank-1 cuts defined by (10), we formulate the following mixed integer programming (MIP) problem:

$$\begin{array}{cc}\hfill \left(\mathrm{Separation}\right)max& \sum _{n\in N}\sum _{l\in L_n}{y}_{nl}·x_{nl}^{*}+\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}{z}_{dsk}·u_{dsk}^{*}-y_0+w·\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}\sum _{m\in \{1,2\}}{\gamma }_{dskm}\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.& \sum _{d\in D}\sum _{s\in S}\sum _{k\in K}\sum _{m\in \{1,2\}}{\gamma }_{dskm}·a_{nldsk}-y_{nl}-f_{nl}^x=0,\hspace{1em}\forall n\in N,l\in Ln\hfill \end{array}$$

(12)

$$\begin{array}{c}{\gamma }_{dsk2}-z_{dsk}-f_{dsk}^u=0,\hspace{1em}\forall d\in D,s\in S,k\in K\hfill \end{array}$$

(13)

$$\begin{array}{c}\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}({\gamma }_{dsk1}·r_{dsk}^{min}+{\gamma }_{dsk2}·r_{dsk}^{opt})-y_0-f_0=0\hfill \end{array}$$

(14)

$$\begin{array}{c}{f}_{nl}^x,f_0\in \left[0,1-ϵ\right),\hspace{1em}\forall n\in N,l\in L_n\hfill \end{array}$$

(15)

$$\begin{array}{c}{f}_{dsk}^u\in \left[0,1-ϵ\right),\hspace{1em}\forall d\in D,s\in S,k\in K\hfill \end{array}$$

(16)

$$\begin{array}{c}{\gamma }_{dskm}\in \left(-1+ϵ,0\right],\hspace{1em}\forall d\in D,s\in S,k\in K,m\in \{1,2\}\hfill \end{array}$$

(17)

$$\begin{array}{c}{y}_{nl},y_0\in Z_{\le 0},\hspace{1em}\forall n\in N,l\in L_n\hfill \end{array}$$

(18)

$$\begin{array}{c}{z}_{dsk}\in Z_{\le 0},\hspace{1em}\forall d\in D,s\in S,k\in K\hfill \end{array}$$

(19)

where $x_{nl}^{*}$ and $u_{dsk}^{*}$ are the current optimal solution for the RMP. To reduce the size of the separation model, we need only consider basis variables with non-zero values. $y_{nl}$ and $z_{dsk}$ are actually the coefficients, which are obtained by applying floor operations to their corresponding terms, for variables $x_{nl}$ and $u_{dsk}$ in CG rank-1 cuts (10), respectively. $y_0$ denotes the value of the right-hand side of CG rank-1 cuts (10). The slack variables $f_{nl}^x$, $f_{dsk}^u$, and $f_0$ are introduced to enhance numerical stability during optimization. The final term $w·{\sum }_{d\in D}{\sum }_{s\in S}{\sum }_{k\in k}{\sum }_{m\in \{1,2\}}{\gamma }_{dskm}$ in the objective function is designed to promote sparsity in the generated cuts. Specifically, this formulation encourages solutions where the multiplier vector $\gamma$ contains a maximal number of zero components.

3.3. {0, ½}-Cuts

{0, ½}-Cuts, also known as zero-half cuts, were introduced by Caprara and Fischetti [30]. These cuts constitute a specialized class of CG rank-1 cuts where all CG multipliers are restricted to values in {0,½}. Gentile et al. [36] demonstrated that iterative generation of {0,½}-cuts can also provide a complete description of integer polytopes in finite time. However, the general separation problem for these cuts remains NP-complete. Consequently, we also employ a MIP model to identify most violated {0,½}-cuts. This MIP model is an extension of the model for CG rank-1 cuts by adding additional variables (21) and constraints (20) to restrict the values of ${\gamma }_{dskm}$.

$$h_{dskm}=-2{\gamma }_{dskm},\forall d\in D,s\in S,k\in K,m\in \{1,2\}$$

(20)

$$h_{dskm}\in \{0,1\},\forall d\in D,s\in S,k\in K,m\in \{1,2\}$$

(21)

4. Dominance Rules

The PSP for the NRP can be formulated as a shortest path problem with resource constraints (SPPRC), where a path corresponds to an individual schedule for a nurse. The SPPRC is defined on a directed acyclic graph $G=\{V,A\}$. The vertex set V comprises a virtual source node $v_0$, a virtual sink node $v_{n+1}$, and intermediate nodes $\{v_1,\dots ,v_n\}$ representing either specific shift assignments or rest days. The arc set A consists of all feasible transitions $(v_i,v_j)$ between consecutive days, each of which is related to a cost and a set of resource consumptions. Each complete path from the source node $v_0$ to the sink node $v_{n+1}$ in the graph corresponds to a feasible individual schedule for a single nurse, encoding the sequence of shift assignments and rest days across the planning horizon.

While alternative approaches exist, DP remains the method of choice for the SPPRC. The DP algorithm operates by progressively extending partial paths, beginning with the trivial initial path $P=\left(v_0\right)$, and systematically generating feasible complete paths through node-by-node expansion. Implementing such a basic path extension procedure would require enumerating all feasible paths, leading to computational complexity that grows exponentially with problem size. As a result, dominance rules are introduced to eliminate non-useful partial paths, thereby reducing the number of paths extended and improving the algorithm’s efficiency. Generally, the label is introduced in the algorithm to represent a partial path, recording both its cost and resource consumption. Consequently, the DP algorithm for the SPPRC is commonly referred to as the labeling algorithm. Let ${\Phi }_i$ represent the set of labels on node $v_i$. Algorithm 3 presents the pseudocode for our implementation of the labeling algorithm, where $REF({\varphi }_i,v_j)$ denotes the function that generates a label with updated cost and resource consumption if extending label ${\varphi }_i\in {\Phi }_i$ to node $v_j$ is feasible. The algorithm’s central challenges involve resource definition/updating and dominance rule design.

To formally present the dominance rules, we introduce the following notations. Let $P=\{v_0,\dots ,v_i\}$ denote a partial path originating at the source vertex $v_0$ and terminating at vertex $v_i$. A partial path $E=\{v_j,\dots ,v_{n+1}\}$ is called a feasible extension of P if the path $(P,E)=\{v_0,\dots ,v_i,v_j,\dots ,v_{n+1}\}$ represents a feasible complete path. Given two partial paths P and Q, the basic idea of the dominance rule is that if the path $(P,E)$ yields a solution at least as good as $(Q,E)$ for every feasible extension E of Q, then path Q can be safely discarded from further consideration. In such cases, we say that P dominates Q.

Algorithm 3 The labeling algorithm for the PSP.

1: Initialization:   2: ${\Phi }_0\leftarrow (0,\dots ,0)$   3: for $v_i\in V\setminus \left\{v_0\right\}$   do   4:     ${\Phi }_i\leftarrow \varnothing$   5: end for   6: Extending labels:   7: for $v_i\in V$   do   8:     ${\Phi }_i\leftarrow \mathrm{Apply} \mathrm{dominance} \mathrm{rules} \mathrm{to} \mathrm{set} {\Phi }_i$   9:     for $v_j\mathrm{in} \mathrm{successors} \mathrm{of} v_i$ do 10:         for ${\varphi }_i\in {\Phi }_i$ do 11:            ${\Phi }_j\leftarrow {\Phi }_j\cup REF({\varphi }_i,v_j)$ 12:         end for 13:     end for 14: end for

The development of effective DP algorithms for the NRP has long been challenging due to its bounded resource constraints. Recent advances have yielded efficient DP algorithms, including tailored resources and dominance rules. Building on these developments, Our column generation algorithm adapts such DP algorithms by considering additional cuts. We begin with the tailored dominance rule before presenting our adaptations. The NRP formulation is characterized by soft bounded constraints on resource consumption, meaning that violations of the prescribed bounds $[r_{min},r_{max}]$ for any resource $r\in R$ are permitted but incur penalty costs. Therefore, the total cost of a complete path P comprises two components: all arc costs along the path and penalty costs incurred from resource constraint violations. For bounded resource constraints, the relationship between resource consumption and penalties is non-monotonic. Let $r\left(P\right)$ represent the current consumption of resource r accumulated throughout a partial path P. $c^r\left((P,E)\right)$ denotes the corresponding penalty cost resulting from resource constraint violation when extending P with a feasible extension E. Given two partial paths P and Q, $r\left(P\right)\le r\left(Q\right)$ does not necessarily imply $c^r\left((P,E)\right)\le c^r\left((Q,E)\right)$ for any feasible extension E.

This constitutes the fundamental challenge in developing effective dominance rules for the NRP. However, recent investigations reveal that the difference of their penalty costs $d^r=c^r\left((P,E)\right)-c^r\left((Q,E)\right)$ constitutes a monotonic function (either decreasing or increasing) of resource consumption r across all feasible extensions. Let $d_{min}^r$ and $d_{max}^r$ be the minimum and maximum value of $d^r$, respectively. For each partial path P, we define its current cost $c\left(P\right)$ as the sum of all arc costs along the path plus any identified penalty costs resulting from resource constraint violations. The tailored dominance rules for the NRP are presented in Definition 1.

Definition 1.

For two partial paths P and Q terminating at the same vertex, the following dominance relations hold: (1) P dominates Q, if $c\left(P\right)+{\sum }_{r\in R}{d}_{max}^r\le c\left(Q\right)$; (2) Q dominates P, if $c\left(P\right)+{\sum }_{r\in R}{d}_{min}^r\ge c\left(Q\right)$.

As these concepts have been thoroughly examined by [21,22], we omit the proof and the method to define and update resources here. A primary implementation challenge of this dominance rule lies in the computation of $d_{min}^r$ and $d_{max}^r$. The methods for calculating these values for NRP-specific constraints have been presented. In what follows, we primarily focus on our methodology for computing these values for the cuts developed in Section 3.

When violated cuts are identified, they are incorporated into the RMP as additional inequality constraints. Let ${\lambda }_t\le 0$ denote the dual variables associated with these new constraints, where $t\in T$ represents their index. Using CG rank-1 cuts as an example, the modified reduced cost is then given by:

$$c_{nl}^{-}=c_{nl}^{*}-\sum _{t\in T}{\lambda }_t⌊\sum _{d\in D}\sum _{s\in S}\sum _{k\in K}\sum _{m\in \{1,2\}}{\gamma }_{dskm}^t·a_{nldsk}^t⌋,$$

(22)

where $c_{nl}^{*}$ is defined by (7). In the DP algorithm for solving the PSP, a new resource $r^t$ is introduced for each additional cut $t\in T$. Let ${\varphi }_i$ be a label representing a partial path P, where ${\varphi }_i.cost$ and ${\varphi }_i.r^t$ denote $c\left(P\right)$ and consumption of resource $r^t$, respectively. The source node initializes all cut resource consumptions to zero. When extending ${\varphi }_i$ using $REF({\varphi }_i,v_j)$, Algorithm 4 presents the procedure to update cut resources. To incorporate these additional resources within the dominance rules from Definition 1, we establish the following calculation method for $d_{max}^{r^t}$ and $d_{min}^{r^t}$. Given two labels ${\varphi }_i$ and ${\varphi }_{i^{\prime }}$, if ${\varphi }_i.r^t={\varphi }_{i^{\prime }}.r^t$, then $d_{max}^{r^t}=d_{min}^{r^t}=0$. If ${\varphi }_i.r^t<{\varphi }_{i^{\prime }}.r^t$, then $d_{max}^{r^t}=0$ and $d_{min}^{r^t}={\lambda }_t$. Otherwise, $d_{max}^{r^t}=-{\lambda }_t$ and $d_{min}^{r^t}=0$. Algorithm 5 implements the dominance rules for our labeling algorithm, with a particular focus on cut resources. Note that the set R contains resources corresponding to NRP-specific soft constraints and methods for computing $d_{max}^r$ and $d_{min}^r$ are described in [22]. As established previously, both SRCs and {0,½}-cuts represent special cases of CG rank-1 cuts. Consequently, the proposed methodology can be directly adapted to compute the relevant values for these cuts.

Algorithm 4 The procedure to update cut resources in $REF({\varphi }_i,v_j)$.

1: for   $t\in T$   do   2:     if $v_j$ is a day off then   3:           ${\varphi }_j.r^t\leftarrow {\varphi }_i.r^t$   4:     else   5:            $(d,s,k)\leftarrow \mathrm{corresponding} \mathrm{day}, \mathrm{shift}, \mathrm{and} \mathrm{skill} \mathrm{indices} \mathrm{associated} \mathrm{with} \mathrm{vertex} v_j$   6:            ${\varphi }_j.cost\leftarrow {\varphi }_i.cost-\lceil {\varphi }_i.r^t+{\sum }_{m\in \{1,2\}}{\gamma }_{dskm}^t\rceil ·{\lambda }_t$   7:            ${\varphi }_j.r^t\leftarrow {\varphi }_i.r^t+{\sum }_{m\in \{1,2\}}{\gamma }_{dskm}^t-\lceil {\varphi }_i.r^t+{\sum }_{m\in \{1,2\}}{\gamma }_{dskm}^t\rceil$   8:      end if   9: end for

Algorithm 5 Dominate rules for two labels ${\varphi }_i$ and ${\varphi }_{i^{\prime }}$ in the same vertex v.

1: $costDif\leftarrow {\varphi }_i.cost-{\varphi }_{i^{\prime }}.cost$   2: $maxDif\leftarrow 0$, $minDif\leftarrow 0$, $maxCutsDif\leftarrow 0$, $minCutsDif\leftarrow 0$   3: $maxDif\leftarrow {\sum }_{r\in R}{d}_{max}^r$, $minDif\leftarrow {\sum }_{r\in R}{d}_{min}^r$   ▹ For each resource $r\in R$, compute the maximum and minimum penalty cost differences   4: for $t\in T$   do   5:     if vertex v represents an assignment occurring on the terminal day of the planning horizon then   6:                           if ${\varphi }_i.r^t\ne 0$ and ${\varphi }_{i^{\prime }}.r^t=0$ then   7:                                 $maxCutsDif\leftarrow maxCutsDif+{\lambda }_t$   8:                                 $miniCutsGap\leftarrow miniCutsGap+{\lambda }_t$   9:                           else if ${\varphi }_i.r^t=0$ and ${\varphi }_{i^{\prime }}.r^t\ne 0$ then 10:                                 $maxCutsDif\leftarrow maxCutsDif-{\lambda }_t$ 11:                                 $miniCutsDif\leftarrow miniCutsDif-{\lambda }_t$ 12:                           end if 13:                        else 14:                           if ${\varphi }_i.r^t<{\varphi }_{i^{\prime }}.r^t$ then 15:                                 $minCutsDif\leftarrow minCutsDif+{\lambda }_t$ 16:                           else if ${\varphi }_i.r^t>{\varphi }_{i^{\prime }}.r^t$ then 17:                                 $maxCutsDif\leftarrow maxCutsDif-{\lambda }_t$ 18:                           end if 19:                      end if 20: end for 21: if costDif + maxDif + maxCutsDif $\le 0$ then 22:     return label ${\varphi }_i$ dominates label ${\varphi }_{i^{\prime }}$ 23: else if costDif + minDif + minCutsDif $\ge 0$ then 24:     return label ${\varphi }_{i^{\prime }}$ dominates label ${\varphi }_i$ 25: else 26:     return neither label dominates the other 27: end if

5. Numerical Experiments

Numerical experiments were conducted to (1) verify whether the cuts developed above improve the lower bound, and (2) quantify the degree of improvement achieved through their incorporation. The benchmark instances employed in our study are those originally introduced in INRC-I and INRC-II. Based on the permitted computation time, INRC-I instances are classified into three subsets: sprint, middle, and long. Additionally, they are divided into early, late, and hidden subsets according to their competition release stage. This two-dimensional classification system organizes all 60 INRC-I instances into nine distinct subsets. However, previous investigations have revealed that for most INRC-I instances, the objective value (or its ceiling) obtained by solving the RMP using column generation alone already matches that of the best-known integer solution. In other words, the lower bound produced by column generation for these instances is remarkably tight. Only six instances exist where the lower bound obtained by column generation is not sufficiently tight. Therefore, we use only these INRC-I instances to test our cuts. Detailed information about these instances is provided in

Table 1. INRC-I instances selected for the experiment.

Instances	Number of Nurses	Number of Days	Number of Shifts	Number of Skills
sprint05	10	28	4	1
medium_late01	30	28	4	1
medium_hidden01	30	28	5	2
medium_hidden02	30	28	5	2
medium_hidden04	30	28	5	2
long_hidden01	50	28	5	2

.

As described in Section 2, INRC-II instances were designed for a dynamic variant of the problem. The competition provided a publicly available testbed consisting of multiple datasets. Each dataset contains three types of files: scenario files (detailing nurse information), history files (documenting previous work states), and week-data files (specifying daily requirements). An instance comprises a specific scenario file, an initial history file, and a sequence of week-data files. Hence, each instance is named to encode this information. For example, the instance name n040w4_2_6-1-0-6 encodes the following components: the scenario file for 40 nurses, the second history file, and four week-data files with indices 6, 1, 0, and 6. We focus on the static formulation, testing instances consistent with those used in previous static version studies. Furthermore, to reflect practical operational conditions, we limit our analysis to instances containing at most 80 nurses and four-week scheduling periods. The INRC-II instances selected for our test are described in

Table 2. INRC-II instances selected for the experiment.

Instances	Number of Nurses	Number of Days	Number of Shifts	Number of Skills
n030w4_1_6-2-9-1	30	28	4	4
n030w4_1_6-7-5-4	30	28	4	4
n035w4_0_1-7-1-8	35	28	4	4
n035w4_2_8-8-7-5	35	28	4	4
n040w4_0_2-0-6-1	40	28	4	4
n040w4_2_6-1-0-6	40	28	4	4
n050w4_0_0-4-8-7	50	28	4	4
n050w4_0_7-2-7-2	50	28	4	4
n060w4_1_6-1-1-5	60	28	4	4
n060w4_1_9-6-3-8	60	28	4	4
n070w4_0_3-6-5-1	70	28	4	4
n070w4_0_4-9-6-7	70	28	4	4
n080w4_2_4-3-3-3	80	28	4	4
n080w4_2_6-0-4-8	80	28	4	4

.

We implemented all algorithms in Java (JDK 21.0.2). The computational experiments were conducted on a Windows 10 system equipped with an Intel Core i7-13700 processor (2.10 GHz), 32 GB of RAM, and an NVIDIA GeForce RTX 3060 GPU. Given the numerous constraints inherent NRP, we set our SRCs parameters to $\left|C\right|=3$ and $\gamma =-1/2$. IBM ILOG CPLEX is utilized as the linear programming solver for the RMP and as the MIP solver for the separation problem of CG rank-1 cuts and {0, ½}-Cuts. To add multiple cuts per iteration, we employ the solution pool feature of CPLEX. At each iteration, we add up to five of the most violated cuts for each cut type. Recognizing that the time limit for the MIP solver in solving the separation problem probably affects cut quality and consequently lower bound improvement, we established two time limit configurations: {15, 8} and {30, 16}. Here, the first value denotes the minutes allocated to the separation problem (15 or 30 min), while The second specifies the maximum column generation runtime in hours (8 or 16 h).

Table 3. Experimental results on the effectiveness of SRCs pre-computation rules.

Instance	SRCs (Without Pre-Computation Rules)				SRCs (With Pre-Computation Rules)
	LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)
n030w4_1_6-2-9-1	1661.4	1.9	724	781.2	1661.4	1.9	277	59
n030w4_1_6-7-5-3	1810	0.8	580	650.1	1810	0.8	293	55.8
n035w4_0_1-7-1-8	1343.8	6.7	690	903	1343.8	6.7	322	87
n035w4_2_8-8-7-5	1075.6	0	165	157.2	1075.6	0	56	14.3
n040w4_0_2-0-6-1	1538	2.8	280	301.5	1538	2.8	111	22.5
n040w4_2_6-1-0-6	1742.5	0.8	270	267.4	1742.5	0.8	109	19.4
n050w4_0_0-4-8-7	1296.1	0.6	322	379.1	1296.1	0.6	122	30.9
n050w4_0_7-2-7-2	1302.1	0	225	243.3	1302.1	0	85	22.1
n060w4_1_6-1-1-5	2435.1	0.2	350	369.2	2435.1	0.2	175	31.7
n060w4_1_9-6-3-8	2665.2	0.9	335	355.4	2665.2	0.9	186	32.4
n070w4_0_3-6-5-1	2370.3	0	120	133.4	2370.3	0	55	15
n070w4_0_4-9-6-7	2105	0	235	263.5	2105	0	76	19.6
n080w4_2_4-3-3-3	3292	0	165	187.1	3292	0	51	16.6
n080w4_2_6-0-4-8	3177.1	0	320	378.4	3177.1	0	119	28.4

,

Table 4. Experimental results for INRC-I instances under different time limit configurations.

Instance	LB					Timelimit: 15-min, 8-h								Timelimit: 30-min, 16-h
		SRCs				CG Rank-1 Cuts				{0,½}-Cuts				CG Rank-1 Cuts				{0,½}-Cuts
		LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)
sprint05	57	57	0	3	2	57	0	47	18,159	57	0	38	10,056.5	57	0	74	57,633	57	0	54	29,042.2
medium_late01	156	156	0	0	5.7	156	0	0	915	156	0	0	915.2	156	0	0	1822.4	156	0	0	1813.8
medium_hidden01	95.7	103.8	8.1	125	33,797.5	97.8	2.1	14	13,221.8	98.8	3.1	39	28,936.5	97.8	2.1	14	14,741.7	99	3.3	33	32,295.2
medium_hidden02	212.3	215.9	3.6	285	30,297	213.5	1.2	31	62,348.7	214.9	2.6	58	36,169.1	213.1	0.8	22	85,331.7	215	2.7	63	94,798.6
medium_hidden04	75.5	75.8	0.3	110	288.2	75.7	0.2	42	45,608.2	75.8	0.3	37	8188.5	75.7	0.2	39	89,392.3	75.8	0.3	37	15,430
long_hidden01	345	345.5	0.5	7	44.1	345.5	0.5	17	4641.9	345.8	0.8	14	4907.2	345.5	0.5	10	7332.3	345.8	0.8	14	9907.8

and

Table 5. Experimental results for INRC-II instances under different time limit configurations.

Instance	LB	Timelimit: 15-min, 8-h								Timelimit: 30-min, 16-h
		CG Rank-1 Cuts				{0,½}-Cuts				CG Rank-1 Cuts				{0,½}-Cuts
		LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)	LB*	ILB	cut_num	Time (s)
n030w4_1_6-2-9-1	1659.5	1661.2	1.7	133	29,591.1	1662.7	3.2	161	29,370	1660.7	1.2	132	58,570.3	1663.3	3.8	163	58,629.4
n030w4_1_6-7-5-3	1809.2	1810.1	0.9	134	29,557.8	1813.2	4	163	29,273.4	1810.6	1.4	132	58,343.5	1812.5	3.3	162	58,493.1
n035w4_0_1-7-1-8	1337.1	1345.3	8.2	134	29,516.6	1345.7	8.6	158	29,530.9	1343.5	6.4	135	58,611.2	1346	8.9	146	58,320.9
n035w4_2_8-8-7-5	1075.6	1075.6	0	122	29,326	1075.6	0	154	29,289.3	1075.6	0	87	40,613.9	1075.6	0	124	47,420.1
n040w4_0_2-0-6-1	1535.2	1540.2	5	134	29,129.3	1541	5.8	155	29,274.7	1539.9	4.7	134	58,169.7	1540.4	5.2	150	58,551.9
n040w4_2_6-1-0-6	1741.7	1743	1.3	131	29,136.1	1743.5	1.8	156	29,304.6	1742.8	1.1	126	58,185.1	1743.5	1.8	158	58,556.9
n050w4_0_0-4-8-7	1295.5	1296.1	0.6	133	29,271.4	1296.8	1.3	152	29,354.6	1296.2	0.7	131	58,391.7	1296.8	1.3	156	58,471.5
n050w4_0_7-2-7-2	1302.1	1302.1	0	129	29,228	1302.2	0.1	156	29,280.3	1302.1	0	133	58,262.3	1302.2	0.1	156	58,393.4
n060w4_1_6-1-1-5	2434.9	2435.9	1	130	29,163.8	2436	1.1	158	29,293.2	2435	0.1	133	58,232.6	2436.2	1.3	157	58,502.7
n060w4_1_9-6-3-8	2664.3	2666.7	2.4	131	29,160.4	2665.5	1.2	155	29,229.2	2666.2	1.9	131	58,261.5	2666.2	1.9	152	58,217.5
n070w4_0_3-6-5-1	2370.3	2370.3	0	131	29,297.5	2370.7	0.4	157	29,218.9	2370.3	0	132	58,574.7	2371	0.7	155	58,175.4
n070w4_0_4-9-6-7	2105	2105	0	136	29,129	2105	0	157	29,236.4	2105	0	135	58,167.6	2106.4	1.4	159	58,362.8
n080w4_2_4-3-3-3	3292	3292	0	131	27,351	3292	0	149	29,176.1	3292	0	131	58,506.5	3292	0	145	56,526.2
n080w4_2_6-0-4-8	3177.1	3177.1	0	133	29,174.9	3177.1	0	153	29,283	3177.1	0	132	58,538.2	3177.1	0	152	58,375.9

present the computational results for the INRC-I and INRC-II instances, where SRCs, CG rank-1 cuts, and {0,½}-cuts are employed to strengthen the lower bounds across all instances. To assess the efficiency of different cuts in enhancing the lower bound, these tables document the instance name, the initial lower bound from the column generation process (LB), the lifted lower bound using each type of cut (LB*), the improvement in the lower bound (ILB), the number of cuts added to the RMP (cut_num), and the actual total solving time of the column generation process (time). Note that for effectiveness evaluation, we developed a control version of the SRCs separation algorithm excluding the pre-computation rules. Table 3 shows the comparative performance on INRC-II instances. For both CG rank-1 cuts and {0,½}-cuts, we implement time limit configurations {15, 8} or {30, 16}. In each iteration after achieving RMP optimality, we check whether the overall solving time has exceeded 8 (or 16) h. Upon reaching this threshold, the optimization process terminates immediately.

As shown in Table 3, separating SRCs with pre-computation rules offers substantial advantages without compromising solution quality. Across all instances, the LB* and its ILB remain identical to those without pre-computation rules, confirming that the pre-computation step does not sacrifice accuracy. The key gains lie in efficiency: the number of cuts added into RMP is dramatically reduced by an average of $58.8\%$, while computation time plummets by an average of $91.5\%$. The consistent reduction in computational steps and runtime confirms the efficiency of these pre-computation rules.

As presented in Table 4, SRCs consistently outperform both CG rank-1 cuts and {0,½}-cuts on INRC-I instances across all tested time limit configurations. Specifically, SRCs yield tighter bounds than CG rank-1 cuts in 50% of instances and {0,½}-cuts in 33.3% of instances. Figure 1 presents two challenging instances to show how lower bounds improve differently when applying these cuts independently. A particularly significant finding from our experiments is that for the “medium_hidden01” instance, SRCs yield a new lower bound of 103.8, surpassing the previously reported lower bound of 103 in [21]. This advancement underscores the effectiveness of SRCs in refining solution bounds for challenging problem instances.

For CG rank-1 cuts and {0,½}-cuts, increasing the time limits for both separation and overall solving processes yields minimal benefits. Under the {30, 16} configuration, CG rank-1 cuts show no performance improvement and {0,½}-cuts exhibit gains in “medium_hidden01” (LB* increasing from 98.8 to 99) and “medium_hidden02” (LB* increasing from 214.9 to 215). Under both time limit configurations, {0,½}-cuts consistently produce tighter lower bounds than CG rank-1 cuts across all lifted instances. The most pronounced performance is observed in “long_hidden01”, where they achieve the tightest lower bound among all methods. In the case of CG rank-1 cuts, a critical observation was made with the lifted instance “medium_hidden01”. Under the {15, 8} configuration, the solving process exceeded 24 h without converging to optimality after incorporating 18 cuts into the RMP. Thus, we interrupted the computation and documented the performance of the lifted solution up to that point. Under the {30, 16} configuration, we observed identical convergence issues. A key contributing factor to such difficulties is the numerical instability often encountered with CG rank-1 cuts. This instability stems from their multipliers, which can take any value in the interval (0, 1). This characteristic critically impacts the solving of the PSP by weakening the effectiveness of dominance rules, ultimately leading to the observed computational inefficiency and failure to converge.

For INRC-II instances (Table 3 and Table 5), {0,½}-cuts demonstrate superior performance to both SRCs and CG rank-1 cuts. SRCs improve lower bounds in 57.1% of instances, and the total solving time for process control remain within 90 s despite the addition of over 350 cuts. Under the {15, 8} configuration, while CG rank-1 cuts cannot improve lower bounds for instances where SRCs are ineffective, they achieve higher ILB values than SRCs in 87.5% of improvable cases. {0,½}-cuts produce the strongest overall results, improving lower bounds for 71.4% of instances (14.3% more than alternatives) and achieving higher ILB values than both SRCs and CG rank-1 cuts in 100% and 87.5% of improvable cases, respectively. Figure 2 visually demonstrates how SRCs, CG rank-1 cuts, and {0,½}-cuts each strengthen lower bounds differently in two example instances.

Under the {30, 16} configuration, CG rank-1 cuts produce better lower bounds in 14.3% of instances (specifically “n030w4_1_6-7-5-3” and “n050w4_0_0-4-8-7”), but demonstrate worse performance in 42.9% of cases. In contrast, {0,½}-cuts achieve improved lower bounds in 42.9% of instances while showing minor degradations in only 14.3% of cases. Notably, {0,½}-cuts obtain an absolute improvement of 1.4in the lower bound for instance “n070w4_0_4-9-6-7”, where no enhancement had been observed under the {15, 8} configuration. Three key factors probably explain the superior performance of {0,½}-cuts: (1) their constrained multiplier space (limited to 0 or ½) enables more computationally efficient separation than CG rank-1 cuts; (2) their unrestricted formulation enables generation of both more numerous and stronger violated cuts compared to SRCs; and (3) their inherent numerical stability circumvents the convergence issues prevalent in CG rank-1 cuts.

These computational results demonstrate that the effectiveness of different cut types in improving lower bounds is closely tied to the problem formulation. Based on experimental analysis, we identify two key characteristics of INRC-II that explain the comparatively weaker performance of SRCs on INRC-II versus INRC-I. First, INRC-II incorporates optimal nurse requirements rather than just minimum requirements, requiring the introduction of additional integer decision variables to track deviations from optimal staffing levels. Second, INRC-II introduces skill assignment constraints, which necessitate coverage to be satisfied for each combination of day, shift, and skill, thereby substantially increasing the number of coverage constraints. These formulation differences make identifying violated SRCs more challenging, particularly for large instances. This motivated our introduction of CG rank-1 cuts and {0,½}-cuts. As presented above, {0,½}-cuts show better performance.

6. Conclusions

Lower bounds are fundamental to efficient B&P algorithms. First, they guide the branch-and-bound process by providing a global lower bound for optimality verification and local lower bounds for node pruning when these bounds exceed the best-known solution. Second, they form the foundation for critical algorithmic components in modern B&P solvers: primal heuristics for feasible solutions, strong branching for tree navigation, and variable fixing for problem reduction. Crucially, the effectiveness of these techniques depends on bound tightness—tighter bounds yield faster convergence, smaller search trees, and improved overall performance in solving large-scale optimization problems. In this study, we propose three classes of non-robust cutting planes for NRPs—specifically, SRCs, CG rank-1 cuts, and {0, ½}-cuts—to enhance the lower bounds generated through column generation. For each cut type, we describe separation approaches augmented with acceleration strategies. As these cuts are inherently non-robust, each addition to the RMP necessitates introducing new resources in the PSP’s labeling algorithm. Consequently, we developed specialized methods to: (1) efficiently update these resources, and (2) seamlessly integrate them within the NRP dominance rules. Computational experiments on selected INRC-I and INRC-II instances show that the effectiveness of different cut types in improving lower bounds is related to the problem formulation. SRCs significantly improve bounds for challenging INRC-I cases, while {0, ½}-cuts outperform other cuts on INRC-II instances. These results demonstrate cutting planes’ considerable potential to enhance solution efficiency in B&P algorithms for NRPs.

There are two major limitations in this study that require further research attention. First, more efficient separation procedures are needed. Our implementation generates SRCs cuts exclusively for $\left|C\right|=3$ cases, since cut generation for $\left|C\right|\ge 4$ would incur prohibitively long runtimes. For CG rank-1 cuts and {0, ½}-cuts, the MIP solver for the separation problem rarely terminates with an optimal solution within the time limit. Integrating cuts whose separation procedures take tens of minutes or longer into a B&P framework is clearly impractical. One acceleration approach is to develop separation heuristics and reduction rules. Several such strategies have been reported in the literature [30,37]. However, developing such methods requires a deep understanding of the specific structure of the NRP. Machine learning presents a promising data-driven alternative to identify key cut characteristics and improve computational efficiency [38]. Second, our analysis focuses solely on column generation contexts. Prior research suggests greater potential could be realized by integrating these cuts into branch-and-bound with proper management strategies, particularly for mixed 0-1 programs [39]. Implementing them in B&P algorithms appears especially promising. Similarly, machine learning could optimize both which cuts to apply and when to apply them within branch-and-bound frameworks [40].