A constructive branch-and-bound algorithm for the project duration problem with partially renewable resources and general temporal constraints

This paper deals with the resource-constrained project scheduling problem with partially renewable resources and general temporal constraints with the objective to minimize the project duration. The consideration of partially renewable resources allows to integrate the decision about the availability of a resource for a specific time period into the scheduling process. Together with general temporal constraints, which permit to establish minimum and maximum time lags between activities, even more aspects of real-life projects can be taken into account. We present a branch-and-bound algorithm for the stated problem that is based on a serial schedule-generation scheme. For the first time it is shown how a dominance criterion can be applied on the associated generation scheme to reduce the start times in each scheduling step. To improve the performance of the solution procedure, we integrate consistency tests and lower bounds from the literature and devise new pruning techniques. In a comprehensive experimental performance analysis we compare our exact solution procedure with all available branch-and-bound algorithms for partially renewable resources. Additionally, we investigate a directly derived priority rule-based approximation method from our new enumeration scheme. The results of the computational study demonstrate the efficiency of our branch-and-bound algorithm and reveal that the derived approximation method is only suited to solve small- and medium-sized instances.


Introduction
In the field of project scheduling, a great deal of effort has been devoted over the years to renewable resources, which are able to model resources like staff or machines that are assumed to be available in a specific quantity at each point in time (or period). In this work, we consider a more general resource type, which has firstly been introduced under the term partially renewable resources in the framework of project scheduling by Böttcher et al. (1999). The corresponding problem, denoted by RCPSP/π , is a generalization of B Kai Watermeyer kai.watermeyer@tu-clausthal.de Jürgen Zimmermann juergen.zimmermann@tu-clausthal.de 1 Operations Research Group, Institute of Management and Economics, Clausthal University of Technology, Julius-Albert-Str. 2, 38678 Clausthal-Zellerfeld, Germany the classical resource-constrained project scheduling problem (RCPSP). The motivation for the extension of RCPSP by partially renewable resources stems from the restrictiveness of the renewable resources in the sense that the availability for each time period has to be fixed in advance, separated from the scheduling process. This limitation is resolved by partially renewable resources that are defined over multiple time periods with a given capacity. Thereby, the resources are consumed only on the defined time periods by the activities of the project. Examples for the application of RCPSP/π can be found in Böttcher et al. (1999) for the flexible planning of lunch breaks, in Alvarez-Valdes et al. (2008) for the assignment of weekend work, or in Alvarez-Valdes et al. (2015) for a school timetabling problem.
In the last decades, approximation and exact solution procedures have been developed for RCPSP/π . In Böttcher et al. (1999) and Schirmer (1999), priority rule-based methods for RCPSP/π are investigated. The works of Alvarez-Valdes et al. (2006, 2008, 2015 are devoted to a GRASP and a scatter search algorithm, and in Schirmer (1999) different local-search procedures are considered. The state-of-the-art approximation method for RCPSP/π in terms of the solution quality is given by the scatter search algorithm. This procedure makes use of a priority rule-based generation scheme to determine feasible schedules, which are iteratively combined with each other to obtain better solutions. Böttcher et al. (1999) devised the only exact solution procedure for RCPSP/π . The branch-and-bound algorithm (BnB) is based on the enumeration scheme by Talbot and Patterson (1978) for which the authors have developed two feasibility bounds.
For the first time, Watermeyer and Zimmermann (2020) have extended RCPSP/π by taking minimum and maximum time lags between the activities into account (RCPSP/maxπ ). An example for this problem is the planning of a training program for an employee that consists of a theoretical and a practical course. Thereby, the theory has to be taught first, the practical course is not supposed to be conducted more than two weeks after, and at most one course should take place at a weekend day. The temporal constraints between both courses are represented by minimum and maximum time lags, while the weekend constraint is given by a partially renewable resource that is defined over all weekend days with a capacity for one course. The state-of-the-art exact solution procedure for RCPSP/max-π and RCPSP/π is provided in Watermeyer and Zimmermann (2020) by a relaxation-based BnB. The procedure progressively reduces the possible resource consumptions by the activities of the project in each branching step and solves the corresponding resource relaxations.
In this work we present a new BnB for RCPSP/max-π that is based on a serial schedule-generation scheme. The new enumeration approach schedules all activities of the project successively by assigning a start time to an activity in each branching step. In this way, partial schedules are augmented in the course of the enumeration until there is no feasible start time left or a complete schedule is determined.
The remainder of this paper is organized as follows. Section 2 provides a formal description of RCPSP/max-π . In Sect. 3 we discuss the enumeration scheme of our BnB. Section 4 deals with improving techniques, and Sect. 5 describes the BnB. In Sect. 6 we present the results of a comprehensive experimental performance analysis and provide some conclusions in Sect. 7.

Problem description
RCPSP/max-π can be represented by an activity-on-node project network N with node set V , covering all activities of the project, and arc set E ⊂ V × V , implying the precedence relationships among them. Each activity i ∈ V is assigned a non-interruptible processing time p i ∈ Z ≥0 and a resource demand r d ik ∈ Z ≥0 for each partially renewable resource k ∈ R. The temporal constraint for each activity pair (i, j) ∈ E is specified by a start-to-start precedence relationship and arc weight δ i j ∈ Z, meaning that each temporal constraint is given by S j ≥ S i + δ i j , establishing a time lag between the start times of activities i and j. In the following we speak of a minimum time lag between activities i and j if δ i j ≥ 0 and say that a maximum time lag is given if δ ji < 0. The node set V :={0, 1, . . . , n + 1} includes two fictitious activities 0 and n + 1, i.e., p 0 = p n+1 = 0, which represent the beginning and the termination of the project, respectively. It is assumed that each project starts at time 0 and is completed before a prescribed deadlined, i.e., S 0 = 0 and S n+1 ≤d. In the remainder of this work, we call a vector S = (S i ) i∈V with S i ∈ Z ≥0 and S 0 = 0 a schedule and speak of a time-feasible schedule if all temporal constraints are satisfied and S n+1 ≤d. By S T , we denote the set of all time-feasible schedules. The resource constraints of RCPSP/max-π are given by the resource capacities R k ∈ Z ≥0 of all partially renewable resources k ∈ R. Thereby, the availability of each resource is only limited on a specified subset of all time periods within the entire planning horizon Π k ⊆ {1, 2, . . . ,d}. As a consequence, only the resource consumption of an activity i ∈ V k :={i ∈ V | r d ik > 0} over the time periods in Π k has to be taken into account. In order to express the number of the time periods in Π k an activity i ∈ V is in execution, we introduce the so-called resource usage Based on the resource usage, the resource consumption of a resource k ∈ R by an activity i ∈ V follows directly with r c ik (S i ):=r u ik (S i ) · r d ik , so that the resource constraints can be stated by i∈V r c ik (S i ) ≤ R k for all k ∈ R. In the following, we call a schedule S that fulfills all resource constraints a resource-feasible schedule and denote the set of all resource-feasible schedules by S R . Furthermore, we say that schedule S ∈ S is feasible with S:=S T ∩ S R as the set of all feasible schedules.
The objective of RCPSP/max-π is to determine a feasible schedule S * with the shortest project duration among all feasible schedules S ∈ S. The corresponding problem is stated by with f : S → R as the objective function that assigns the project duration to each feasible schedule S. We call a schedule S that solves problem (P) an optimal schedule and denote the set of all optimal schedules by OS.
It should be noted that there also exist other approaches to model partially renewable resources by assigning multiple subsets of time periods to each of them with the advantage of a more intuitive connection to resources in real-life applications (Böttcher et al. 1999). In this work, we use the so-called normalized formulation for partially renewable resources that turned out to be more appropriate for theoretical issues since each restriction of a real-life resource is represented by exactly one partially renewable resource.

Enumeration scheme
In general, the enumeration scheme of a BnB specifies the procedure to construct the search tree or rather implicates how to generate all direct descendants of a search node. In the following, we present the enumeration scheme of our BnB, which is based on a serial schedule-generation procedure complemented by an unscheduling step. The concept of unscheduling is based on the work of Franck et al. (2001) that provides a serial schedule-generation scheme for RCPSP with general temporal constraints (RCPSP/max).
The construction procedure of the directed outtree corresponding to the enumeration scheme of our BnB is described in Algorithm 1. In this procedure, each enumeration node is represented by a pair (C, S) with C ⊆ V as the set of all currently scheduled activities and S as a time-feasible schedule that represents the start times S i for all activities i ∈ C and the earliest time-feasible start times for all not currently scheduled activities i ∈ V \ C. To simplify the following explanations, we use the concept of partial schedules, referring to Definition (2.6.3) in Neumann et al. (2003), to describe the start times of all currently scheduled activities for some enumeration node.
Definition 1 S C :=(S i ) i∈C with C ⊆ V and schedule S is called a partial schedule. In case that S j ≥ S i + δ i j for all (i, j) ∈ E ∩ C × C, partial schedule S C is said to be time-feasible and is termed resource-feasible if i∈C r c ik (S i ) ≤ R k for all k ∈ R. In compliance with schedules, a time-feasible and resource-feasible partial schedule S C is called feasible. S C∪{i} with i ∈ V \ C is said to be the augmentation of S C by activity i and S i is termed time-feasible, resource-feasible or feasible if partial schedule S C∪{i} is time-feasible, resource-feasible or feasible, respectively.
Algorithm 1 outlines the enumeration scheme of our BnB. In the initialization step, the distance matrix D:=(d i j ) i, j∈V with d i j as the length of a longest path between activities i and j in project network N is calculated with the Floyd-Warshall algorithm (Ahuja et al. 1993, Sect. 5.6). Then, the earliest and latest time-feasible schedules ES and LS are derived and the root node (C, S) is initialized by C:={0} and S:=ES, meaning that the project start is scheduled at time 0, so that partial schedule S C = (0) with S 0 = 0 corresponds to the root node. For the enumeration scheme we use set Ω to store all generated enumeration nodes that are still to be explored, and Φ to gather all generated schedules during the construction procedure. Accordingly, these sets are initialized by Ω:={(C, S)} and Φ:=∅.

Algorithm 1: Enumeration scheme
Input: Instance of problem RCPSP/max-π Output: Set Φ of candidate schedules In each iteration of Algorithm 1 some pair (C, S) is removed from Ω. In case that C = V , some activity i ∈C from the set of all not currently scheduled activitiesC:=V \C is chosen. For this activity, all resource-feasible start times in {S i , . . . , LS i } are determined and stored in the so-called scheduling set Θ i . The resource-feasibility is ensured by taking the resource consumption r c k (S C ):= j∈C r c jk (S j ) for each resource k ∈ R i :={k ∈ R | r d ik > 0} of partial schedule S C into account. Afterward, based on a dominance criterion with similarities to left-shift dominance rules for renewable resources (see, e.g., Stinson et al., 1978;Demeulemeester and Herroelen, 1992), the reduced scheduling set T i is calculated. T i comprises all start times from Θ i with a lower resource consumption for at least one resource k ∈ R i compared to all lower start times in Θ i . The calculation of T i , which is defined by Based on the reduced scheduling set T i , all direct descendants of enumeration node (C, S) are generated. For each descendant node (C , S ), some scheduling time t ∈ T i is established as the start time S i of activity i, followed by an update of the earliest time-feasible start times for all activities by S :=(max(S j , S i + d i j )) j∈V if it is assumed that activity i starts at time t. Since for each start time t ∈ T i the conditions S j + d ji ≤ t for all currently scheduled activities j ∈ C are satisfied, in case that t is not time-feasible, there has to be at least one activity j ∈ C with S j − d i j < t. This means that the induced latest start time LS i (S j ):=S j − d i j of activity i by some activity j ∈ C prevents the time-feasibility of start time t. As a consequence, in order to achieve the time-feasibility of S C∪{i} with S i = t, all currently scheduled activities j ∈ C with t > LS i (S j ) or rather S j > S j are unscheduled by setting C :=C \ { j ∈ C | S j > S j }. More precisely, the unscheduling of an activity is done by removing it from the set of all currently scheduled activities C of the direct ancestor node. It should be noted that 0 ∈ C is always ensured by t ≤ LS i due to the definition of Θ i . In case that start time t is time-feasible (t ≤ min j∈C LS i (S j )), activity i is scheduled at start time S i = t by setting C :=C ∪ {i}. Finally, after the scheduling or unscheduling step, the descendant node (C , S ) is stored in Ω in order to be explored in one of the following iterations. From the description of the procedure to schedule or unschedule activities it follows directly that each partial schedule S C of an enumeration node (C, S) is feasible. Therefore, in case that some node (C, S) with C = V is removed from Ω, schedule S = S C ∈ S is stored in Φ as a candidate schedule. After all enumeration nodes have been explored, i.e., Ω = ∅, Algorithm 1 terminates and returns set Φ, which contains all candidate schedules generated in the course of the enumeration procedure.

Reduced scheduling set
This section deals with the calculation of the reduced scheduling set T i in each branching step of Algorithm 1. For the first time, we provide a procedure to determine dominant start times from Θ i , while all existing schedule-generation schemes for partially renewable resources consider all start times from Θ i in each scheduling step (see Schirmer, 1999;Alvarez-Valdes et al., 2006;2008;2015).
The procedure to calculate the reduced scheduling set To simplify the representation, the definition min ∅:=∞ is assumed. In the course of the procedure, variable t serves as the start time that is considered in the current iteration, while boolean variable element is used to indicate if start time t is or is not an element of T i . The algorithm starts with an empty set T i and checks in each iteration for some start time t ∈ Θ i if there is any start time τ ∈ T i with r u ik (t) ≥ r u ik (τ ) for all k ∈ R i . This is done in the procedure by checking for each τ ∈ T i if there is at least one resource k ∈ R i with r u ik (t) < r u ik (τ ). If this is the case for all start times in T i , meaning that there is no start time τ ∈ T i with r u ik (t) ≥ r u ik (τ ) for all k ∈ R i , t is added to T i . Since all start times t ∈ Θ i are considered in an increasing order, the condition that there is no start time τ ∈ T i with r u ik (t) ≥ r u ik (τ ) for all k ∈ R i implies that there is also no lower start time in Θ i satisfying this condition. This can be verified by noticing that for each start time τ ∈ Θ i that has not been added to T i in the course of Algorithm 2, there is at least one lower start time τ ∈ T i with r u ik (τ ) ≤ r u ik (τ ) for all k ∈ R i . Finally, since for each start time t ∈ Θ i that is not an element of T i at the end of the procedure there is at least one earlier start time τ ∈ Θ i (τ ∈ T i ) with r u ik (t) ≥ r u ik (τ ) for all k ∈ R i , we can state that Algorithm 2 is correct.

Correctness of the enumeration scheme
In what follows, we prove that Algorithm 1 generates at least one optimal schedule in finitely many iterations if and only if there is at least one feasible solution. It should be noted that the total correctness of Algorithm 1 follows directly from this proof since each candidate schedule is feasible, i.e., Φ ⊆ S. First of all, Theorem 1, which is based on Lemmas 1 and 2, states that the enumeration scheme generates at least the set of all so-called active schedules AS. In line with Neumann et al. (2000), we call a feasible schedule S active if and only if there is no feasible schedule S = S with S ≤ S, i.e., S i ≤ S i for all i ∈ V . By definition, for each non-active feasible schedule there is at least one activity whose start time can be left-shifted to obtain a feasible schedule. As a consequence, there has to be at least one optimal schedule that is active for each instance with S = ∅, so that Theorem 1 implicates the completeness of Algorithm 1, i.e., S = ∅ ⇔ Φ ∩ OS = ∅.
Lemma 1 Let T i be the reduced scheduling set of Θ i . Then T i contains exactly all lowest scheduling times t ∈ Θ i that satisfy r u ik (t) ≤ r u ik (τ ) for any τ ∈ Θ i and all k ∈ R i , i.e., Proof Consider any start time t ∈ T i . From the definition of T i it follows directly that t = min{τ ∈ Θ i | r u ik (τ ) ≤ r u ik (t) for all k ∈ R i }, so that T i ⊆ T ∪ i is given. Next, let τ ∈ Θ i and t:= min{τ ∈ Θ i | r u ik (τ ) ≤ r u ik (τ ) for all k ∈ R i } be given and assume t / ∈ T i . Since t / ∈ T i implies t > min{τ ∈ Θ i | r u ik (τ ) ≤ r u ik (τ ) for all k ∈ R i }, which would contradict the assumption for t, T i ⊇ T ∪ i and therefore T i = T ∪ i follows.
Lemma 2 Let S f ∈ S be any feasible schedule and (C, S) some node corresponding to the enumeration scheme of Algorithm 1 with C = V , S ≤ S f and r u jk (S j ) ≤ r u jk (S f j ) for all j ∈ C and all k ∈ R j . Then there is at least one direct descendant node (C , S ) that fulfills the conditions S ≤ S f and r u jk (S j ) ≤ r u jk (S f j ) for all j ∈ C and all k ∈ R j .
Proof Let i ∈C be the selected activity for the generation of the direct descendants of enumeration node Theorem 1 Algorithm 1 generates all active schedules, i.e., Φ ⊇ AS.
Proof For each active schedule S a ∈ AS the conditions S ≤ S a and r u jk (S j ) ≤ r u jk (S a j ) for all j ∈ C and all k ∈ R j are satisfied with (C, S) corresponding to the root node. Accordingly, it follows from Lemma 2 that there exists at least one path in the enumeration tree on which each node (C, S) satisfies the conditions S ≤ S a and r u jk (S j ) ≤ r u jk (S a j ) for all j ∈ C and all k ∈ R j , respectively. Since for the generation of any direct descendant node either the start time S j for at least one activity j ∈ C is increased (S j > S j ) or some activity i ∈C is scheduled (C :=C ∪ {i}), each such path has a finite length. Finally, from the property of Algorithm 1 that each generated schedule S ∈ Φ is feasible and since S ≤ S a with S = S a would contradict the assumption that S a is active, we can state that Algorithm 1 generates all active schedules.
Finally, Lemma 3 establishes that the enumeration scheme terminates after a finite number of iterations.

Lemma 3 Algorithm 1 generates at most
Proof For the generation of any descendant node in the enumeration scheme of Algorithm 1 either the selected activity i ∈C is scheduled or the start time S j of any activity j ∈ C is increased by at least one unit. Since the start time of each activity is bounded from above byd + 1, an upper bound for the maximum depth of the enumeration tree is given by |V |(d + 1). Accordingly, an upper bound for the maximum number of generated nodes is given by (d + 1) |V |(d+1) taking into consideration that the number of start times in T i is bounded from above byd + 1.

Improving techniques
In Watermeyer and Zimmermann (2020) it has already been shown for a relaxation-based BnB for RCPSP/max-π that the application of consistency tests, lower bounds , and techniques to avoid redundancies can have a great impact on the performance. In what follows, we extend our enumeration scheme to be able to use consistency tests and lower bounds from Watermeyer and Zimmermann (2020) and to apply new devised pruning techniques that are described in Sect. 4.3.

Extended enumeration scheme
For the extension of the enumeration scheme we establish a domain W i ⊆ H :={0, 1, . . . ,d} for the start time S i of each activity i ∈ V . Set W i contains all possible start times of activity i ∈ V , i.e., S i ∈ W i . In line with Definition 1 in Watermeyer and Zimmermann (2020), we call W :=(W i ) i∈V with W i ⊆ H for all i ∈ V and W 0 = {0} a start time restriction and denote by W i the start time restriction of activity i ∈ V . In the following we speak of a W -feasible schedule S if S ∈ S T (W ):={S ∈ S T | S i ∈ W i for all i ∈ V } and say that a partial schedule S C is W -feasible if there is at least one schedule S ∈ S T (W ) with S i = S i for all scheduled activities i ∈ C. Furthermore, in accordance with Definition 1, we say that start time S i of some not currently scheduled activity i ∈C is W -feasible exactly if augmentation S C∪{i} is W -feasible. Therefore, if t is established as the earliest possible start time of some activity i ∈ V , the earliest W -feasible start time of any activity j ∈ V is expressed by In the same way, the latest W -feasible start time of an activity j ∈ V is given by is assumed to be the latest possible start time of activity i ∈ V . In Watermeyer and Zimmermann (2020), two algorithms have been introduced that are able to determine the minimal point of S T (W , i, t) and the maximal point of S T (W , i, t), respectively.
The extension of the enumeration scheme is given in Algorithm 3. For each enumeration node a start time restriction W is stored in addition, so that each node is given by a triple (C, S, W ). At the beginning of the algorithm, W i :={ES i , . . . , LS i } for all i ∈ V ensures that all feasible schedules S ∈ S are covered by the set of all W -feasible Algorithm 3: Extended enumeration scheme Input: Instance of problem RCPSP/max-π Output: Set Φ of candidate schedules In the further course of the algorithm, recalling that W i represents the domain of start time S i , all start times in T i of some activity i ∈C are limited to W i . Accordingly, each start time t ∈ T i that is assigned to activity i ∈C is assured to be an element of W i . In the branching step, in order to generate a descendant node (C , S , W ), some start time t ∈ T i is established as the earliest start time of activity i ∈C by setting S i :=t. Following, the earliest W -feasible schedule S with S ≥ S and S i ≥ t is determined. Since S = (min W i ) i∈V is assured at the start of each iteration, the earliest W -feasible schedule with S ≥ S and S i ≥ t is obtained by It should be noted that in general, due to the breaks in W , The proof of the total correctness of the extended enumeration scheme is closely related to that of Algorithm 1. In Lemma 2, only the conditions S f ∈ S T (W ) for node (C, S, W ) and S f ∈ S T (W ) for its direct descendant node (C , S , W ) have to be considered in addition. Based on this, the completeness of Algorithm 3 follows analogously to the proof of Theorem 1, while Lemma 3, which still applies to Algorithm 3, states the total correctness.

Lower bounds and consistency tests
In this section, we shortly present lower bounds and consistency tests that have been developed in Watermeyer and Zimmermann (2020).
The first lower bound is equal to the earliest time-feasible project termination if the start time restrictions of all activities are taken into account. The corresponding lower bound is given by LB0 π :=ES n+1 (W ) with ES(W ):= min S T (W ). The second lower bound LBD π is determined in a destructive way, meaning that a hypothetical upper bound on the project duration d is increased as long as it precludes any feasible solution (Brucker and Knust, 2003). To determine the destructive lower bound LBD π in any node (C, S, W ), a binary search is conducted on some time interval [LB0 π , UB − 1] with UB as the best solution that has been found in the course of the BnB ord + 1, otherwise. In each iteration, it is checked if the sum of the minimum possible consumptions } over all activities exceeds the capacity of at least one resource k. In this case, there cannot be any feasible schedule with S n+1 ≤ d, so that d + 1 is established as a lower bound for the binary search. Otherwise, d − 1 is set as an upper bound. This procedure continues until LBD π is determined, i.e., the lowest hypothetical upper bound on the project duration that does not preclude any feasible schedule.
In general, a consistency test establishes an implicit constraint of a problem if some specified condition is satisfied. For all consistency tests we consider, these implicit constraints are unary on the start time of some activity. Accordingly, each consistency test is described by a condition and a reduction rule on the start time restriction of some activity. In line with Dorndorf et al. (2000a), each of the following consistency tests can be interpreted as a function γ mapping any start time restriction W to an updated start time The first three consistency tests are based on the temporal constraints S j ≥ S i + δ i j for all (i, j) ∈ E of problem (P), so that they could be applied on any project scheduling problem independent on the considered resource type. The following two consistency tests are well known and have already been applied on project scheduling problems (see, e.g., Dorndorfet al., 2000b;Alvarez-Valdes et al., 2008). The first (second) test is based on checking for some activity pair (i, j) ∈ E if the currently lowest (greatest) possible start time W j := min W j (W i := max W i ) of activity j (i) is consistent with the lowest (greatest) possible start time min W i (max W j ) of activity i ( j) with respect to time lag δ i j . The corresponding conditions and reduction rules are given as follows: In this work, both tests are gathered under the term temporal-bound consistency test.
The next consistency test, which is also based on the temporal constraints of problem (P), checks for each possible start time of some activity whether there even exists any Wfeasible schedule with this start time of the activity. One pass of the so-called temporal consistency test considers all start times in the start time restrictions over all activities. The corresponding condition and reduction rule for some start time t ∈ W i of an activity i ∈ V is given by Next, we deal with consistency tests that take the resource constraints of problem (P) into account. All the following tests have in common that they check for each start time of some activity if its induced resource consumption and the minimum consumptions over all other activities exceed the capacity of at least one resource. The general condition is stated by The difference between the consistency tests is given by the determination of the possible start times W r j for the activities j ∈ V \ {i}. For the resource-bound consistency test, W r j is given by the start time restriction, i.e., W r j :=W j . Extensions of the resource-bound consistency test are the so-called D-interval and W -interval consistency tests that restrict the number of start times in W r j by taking temporal constraints into account. While the D-interval consistency test considers W r j : , the W -interval consistency test restricts W r j even more by setting

Pruning the enumeration tree
In this section, we present two techniques that are able to reduce the set of schedules that are explored by a node in the course of the enumeration scheme. For both methods, the branching step of Algorithm 3 is extended by a procedure that reduces the start time domain of the branching activity.
It should be noted that in contrast to methods that remove generated nodes, the following techniques prune parts of the enumeration tree by adding constraints to each node in the branching step to prevent that parts of the search tree are generated at all. In a first step we develop the two pruning techniques separately from each other. Afterward, we show that the combination of both methods ensures that each part of the time-feasible region is explored exactly once in the course of the enumeration scheme. The first technique is based on the storage of the resource usage that is induced by the selected activity and its start time in the branching step as a lower bound for all possible start times of the considered activity. In order to apply the socalled usage-preserving technique (UPT), the branching step of the extended enumeration scheme is adapted as follows. Before start time t ∈ T i is established as the earliest start time of some activity i ∈C in line 15 of Algorithm 3, W :=W is initialized and W i :={τ ∈ W i |r u ik (τ ) ≥ r u ik (t) for all k ∈ R i } is set. Additionally, for all further operations in line 15, start time restriction W is replaced by W . Since the application of UPT in Algorithm 3 implies for any node (C, S, W ) and any schedule S ∈ S T (W ) that the conditions S ≤ S and r u jk (S j ) ≤ r u jk (S j ) for all j ∈ C and all k ∈ R j are satisfied, Corollary 1 follows.
Corollary 1 Let UPT be used in Algorithm 3, let S f ∈ S be any feasible schedule, and (C, S, W ) some node corresponding to the enumeration scheme of Algorithm 3 with C =V and S f ∈ S T (W ). Then there is at least one direct descendant node (C , S , W ) that fulfills the condition S f ∈ S T (W ).
As a consequence of Corollary 1, noticing that S T (W ) ⊆ S T (W ) for some node (C, S, W ) and any of its descendants (C , S , W ), precisely S T (W ) is completely explored by enumeration node (C, S, W ) and all its descendants. In other words, there is no descendant node that explores a part of the time-feasible region S T that is not a part of S T (W ). It should be noted that due to the unscheduling of activities this is not assured if UPT is not applied.
The second pruning technique is based on the consideration of the resource usages of all start times in the reduced scheduling set that are lower than the established earliest start time of the selected activity in the branching step. To apply the second pruning technique, the same extensions as for the first method are made in line 15 of Algorithm 3, except for the setting of W i that is replaced by Accordingly, the second method removes each start time τ from W i if there is at least one start time τ in the reduced scheduling set T i that is lower than t and satisfies r u ik (τ ) ≥ r u ik (τ ) for all k ∈ R i . Since this implies for each start time τ ∈ W i that there is at least one resource k ∈ R i with r u ik (τ ) < r u ik (τ ) for each τ ∈ [0, t[ ∩ T i , we call this method usage-limitation technique (ULT).
In what follows, we investigate the application of both pruning techniques in Algorithm 3. For this, we consider two direct descendants (C , S , W ) and (C , S , W ) of some node in the enumeration tree. In addition, we assume that both nodes (C , S , W ) and (C , S , W ) are generated by establishing t and t with t < t as the earliest start time of the branching activity i ∈C, respectively. Considering the specifications of both pruning techniques to reduce the start time restriction of the branching activity, W i ∩ W i = ∅ is given. Since W i ∩ W i = ∅ directly implies S T (W ) ∩ S T (W ) = ∅, Corollary 2 follows from Corollary 1.

Corollary 2 Let UPT and ULT be used in Algorithm 3
, let S f ∈ S be any feasible schedule, and (C, S, W ) some node corresponding to the enumeration scheme of Algorithm 3 with C = V and S f ∈ S T (W ). Then there is exactly one direct descendant node (C , S , W ) that fulfills the condition S f ∈ S T (W ).
Taking S T (W ) ⊆ S T (W ) for some node (C, S, W ) and any of its descendants (C , S , W ) into account, from Corollary 2 it follows that each candidate schedule is generated exactly once if both pruning techniques UPT and ULT are used. Furthermore, we can state that in the course of the enumeration, each part of the time-feasible region is explored exactly once, so that any redundancy is excluded.

Branch-and-bound algorithm
In this section we present the general framework of our BnB that enables a wide range of different settings concerned with the construction of the enumeration tree and the application of improving techniques. The first part of this section is devoted to the search strategy of our BnB that determines the way to construct the enumeration tree. In order to provide a generic framework for the construction of the search tree, in line with Watermeyer and Zimmermann (2020), we divide the search strategy in different parts, called traversing, branching, generation, and ordering strategy.
For the traversing strategy, which determines the node to be considered next in the course of the BnB, we have implemented two alternatives. The first alternative is the wellknown depth-first search (DFS), while the second one is an extension of the DFS that has been introduced by Watermeyer and Zimmermann (2020). The so-called scatteredpath search (SPS) selects after a predefined time span, among all not completely explored nodes with lowest search tree level, a node with the lowest bound on the project duration. After some node has been chosen to be explored next, the branching strategy determines the activity to be considered in the branching step. For this, in a first step, the so-called eligible set E ⊆C, i.e., the set of all activities that could be used for the branching step, is determined. The first alternative takes all not currently scheduled activities into consideration (C), i.e., E:=C. In contrast, the other two alternatives that are both based on a strict order ≺ in set V , reduce the set C, where E ⊆ {i ∈C | Pred ≺ (i) ⊆ C} holds with Pred ≺ (i) as the set of all direct predecessors of activity i ∈ V in a precedence graph G ≺ with V as the node set and the covering relation cr (≺) of the strict order as the arc set. The strict orders we use in this work have been introduced as distance order (≺ D ) and cycle order (≺ C ) in Franck et al. (2001) and Neumann et al. (2003, Sect. 2.6). For further details we refer the reader to those references. In the following, we assume that the eligible set E is given. Then in the next step of the branching strategy, the activity with the best priority value π i and the lowest index in set E is selected for the branching step. Accordingly the branching activity is given by where ext ∈ {min, max} indicates if lower (min) or greater (max) priority values are preferred. In what follows, we present some priority rules that have shown promising results in preliminary tests. First, we deal with priority rules that have already been discussed in the literature (see, e.g., Kolisch, 1996;Franck et al., 2001) and are concerned with the temporal constraints of the problem. These include among others the latest start time rule (LST) with π i = LS i and the slack time rule (ST) with π i = LS i − ES i . For both priority rules we have also tested dynamic versions that take the start time restrictions and the best found solution UB into account that are given by . Additionally, we have implemented a dynamic version of ST (STd I ) that considers the number of start times in the start time restriction by π i = |W i ∩ [ES i (W ), LS UB i (W )]|. Further rules are given by the total successor rule (TS) with π i = |Reach ≺ (i)| and Reach ≺ (i) as the set of all successors of activity i ∈ V in G ≺ , the path following rule (PF) with π i = l(i) and l(i) as the maximal number of nodes on any longest directed path from node i ∈ V to n + 1 in project network N , and the maximal resource consumption rule (MRC) with π i = p i k∈R i r d ik . In contrast to the priority rules from the literature, the following rules make use of the properties of the partially renewable resources. For this, the maximal possible additional resource consumption p i r d ik by an activity in relation to the maximal remaining resource capacityR k is considered with We have tested the following two different versions. The total maximal additional relative resource consumption rule (TMAR) with 1, and the average maximal additional relative resource consumption rule (AMAR) with π i = π i /|R i | and π i as the priority value of TMAR. After the branching activity has been selected for some enumeration node, the last part of the search strategy is concerned with the generation and the ordering of the direct descendants. For the generation strategy, we distinguish between the possibilities either to generate all direct descendants (all) or to restrict the number of generated nodes by a maximal value (restr), where one and the same node must possibly be explored more than once. Furthermore, we have implemented different orders in which all start times in the reduced scheduling set T i of branching activity i ∈ E are considered. The most intuitive alternative for this takes always the lowest start time from T i that has not been used so far to generate a direct descendant node (LT). The other alternative assigns a priority value π t to each start time t ∈ T i and considers all start times in T i in an order of non-decreasing priority values (PV), where ties are broken on the basis of lower start times. In what follows, we present the best priority value we have found to order the start times in T i . The corresponding priority value with a ikt := r c ik (t)/R k , ifR k = 0 1, otherwise and b ik := r d ik /R k , ifR k = 0 1, otherwise is a combination of a priority value that is highly related to the TMAR rule and a penalty term that increases the priority value in a linear fashion based on the difference between start time t and the earliest W -feasible start time ES i (W ). Finally, after all direct descendant nodes have been generated, the ordering strategy determines the order in which they are considered in the further course of the BnB. In this work, all generated descendant nodes are explored in an order of non-decreasing lower bounds on the project duration (LB), which has shown to provide good results in computational experiments.
In accordance with Watermeyer and Zimmermann (2020), we apply three different sets of consistency tests in our BnB. Set Γ B contains the temporal-and resource-bound consistency test, Γ D the temporal-bound and D-interval consistency test, and Γ W the temporal and W -interval con-sistency test. γ α β (W ) denotes the start time restriction that results if all consistency tests in Γ β are applied on W for α iterations. α = ∞ implies that the fixed point corresponding to Γ β is determined. To be able to differentiate between the possibilities for the D-interval and W -interval consistency test to use all resources or only the resources that are demanded by activity i, we use the notations γ α β (W ) [R] and γ α β (W )[R i ].

Algorithm 4: Branch-and-bound algorithm
Input: Instance of problem RCPSP/max-π Output: Optimal schedule S * Remove t from set T i (according to the generation strategy) In what follows, we outline the framework of our BnB, which is given in Algorithm 4. It should be noted that in order to simplify the presentation, we assume that a depth-first search (DFS) is used and that all direct descendants of each enumeration node are generated at once (all). Accordingly, all other alternatives for the traversing and the generation strategy are omitted. In the first part of Algorithm 4, a preprocessing step is performed on the start time restriction W , for which we calculate the fixed point of set Γ W considering all resources, meaning that W :=γ ∞ W (W ) [R] is set. In case that the preprocessing step cannot prove the infeasibility (S T (W ) = ∅), the global lower bound LB G is set to min W n+1 , the upper bound on the minimum project duration UB is set tod + 1, and the root node is initialized and put on stack Ω. In each iteration, an enumeration node (C, S, W , LB) is removed from stack Ω and it is checked if it could provide a solution with a better project duration than UB, i.e., LB < UB. In this case, consistency tests from set Γ D or Γ W are applied on the start time restriction W . If the consistency tests can show that the considered node and all its descendants cannot generate any feasible schedule with a better project duration than UB, i.e., S UB T (W ):= S T (W , n +1, UB −1) = ∅, the next enumeration node in Ω is considered. Otherwise, based on the branching strategy, the eligible set E is determined and the branching activity i ∈ E is selected, followed by the initialization of Λ, which is used to store all direct descendants of the considered enumeration node. In the next step, analogously to Algorithm 3, Θ i and the reduced scheduling set T i are calculated. The start times in T i are considered in an order depending on the generation strategy. Given some start time t that has been removed from T i , t is established as the earliest start time of the branching activity. It should be noted that line 19 of Algorithm 4 can be adapted as described in Sect. 4.3 to apply the pruning techniques UPT and ULT. After the initialization (and update) of start time restriction W , the consistency tests from set Γ B are applied on W . The direct descendant node corresponding to W is directly pruned from the enumeration tree if S UB T (W ) = ∅. Otherwise, in case that the existence of any feasible schedule in S T (W ) with a better objective function value than UB cannot be excluded, it is checked if some activities have to be unscheduled or if the branching activity can be scheduled. If C = V after the scheduling of the branching activity, a new best feasible solution S * :=S has been found, UB is set to S * n+1 , and all start times in T i that are greater than t are removed, noticing that they cannot generate any better feasible solution. Otherwise, the lower bound LB for the descendant node is calculated by LB0 π or LBD π . In case that LB < UB, the node is added to the list Λ, which is used after the generation of all direct descendant nodes to put them on the stack Ω in an order of non-increasing values of their lower bounds LB . The described procedure reiterates until there is no enumeration node left to be considered, i.e., Ω = ∅. In case that UB =d + 1 at the end of the algorithm, we can state that there is no feasible solution, while otherwise, Algorithm 4 returns an optimal solution S * .

Performance analysis
In this section, we evaluate the performance of our BnB. For this, we conduct computational experiments on different benchmark sets with partially renewable resources. To provide a comprehensive investigation, we compare our procedure with all available BnB from the literature for RCPSP/max-π and RCPSP/π . In a second step, we derive a priority rule-based approximation method from our new enumeration approach and evaluate its performance in comparison with the associated BnB.
The computational experiments have been conducted on a workstation with an Intel Core i7-8700 CPU with a clock pulse of 3.2 GHz and 64 GB RAM under Windows 10 on a single thread. The algorithms were all coded in C++ and compiled by the 64-bit Visual Studio 2017 C++-compiler.

Comparison of branch-and-bound algorithms
In the first part of the performance analysis, we compare our constructive BnB (CBB) with all available exact solution procedures from the literature for partially renewable resources. In the second part, we derive a schedule-generation scheme from our new enumeration approach and compare its results with those of CBB.

General temporal constraints
In this section, CBB is compared with the relaxation-based BnB (RBB) from Watermeyer and Zimmermann (2020) on instances with general temporal constraints. To the best of our knowledge, RBB represents the only BnB for RCPSP/maxπ that is available in the open literature so far. For the comparison of CBB with RBB, we have conducted computational studies on a benchmark set that covers instances with n = 10, 20, 50, 100, 200 real activities, all of them with 30 partially renewable resources. The benchmark set UBOπ , which is available online, 1 is an adaptation of the wellknown benchmark set UBO for RCPSP/max, which has been generated by the instance generator ProGen/max (Schwindt 1996(Schwindt , 1998. As described in Watermeyer and Zimmermann (2020), the test sets for RCPSP/max-π , denoted by UBOnπ , were obtained by a replacement of the renewable resources by partially renewable resources that have been generated in accordance with the procedure in Schirmer (1999, Sect. 10). Table 1 provides an overview of the settings we have used for CBB in the computational experiments depending on the instance size. The settings were determined by preliminary computational tests in the same way as for RBB in Watermeyer and Zimmermann (2020). Table 1 gives the set- Pruning techniques UPT UPT UPT+ULT UPT+ULT UPT+ULT tings that have shown the best balance between the number of solved instances and instances whose solvability statuses were determined among all settings we have tested. It should be noted that we have also analyzed the performance of both BnB that were conducted with only one setting over all instances of benchmark set UBOπ . The corresponding results are given in the supplementary material of this paper (Online Resource 1). While the most terms in Table 1 are in line with Sect. 5, there are some additional specifications, which are explained in the following. The values in brackets in Table 1 give the time span for the scattered-path search, the maximal number of generated nodes in one branching step for the generation strategy, and the maximal search tree level on which the sets of consistency tests are applied. The values in parentheses indicate if lower (min) or greater (max) priority values or lower bounds are preferred. As already mentioned, Table 1 lists the settings that have shown the best balance between the number of instances that were solved and whose solvability status remained open among all settings we have tested. From Table 1 it follows that the restriction of the eligible set for the branching step in accordance with strict orders (≺ D , ≺ C ) is only beneficial for greater instances. Furthermore, the computational studies reveal that resourcebased priority rules are preferable for small instances to select the branching activity, whereas temporal-based or networkbased priority rules are better suited for greater instances. It is also worth mentioning that SPS and the usage of priority values for the generation of direct descendant nodes (PV) have both a great impact on the performance for greater instances. Finally, taking a look on the improving techniques, Table 1 shows that it is beneficial over all instances to use UPT and to calculate the fixed point γ ∞ B in each enumeration node, while additional procedures can enhance the performance just for a few test sets.
Since for the greatest instances the improving techniques of CBB have shown to result in a significant increase in the number of instances whose solvability status could not be determined, we have implemented a warm-up phase (W). For this procedure, CBB is conducted with no improving technique for n/10 seconds, followed by CBB with the settings that are given in Table 1 (CBB+W). Table 2 shows the performance of CBB and RBB. For the performance analysis, we have used a time limit of 300 seconds. The results for RBB are taken from Watermeyer and Zimmermann (2020), where RBB has been tested on the same workstation under the same conditions as CBB. In the third column, Table 2 gives the number of instances for which the earliest start time schedule ES is not optimal (#nTriv), so-called non-trivial instances in line with Alvarez-Valdes et al. (2008). Since trivial instances can efficiently be solved to optimality, they are excluded from all investigations in the remainder of this work. The following columns list for each test set the number of instances for which an optimal solution is found and verified (#opt), infeasibility is shown (#inf), a feasible solution is found (#feas), or the solvability status remains unknown (#unk). The next columns give the average percentage deviation of the determined upper bound UB from the earliest time-feasible project termination ES n+1 (Δ lb ) and the average computing time (∅ cpu ). The percentage deviation from ES n+1 is defined by zero for each instance that were shown to be infeasible. For comparison purposes both measures are given in relation to the number of all non-trivial instances. The last two columns provide the average computing time over all instances that were solved to optimality (∅ cpu opt ) and have been shown to be infeasible (∅ cpu inf ). Table 2 reveals a great dominance of CBB for test sets UBO20π , UBO50π , and UBO100π , whereas RBB is able to solve test set UBO10π in less computing time. The results for test set UBO200π show that CBB+W also clearly dominates RBB, while CBB is not capable to determine the solvability status for all instances without the warm-up phase. It should be noted that this result gives an important implication for constructive approximation methods for RCPSP/max-π that redundancies should be maintained in the solution procedure for greater instances. Since CBB+W was only able to improve the performance for UBO200π , the corresponding results for all other test sets are omitted. A closer look at the results shows that the intractability of the instances is strongly affected by a lower resource availability and a higher number of demanded resources per activity. These results are in line with general expectations, since the described characteristics increase the interdependence between the scheduling times of the activities. It should be noted that further performance tests with a time limit of 600 s showed that the gap between CBB and RBB over all test sets remained rather unchanged and that only a few more instances were solved by both procedures, respectively.
In order to evaluate the quality of the best found solutions by CBB for which the optimality could not be verified, Table 3 provides a comparison with the best solutions of RBB. For test set UBO200π the results of CBB+W are con-sidered. The first part of Table 3 gives an overview about the number of instances for which a feasible solution has been found by at least one (# ∪ feas ) or by both procedures (# ∩ feas ), followed by the number of instances for which only CBB (# < feas ) or RBB (# > feas ) was able to find a feasible solution. For the test sets UBO20π , UBO50π , and UBO100π , CBB is able to find a feasible solution for more instances than RBB, where there is no instance for which only RBB detects a feasible solution. In the second part of Table 3, the quality of the feasible solutions is compared with each other. The first column gives the number of instances for which both procedures have found a feasible solution, but not both procedures could verify the optimality for (# ∩,nv feas ). These instances are subdivided into the number of instances with a better (# < ), an equal (# = ), or a worse (# > ) found solution by CBB compared to RBB. The last two columns are concerned with the average deviations of the best found project durations by CBB from those of RBB, which are assumed to be given by S CBB n+1 and S RBB n+1 , respectively. In the first column, the average of the absolute deviation S CBB n+1 − S RBB n+1 over all considered instances is given (Δ abs RBB ), while the second column depicts the average of the relative deviation (S CBB n+1 − S RBB n+1 )/S RBB n+1 from the best found project duration by RBB (Δ rel RBB ). The second part of Table 3 shows that CBB obtains better feasible solutions for more instances than RBB over all test sets. Furthermore, the last two columns indicate a dominance of CBB in terms of a better solution quality.
In order to illustrate the impact of the improving techniques on the performance of CBB, Table 4 shows the results for test set UBO20π with a time limit of 300 seconds if the search strategy in accordance with Table 1 is applied with different combinations of the given improving techniques. In the first two lines, the results of CBB are given if it is conducted without any improving technique, except that the lower bound LB0 π is calculated in any enumeration node, termed basic version in the following. To investigate the benefit to calculate the reduced scheduling set T i in each branching step, in Table 4 the results of two different basic versions of CBB are listed that consider the start times in Θ i or T i , respectively. In the following lines, the improving techniques from Table 1 are individually added to the basic version of CBB. The calculation of the reduced scheduling set as well as all improving techniques enhances the perfor-  mance of CBB with a significant reduction in the average deviation Δ lb and computing time ∅ cpu .

Precedence constraints
In this section we investigate the performance of CBB on RCPSP/π benchmark sets. To evaluate the performance, CBB is compared with RBB and the only available BnB for RCPSP/π (BOT), which has been developed in Böttcher et al. (1999). Since the original code for BOT could not be provided to us, we have reimplemented BOT in line with Böttcher (1995) and Böttcher et al. (1999). As preliminary tests have shown, the best results for BOT are obtained if the feasibility bounds FB1 and FB2 as described in Böttcher et al. (1999) are used. Hence, we have applied both feasibility bounds in all computational experiments on BOT. The first benchmark set contains 2160 instances with 10 real activities (P10π ) and 250 instances with 15, 20, 25, and 30 real activities (P15π , P20π , P25π , P30π ), respec-tively. All of them were generated with 30 partially renewable resources. These test sets have been used in Alvarez-Valdes et al. (2006, 2008 for a performance analysis and were provided to them by the authors of Böttcher et al. (1999). Table 5 shows the results of an experimental performance analysis on the Böttcher benchmark set with a time limit of 300 seconds. For CBB and RBB we have used the settings of test set UBO20π , except for test set P25π , for which we have conducted the computational tests on CBB with the settings of test set UBO50π . Table 5 shows that both CBB and RBB dominate BOT over all instances, while only small differences are given between CBB and RBB, except that RBB tends to show lower computing times.
The second RCPSP/π benchmark set was generated by Schirmer (1999) and was later extended by Alvarez-Valdes et al. (2006, 2008. The test sets of Schirmer (1999) cover 960 instances with 10, 20, 30, and 40 real activities (J10π , J20π , J30π , J40π ), respectively, with 30 partially renewable resources. Later, Alvarez-Valdes et al. (2006, 2008 added a  test set with 960 instances, each of them with 60 real activities (J60π ) and 30 partially renewable resources. It should be noted that 9 instances of test set J10π , which have been proven to be infeasible in Schirmer (1999, Sect. 10.4), could not be provided to us, so that they are not part of the performance analysis. In the following, we summarize all instances from Schirmer (1999) and Alvarez-Valdes et al. (2006, 2008 under the term SAV benchmark set. In Table 6, the results of the computational tests on the SAV benchmark set with a time limit of 300 seconds are given. As for the Böttcher instances, we have used the settings of UBO20π for CBB and RBB for the computational experiments, with the only exception that CBB has been conducted with the settings of UBO50π for test set J60π . Table 6 reveals that both CBB and RBB outperform BOT on the SAV benchmark set. Furthermore, Table 6 shows slightly better results for CBB compared to those of RBB.

Schedule-generation scheme
The enumeration approach of CBB, which is based on a serial schedule-generation scheme (SGS), can directly be used as a framework for a priority rule-based approximation method. For this, in each branching step only one of the direct descendant nodes has to be chosen in accordance with a priority rule.
In what follows, we investigate the performance of a regretbased biased random sampling method that makes use of a regret measure that has been introduced by Drexl (1991) and Drexl and Grünewald (1993).
Considering the extended enumeration scheme in Algorithm 3, each activity i ∈ E and each start time t ∈ T i that could be selected in a branching step is assigned a priority value π i (π t ). 2 For simplicity, let D be the set of all candidates for each selection and s some candidate (activity i or start time t). Then, in accordance with Kolisch (1996), each candidate s is assigned a regret value depending on whether lower (ext = min) or greater (ext = max) priority values are preferred and a selection probability The eligible set E and the priority values for the start times are determined in accordance with the settings for CBB. Based on preliminary tests, parameter α for the calculation of the selection probability ψ s is set to α = 2 for n = 10, α = 4 for 10 < n ≤ 30, α = 16 for 30 < n ≤ 60, and α = 32 for all greater instances (n > 60). Table 7 shows the performance of SGS on test sets UBO10π , UBO20π , and UBO50π for Z = 100 and Z = The computational studies were conducted on all non-trivial instances that could not be shown to be infeasible by CBB (#inst). Δ lb and ∅ cpu are given in relation to these instances, while Δ CBB represents the average percentage deviation of the best found solution by SGS from the shortest project duration that has been determined by CBB in relation to the number of instances for which SGS was able to find a feasible solution. For this, it should be noted that all instances, for which SGS was able to determine a feasible solution, were feasibly solved by CBB as well. Finally, the last measure is given by the number of instances for which SGS was not able to find a feasible solution (#nfeas). Table 7 shows the best results for SGS that were obtained among all priority rules for the activity selection that are described in Sect. 5. The corresponding priority rules that have been applied on test sets UBO10π , UBO20π , and UBO50π are, respectively, given by LST, LSTd, and STd I with ext = min. It can be seen from Table 7 that the calculation of the reduced scheduling set T i always results in a better performance for SGS and that the RB consistency test is able to improve the solution procedure, but with a significant greater impact on test sets UBO10π and UBO20π . This observation might be explained by the reduction of the start times that are not part of any feasible solution by the RB consistency test whose effectiveness seems to increase if less possible start times are considered. In contrast, the additional application of the pruning technique UPT could only obtain better results for small instances, while the number of instances for which no feasible solution was determined is getting greater for test set UBO50π . The negative impact of UPT might be assumed to be caused by the reduction of redundancies that tend to increase the probability for unfavorable scheduling decisions if the number of activities is getting greater. The comparison with CBB reveals that SGS performs only reasonable on small instances (UBO10π , UBO20π ) if the improving techniques are applied, while the best solutions for test set UBO50π (+RB) deviate more than 16% on average from the solutions of CBB even if Z = 1000 iterations are conducted.
Due to the significant increase in the computing time, Table 8 provides the results of SGS on test sets UBO100π and UBO200π for Z = 10 and Z = 100 iterations. The priority rules ST and STd with ext = min were applied on the test sets UBO100π and UBO200π , respectively. In accordance with the results for test set UBO50π , the application of UPT leads to an increase in the number of instances for which SGS is not able to determine a feasible solution. Furthermore, the RB consistency test can at most slightly improve the performance, while the advantage of the reduced scheduling set T i even tends to increase for greater instances. The best solutions of SGS clearly deviate from the shortest project durations determined by CBB on average, so that SGS seems to be not well suited to solve large instances.
The results of SGS on the Böttcher and SAV benchmark set show similar trends as for the test sets UBO10π and UBO20π . For details, we refer the reader to the supplementary material of this paper.
In conclusion, SGS shows a reasonable performance on small instances if the RB consistency test and the pruning technique UPT are applied, while the procedures lack to improve the performance for greater instances, which might be assumed to be caused by the increase in the number of possible start times in each scheduling step. In our opinion, a promising way to improve the performance of SGS on greater instances might be to implement procedures that store information about the decisions that were made in previous iterations. One way for this might be given by adapting the construction procedure of the search tree that has been presented for CBB.

Conclusions
We have presented a branch-and-bound algorithm (BnB) for the resource-constrained project duration problem with partially renewable resources and general temporal constraints (RCPSP/max-π ) that is based on a serial schedule-generation scheme. For the first time it has been shown that it is sufficient to consider only a subset of all resource-feasible start times in each branching step. By an extension of the enumeration scheme by start time domains, improving techniques from the literature could be included. Furthermore, we were able to devise new pruning techniques to prevent redundancies with a significant impact on the performance.
In a comprehensive experimental performance analysis we have compared our exact solution procedure with all BnB that are available in the open literature for partially renewable resources. The computational experiments could reveal a great dominance of our BnB for RCPSP/max-π . The favorable performance could also be confirmed for instances that are restricted to precedence constraints with significant better results compared to the only available BnB for RCPSP/π . In a second step, we investigated a directly derived schedulegeneration scheme from our new enumeration approach. It has been shown that the approximation procedure obtains reasonable results for small instances, while a limitation for large instances became apparent.
As the computational experiments have shown, the performance of a BnB for RCPSP/max-π is strongly influenced by the way to enumerate the candidate solutions. Therefore, the investigation of further enumeration schemes seems to be a promising field for future research. Moreover, the experiments could demonstrate that there is a great need for new types of approximation methods that goes beyond classical priority rule-based generation schemes.
Funding Open Access funding enabled and organized by Projekt DEAL.
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecomm ons.org/licenses/by/4.0/.