A ⁄ -based construction of decision diagrams for a prize-collecting scheduling problem

Decision diagrams (DDs) have proven to be useful tools in combinatorial optimization. Relaxed DDs represent discrete relaxations of problems, can encode essential structural information in a compact form, and may yield strong dual bounds. We propose a novel construction scheme for relaxed multi-valued DDs for a scheduling problem in which a subset of elements has to be selected from a ground set and the selected elements need to be sequenced. The proposed construction scheme builds upon A (cid:1) search guided by a fast-to-calculate problem-speciﬁc dual bound heuristic. In contrast to traditional DD compilation methods, the new approach does not rely on a correspondence of DD layers to decision variables. For the considered kind of problem, this implies that multiple nodes representing the same state at different layers can be avoided, and consequently also many redundant isomorphic substructures. For keeping the relaxed DD compact, a new mechanism for merging nodes in a layer-independent way is suggested. For our prize-collecting job sequencing problem, experimental results show that the DDs from our A (cid:1) -based approach provide substantially better bounds while frequently being an order-of-magnitude smaller than DDs obtained from traditional compilation methods, given about the same time. To obtain a heuristic solution and a corresponding lower bound, we further propose to construct a restricted DD based on the relaxed one, thereby substantially exploiting already gained information. This approach outperforms a standalone restricted DD construction, basic constraint programming and mixed integer linear programming approaches, and a variable neighborhood search in terms of solution quality on most of our benchmark instances. (cid:1)


Introduction
In the last decade decision diagrams (DDs) have shown to be a powerful tool in combinatorial optimization (Andersen et al., 2007;Bergman et al., 2014;Cire and van Hoeve, 2013).For a variety of problems that classical mixed integer programming (MIP) and constraint programming (CP) techniques cannot address effectively (due, e.g., weak dual bounds), new state-of-the-art methodologies could be obtained with DDs at the core.These problems comprise prominent ones such as the minimum independent set, set covering, and maximum cut problems (Bergman et al., 2016b, a) as well as diverse sequencing and scheduling problems (Cire and van Hoeve, 2013), including variants of the traveling salesman problem (TSP).Note that, common for the first group of mentioned problems is that an optimal subset of elements needs to be selected from some ground set, while for the sequencing problems, an optimal order (permutation) of all elements shall be determined.
Decision diagrams are in essence data structures that provide graphical representations of the solution space of an optimization problem.More specifically, a relaxed DD represents a superset of all feasible solutions in a compact way and can therefore be seen as a discrete relaxation of the problem.A relaxed DD can be used to obtain a dual bound, but it also provides a fruitful basis for alternative branching schemes (Bergman et al., 2016a) and constraint propagation (Andersen et al., 2007), for example.
For the kind of problems where a subset of elements is to be selected, so-called binary decision diagrams (BDDs) are typically used.Here, solutions are usually represented by binary vectors and each layer of the BDD is associated with a boolean decision variable indicating whether an element is selected or not.In contrast, for problems in which an optimal sequence of elements shall be found, it is more natural to apply so-called multi-valued DDs (MDDs).Then, a solution is represented by a permutation of the given elements, and consequently a layer in the MDD is associated with the decision which element appears at the respective position in the permutation.
We contribute in considering DDs for a problem that combines the selection aspect with the sequencing aspect, i.e., a problem in which a subset of initially unknown size needs to be selected from some ground set of elements and the selected elements need to be ordered to form a complete solution.Problem-specific constraints restrict the solution space so that not all subsets have a feasible order.More specifically, the problem we consider is the prizecollecting job sequencing problem with one common and multiple secondary resources (PC-JSOCMSR) from Horn et al. (2018).In this problem, each job is associated with a prize and the objective is to select a subset of jobs and find a feasible schedule such that the total prize is maximized.Note that besides the PC-JSOCMSR, the type of problems that combines the element selection aspect with the sequencing aspect is not uncommon.For example, the prominent class of orienteering problems (Gunawan et al., 2016), also called selective TSP, falls into this category as well as order acceptance and single machine scheduling (Oguz et al., 2010;Silva et al., 2018), prize-collecting single machine scheduling (Cordone et al., 2018), and other scheduling problems in which the number of tardy jobs shall be minimized (which corresponds to selecting and scheduling a subset of the jobs), see., e.g., Moore (1968) and Lee and Kim (2012).More generally, similar problems also appear as pricing problems in column generation approaches, for example for vehicle routing and parallel machine scheduling problems.Last but not least, assortment problems also exhibit the selection aspect-although sometimes with decisions beyond binary ones-and occasionally the sequencing aspect, for example when optimizing over time (Davis et al., 2015).
For the type of problem with both selection and sequencing decisions we consider, it is natural to build upon MDDs similar to those from Cire and van Hoeve (2013), as solutions can be represented by permutations of the chosen elements.In contrast, it does not seem possible to effectively cover the sequencing aspect in some BDD variant.A particularity of our case is that feasible solutions may have arbitrary size in terms of the number of selected elements.This leads us to a novel technique for constructing relaxed MDDs.The method is inspired by A Ã search, a commonly used algorithm in path planning and problem solving (Hart et al., 1968).A priority queue is maintained for open nodes that still need further processing.A fast-to-calculate exogenous dual bound function is used as heuristic function to iteratively select the next node to be processed.To keep the constructed relaxed MDD compact, nodes are merged in a carefully selected way when the open list reaches a certain size.We show for the PC-JSOCMSR that the relaxed MDDs obtained by the A Ã -based method yield substantially stronger bounds than relaxed MDDs of comparable size constructed by two standard techniques.The main reasons for this advantage are (a) the guidance by the dual bound heuristic, (b) that our construction is able to effectively avoid multiple nodes for identical states at different layers of the MDD, and (c) that similar nodes can also be merged across different layers.Substantial redundancies that cannot be avoided in the standard construction techniques are therefore less problematic in our approach.
In order to not just obtain dual bounds, we further describe the construction of a restricted DD that yields promising heuristic solutions for the PC-JSOCMSR.Restricted DDs in general represent subsets of all feasible solutions.Hereby we contribute with a novel way of utilizing a previously constructed relaxed DD in order to substantially speed up the construction of a restricted DD.
Rigorous experiments including comparisons with MIP and CP approaches as well as with a variable neighborhood search heuristic on large benchmark instances with up to 500 jobs show the advantages of the proposed relaxed and restricted MDD construction techniques, respectively.
The article is structured as follows.Section 2 reviews DDs with a focus on MDDs for sequencing problems, introduces notations, and discusses related work.The PC-JSOCMSR is formally introduced in Section 3. Section 4 presents the A Ã -based construction of relaxed DDs in a rather problem-independent way, while Section 5 adds the problem-specific aspects, such as the definition of states, the transitions between them, and the way how nodes are merged.In Section 6, we explain how to boost the construction of a restricted DD by exploiting an existing relaxed DD.Experimental results are presented in Section 7. Finally, Section 8 concludes this work and outlines further research directions.

Decision diagrams for combinatorial optimization
Decision diagrams were originally introduced in the field of electrical circuits and formal verification, see e.g. Lee (1959).For a comprehensive reading on DDs in optimization, their variants, applications, and successes, we refer to the book by Bergman et al. (2016a).
In the context of this work, a DD is a directed weighted acyclic multi-graph M ¼ V; A ð Þwith node set V and arc set A. In the literature, the node set V is usually partitioned into layers , where n corresponds to the number of decision variables representing a solution.The first and the last layer are singletons and contain the root node r 2 V and the destination node t 2 V, respectively.Each arc a ¼ u; v ð Þ2A is associated with a value val a ð Þ and directed from a source node u in some layer V i to a destination node v in the subsequent layer V iþ1 ; i 2 1; . . .; n f g .Such an arc refers to the assignment of value val a ð Þ to the i-th decision variable.While the domain of values in BDDs is restricted to 0; 1 f g, MDDs have arbitrary finite domains corresponding to those of the respective decision variables.
Each path from the root node r to the target node t corresponds to a solution encoded in the DD.An exact DD has a one-to-one correspondence between feasible solutions and the existing r-t paths.Let us consider a sequencing problem where a subset of the permutations p ¼ p 1 ; . . .; p n ð Þof the ground set 1; . . .; n f gforms the set of feasible solutions.Fig. 1a shows an example for an exact MDD with n ¼ 3 encoding the permutations (1,3,2), (2,1,3), (2,3,1), (3,2,1), and (3,1,2).
Each arc a 2 A has a length z a ð Þ (or prize, cost, etc.) which gives the corresponding variable assignment's contribution to the objective value if it is chosen.The total length of an r-t path thus corresponds to the solution's objective value.We assume throughout this work that the considered optimization problem is a maximization problem.Consequently, we are looking for a longest r-t path.
As long as the DD is not too large, a longest path can be found efficiently as the DD is acyclic.Unfortunately, exact DDs for NPhard optimization problems will in general have exponential size.This is where relaxed DDs come into play: They are more compact and they approximate an exact DD by encoding a superset of all feasible solutions.The longest path of a relaxed DD therefore provides an upper bound to the original problem's optimum solution value.A restricted DD, in contrast, encodes only a subset of the feasible solutions, and its longest path therefore yields a lower bound and a possibly promising heuristic solution.Fig. 1b and c show a relaxed and a restricted DD for the exact DD in Fig. 1a.
Each node u 2 V carries problem-specific information through its state r u ð Þ that is reached by all the partial solutions corresponding to the paths from the root node to node u.In our case, when the MDDs represent subsets of permutations, each state includes the subset of elements by which the partial solutions may still be extended, thereby defining which outgoing arcs exist; we denote this set as P u ð Þ. Decision diagrams are usually derived from a dynamic programming (DP) formulation of the considered problem, and therefore a strong relationship exists between the DP's state transition graph and the nodes of the DD (Hooker, 2013).We will see this relationship in more detail when considering the PC-JSOCMSR specifically in Section 5.
There are two fundamental methods for compiling relaxed DDs of limited size.These are, to the best of our knowledge, used in almost all so far published works where relaxed DDs are applied to address combinatorial optimization problems.The top-down construction (TDC) starts with just the root node and creates the DD iteratively layer by layer, essentially performing a breadthfirst search.The size of the DD is controlled by imposing an upper bound b, called width, on the number of nodes at each layer.If the size of a current layer exceeds b, then some nodes of this layer are selected and merged so that the layer's size is reduced to at most b.This merging is done in such a way that no paths corresponding to feasible solutions are lost; new paths corresponding to infeasible solutions may emerge, however.
The second frequently applied approach for constructing relaxed DDs is incremental refinement (IR).It starts with a trivial relaxed DD, e.g., a DD of width one, which has just one node in each layer.Then two major steps are repeatedly applied until some termination condition is fulfilled, e.g., a maximum number of nodes is reached.In the filtering step, the relaxation represented by the DD is strengthened by removing arcs that cannot be part of any path corresponding to a feasible solution.In the refinement step, nodes are split into pairs of new replacement nodes in order to remove some of the paths that correspond to infeasible solutions.
Besides TDC and IR, Bergman and Cire (2017) proposed to consider the compilation of a relaxed DD as an optimization problem and investigated a MIP formulation.While this approach is useful for benchmarking different compilation methods on small problem instances, it is computationally too expensive for any practical application.In another work, Römer et al. (2018) suggested a local search framework that serves as a more general scheme to obtain relaxed DDs.It is based on a set of local operations for manipulating and iteratively improving a DD, including the node splitting and merging from IR and TDC, respectively, and arc redirection as a new operator.Again, both approaches are strongly layer-oriented.
Especially in the context of binary DDs, a commonly used extension that frequently yields more compact DDs are so-called long arcs (Bryant, 1986;Minato, 1993).They skip one or more layers and represent multiple variable assignments with one arc.In zero-suppressed DDs, variables corresponding to skipped layers take the value zero, while in one-suppressed DDs they get value one.Alternatively, a long arc may indicate that the skipped variables can take either value.For example, Bergman et al. (2014) suggested to use zero-suppressed DDs for the independent set problem, while Kowalczyk and Leus (2018) applied them to solve the pricing problem in a branch-and-price algorithm for parallel machine scheduling.
In conjunction with scheduling and sequencing problems, MDDs were already successfully applied e.g. to single machine scheduling problems (Cire and van Hoeve, 2013), the timedependent traveling salesman problem with and without time windows, the time-dependent sequential ordering problem (Kinable et al., 2017), and job sequencing with time windows and state-dependent processing times (Hooker, 2017).
All these approaches utilize MDDs for permutations similar to our example in Fig. 1.An alternative way of representing sets of permutations as DDs has been described by Minato (2011).It builds upon zero-suppressed decision diagrams and encodes permutations by binary decision variables that indicate the transposition of pairs of elements.While this approach offers interesting advantages concerning certain algebraic operations, it appears nontrivial to efficiently express typical objective functions from routing and scheduling in terms of arc lengths on such DDs.

MDDs for problems with both selection and sequencing decisions
To address problems like the PC-JSOCMSR, the above described MDDs for permutations can be extended in natural ways.
A commonly used approach for modeling problems with multiple different goal states is to use a single target node t and connect each other node that corresponds to a feasible end state to this target node with a special termination arc of length zero.Such a termination arc a has a special value val a ð Þ ¼ T and does not correspond to any classical variable assignment.See Fig. 2a for an example of such an approach in our case.
A simpler method can be used for optimization problems where appending an element to a solution, if feasible, always leads to a solution that is not worse.This is, in particular, the case when all arc lengths are non-negative.Here, we can avoid additional artificial arcs and simply redirect all arcs that lead to a non-extendable state directly to the target node t; see Fig. 2b.These redirected arcs may now skip layers.In contrast to the previously discussed long Fig. 1.Examples of an exact, a relaxed, and a restricted MDD for a sequencing problem with ground set 1; 2; 3 f g .Each arc label shows both the element to be assigned to the corresponding variable and the arc length as val a ð Þjz a ð Þ.The longest path is highlighted.For the exact MDD, the longest path encodes the optimal permutation p Ã ¼ 2; 3; 1 ð Þ with a total prize of 30.arcs, however, our arcs here still represent single variable assignments.In the remainder of this work, we consider just this simpler redirection approach without explicit termination arcs.However, the algorithmic concepts we present can also be adapted in a straightforward way to the more general DD structure with termination arcs.
A further advantage of our MDDs for problems with both selection and sequencing decisions is illustrated in Fig. 2b-c.In Fig. 2b, consider the substructures rooted at nodes v and v 0 and note thereby that due to the variable solution length, isomorphic substructures appear.In Fig. 2c, the MDD is condensed by storing this substructure just once, with all arcs leading to the two substructures in Fig. 2b redirected to the single substructure.In this way, many redundancies might be avoided and substantially more compact MDDs representing the same set of solutions may be obtained.Note, however, that classical DD construction techniques such as TDC and IR are not able to create such an MDD as they rely on the notion that an arc originating at layer i; i ¼ 1; . . .; n, (or a long arc passing a layer i) assigns a value to the i-th decision variable.The A Ã -based construction method we will propose in Section 4 does not rely on the layer-to-variable relationship but more generally just assumes that on any r-t path, the i-th arc represents an assignment to the i-th variable.

Prize-collecting job sequencing with one common and multiple secondary resources
We consider here specifically the prize-collecting job sequencing with one common and multiple secondary resources (PC-JSOCMSR), which was introduced by Horn et al. (2018).
Given is a set of jobs where each job is associated with a prize.Among these jobs, a subset of maximum total prize shall be selected and feasibly scheduled.Each job has individual time windows and can only be performed during one of these.The processing of each job requires two resources: a common resource, which all the jobs need for a part of their processing, and a secondary resource which is shared by only a subset of the other jobs but needed for the whole processing time.Each resource can only be used for processing one job at a time.As example, consider an application similarly as the one described by Van der Veen et al. (1998): The common resource might be an oven and the secondary resources molds of different types; jobs correspond to different products to be processed in the oven and each product requires a particular mold.There is some preprocessing, where the mold is already required before the prepared product can be put with its mold into the oven; after the heat treatment, the product is taken from the oven but still needs to be cooled within the mold for some time.Only thereafter, the mold can be used for a successive product.
Fig. 3 illustrates a solution in which jobs 8, 1, 7, 10, and 4 have been selected and scheduled.The processing of a job is illustrated as a bar with the white part referring to the usage of the common resource.The top row shows when a job uses the common resource (e.g., the oven) and rows one to three show the schedule for each of the three secondary resources (e.g., the three molds).

Formal definition
More formally, we denote the set of (renewable) resources by where resource 0 refers to the common resource and R ¼ 1; . . .; m f gto m secondary resources.The set of jobs to be considered is J ¼ 1; . . .; n f g , where n denotes the number of jobs.Each job j 2 J has an assigned secondary resource q j 2 R needed for its whole processing time p j > 0, while the common resource is required for the time p 0 j , starting after a pre-processing time p pre j P 0 from the job's start time.The remaining time for which the secondary resource is still needed, but the common resource is not, is the post-processing time p post j ¼ p j À p pre j À p 0 j P 0. A selected job must always be performed without preemption.Fig. 4 illustrates a job with its required resources and respective times.
If a job j 2 J is scheduled it must be performed without preemption within one of its x j disjunctive time windows , where w end jk À w start jk P p j ; j 2 J.For job j, let the release time be T rel j ¼ min k¼0;...;x j w start jk and the deadline be T dead j ¼ max k¼0;...;x j w end jk .The overall time interval to consider is then T min ; T max h i with Note that the existence of unavailability periods of resources is also covered by the above formulation since these can be translated into time windows of the jobs.
Last but not least, each job j 2 J is associated with a prize z j > 0 and the objective is to select a subset of jobs S # J and find a feasible schedule for them so that the total prize of these jobs is maximized: Fig. 2. MDD variants for a problem with both selection and sequencing decisions encoding the same set of solutions: (a) using artificial termination arcs with val a ð Þ ¼ T; (b) redirecting all arcs leading to non-extendable states directly to the target node (if appending an element may never yield a worse feasible solution); (c) additionally avoiding multiple instances of isomorphic substructures (shaded parts).
A feasible schedule assigns each job in S a feasible starting time.Since each job requires the common resource and since this resource can be used only by one job at a time, any feasible schedule is characterized by the sequence p ¼ p i ð Þ i¼1;...;jSj in which the selected jobs use the common resource; for example p ¼ 8; 1; 7; 10; 4 ð Þfor the solution in Fig. 4. For such a sequence, valid job starting times can always be computed in a straightforward greedy way.This is done by assigning the jobs in the given order the earliest possible starting times with respect to their time windows and the resource availabilities considering all earlier scheduled jobs.Such a schedule is referred to as a normalized schedule.It is easy to see that any feasible schedule always has a corresponding normalized schedule that is also feasible.Consequently, it is sufficient to search the space of all normalized schedules and thus all respective job sequences to solve PC-JSOCMSR.

Earlier work on the PC-JSOCMSR
Originally, Van der Veen et al. (1998) has considered a variant of the problem in which all jobs have to be scheduled and the objective is to minimize the makespan.A crucial condition in this work was that the post-processing times were assumed to be negligible compared to the total processing times of the jobs.This simplifies the problem substantially since it implies that the start time of each job only depends on its immediate predecessor.The problem could therefore be modeled as a Traveling Salesman Problem (TSP) with a special cost structure that allows to solve the problem efficiently in time O n log n ð Þ .The variant of the problem with general post-processing times, but still with the aim to schedule all jobs and minimize the makespan, has been treated in Horn et al. (2019) by an A Ã /beam search anytime algorithm.The authors showed the problem to be NP-hard and could solve instances with up to 1000 jobs to proven optimal-ity.The good computational performance is mainly thanks to a detailed study of the problem structure which yielded a tight dual bound calculation.
The prize-collecting problem variant we consider here, the PC-JSOCMSR, was first described in Horn et al. (2018), where an exact A Ã algorithm is proposed; see also Horn et al. (2020) for an extended version of the original conference paper.To determine tight bounds for this problem variant turned out to be more difficult due to the prize-collecting aspect and the time windows.Different variants of upper bound calculations based on Lagrangian and linear programming relaxation were investigated.Comparisons to a compact MIP model and a MiniZinc CP model solved by different backends indicated the superiority of the A Ã search.Nevertheless, only instances with up to 30 jobs could be consistently solved to optimality.For instances with 80 jobs, an optimal solution was only found and verified for a few of them.
To obtain dual bounds and heuristic solutions for larger PC-JSOCMSR instances, Maschler and Raidl (2018) investigated classical TDC and IR approaches to construct relaxed MDDs and a topdown construction for restricted MDDs.In addition, an independent general variable neighborhood search (GVNS) metaheuristic was considered.Instances with up to 300 jobs were studied.It turned out that IR frequently yields relaxed DDs of roughly comparable size with stronger upper bounds than TDC.Differences are particularly significant for instances with a larger number of jobs.IR's running times are, however, in general higher than those of TDC for constructing MDDs of comparable size.The heuristic solutions obtained from the restricted DDs were usually better than or on par with the solutions obtained from the GVNS, except for the largest skewed instances, where the GVNS performed better.In our experimental investigations in Section 7 we will also compare to these approaches.

Applications
As already briefly sketched, the PC-JSOCMSR may arise in the context of the production or processing of certain products on a single machine (the common resource), for example to perform a heat treatment.Some raw material is put into specific molds or fixtures (the secondary resources), which are then sequentially processed on the single machine.In order to use the fixtures/molds again, some post-processing may be required (e.g., cooling).The raw material may only be available on certain times within a limited time horizon and the task is to select the in some sense most valuable subset of products to produce or process on the single machine within the limited time horizon.
Our interest in the PC-JSOCMSR has been primarily motivated from work on two real-world applications in which the PC-JSOCMSR appears as a simplified subproblem at the core.
The first application concerns the scheduling of particle therapies for cancer treatments (Maschler and Raidl, 2018).Here, the common resource corresponds to a synchrotron (i.e., a particle accelerator) in which proton or carbon particles get accelerated to almost light speed and are directed to one of a few treatment rooms in which one patient gets radiated at a time.The typically two to four differently equipped treatment rooms are the secondary resources.Preparations like positioning and a possible anesthesia yield a pre-processing time, while specific medical inspections that are performed after the radiation yield a postprocessing time.In the long-term planning, the planning horizon consists of several weeks and due to the overall problem's complexity, a decomposition approach is used in which the PC-JSOCMSR appears as subproblem for each day: To utilize the available working time at a considered day as best as possible, a most valuable subset of all remaining treatments to be performed is  selected and scheduled.Not scheduled treatments have to be dealt with at other days.The availability of further required resources, such as medical stuff, is taken into account by setting the jobs' time windows accordingly.Note that the sketched approach is closely related to solving a pricing problem in the context of column generation.
The second application is pre-runtime scheduling of avionic systems (electronic systems in aircraft) as introduced in Blikstad et al. (2018) and Karlsson et al. (2020).The industrially relevant instances considered in these articles are too complex and largescale to be addressed directly and instead they need to be solved by some decomposition.The PC-JSOCMSR appears as an important sub-structure both in the exact decomposition approach in Blikstad et al. (2018) and in the matheuristic approach in Karlsson et al. (2020).Briefly described, the considered system consists of a set of nodes and each of these contains a set of modules (processors) with jobs to be scheduled.In each node, there is a single module called the communication module, which corresponds to the common resource in PC-JSOCMSR.Each node also has a set of application modules, which correspond to the secondary resources.By solving a PC-JSOCMSR, partial and simplified schedules for the nodes can be constructed.In Blikstad et al. (2018) and Karlsson et al. (2020), this is of relevance in a subproblem where a restriction of the original problem is to be solved and the objective is to schedule as many jobs as possible.Also, to create partial schedules for the nodes would be of interest in rollinghorizon methods for this type of problem.
For more details on both applications we refer to Horn et al. (2020).Benchmark instances reflecting the structure of these two applications have been used in the mentioned earlier works on the PC-JSOCMSR, and we will adopt the larger instances from those and extend the benchmark set in our experimental evaluation.

Further related work
The PC-JSOCMSR might also be modeled as a more general Resource-Constrained Project Scheduling (RCPS) problem with maximal time lags by splitting each job according to the resource usage into three sub-jobs; for a survey on RCPS see Hartmann and Briskorn (2010).These three sub-jobs must be executed sequentially without any time lags.However, since each job of the PC-JSOCMSR problem requires three jobs in a RCPS problem and the RCPS also is known to be difficult to solve in practice, this approach does not seem likely to yield better results than a well chosen problem-specific approach.

A Ã -based construction of a relaxed MDD
We propose to construct relaxed MDDs for the PC-JSOCMSR problem and possibly other problems with both selection and sequencing decisions in a novel way that essentially adapts the classical TDC towards the spirit of A Ã search.Instead of following a breadth-first search we turn towards a best-first search where layers do not play a role anymore.The key characteristics of this scheme are: 1.It naturally avoids multiple nodes for identical states at different layers and consequently multiple copies of isomorphic substructures (cf.Section 2.1 and Fig. 2).2. Node expansions and the selection of nodes to be merged are guided by an auxiliary upper bound function.3. Partner nodes for merging are selected by considering state similarity and merging of nodes across different layers is enabled in a natural way.
These features allow to obtain more compact relaxed MDDs that provide tighter upper bounds than the so far used classical construction techniques.(Hart et al., 1968) is a commonly applied technique in path planning and problem solving.It is well known for its ability to efficiently find best paths in very large (state) graphs.The following brief overview on A Ã search builds upon the notation already introduced in our DD setting.A Ã search follows a bestfirst-search strategy and uses as key ingredient a heuristic function Z ub u ð Þ that estimates, for each node u reached, the cost to get to the target node t in a best way, the so-called cost-to-go. 1 All not yet expanded nodes, called open nodes, are maintained in a priority queue, the open list Q.This list is partially sorted according to a priority function

A
where Z lp u ð Þ denotes the length of the so far best path from the root node r to node u.Initially, Q contains just the root node.The A Ã search then always takes a node with highest priority from Q and expands it by considering all outgoing arcs.Destination nodes that are reached in better ways via the expanded node are updated and newly reached nodes are added to Q. Considering maximization, a heuristic function Z ub that never underestimates the real cost-to-go (i.e., is an upper bound function) is called admissible.A Ã search terminates when t is selected from Q for expansion.If an admissible heuristic is used, then Z lp t ð Þ is optimal.From now on let us assume that Z ub is indeed admissible.The efficiency of A Ã search mostly relies on how well the heuristic function estimates the real cost-to-go.

Constructing exact MDDs by A Ã search
When performing the A Ã search, all encountered nodes and arcs that correspond to feasible transitions are stored.If the construction process is carried out until the open list becomes empty and thereby all nodes have been expanded, then a complete MDD is obtained.Alternatively, the A Ã search's criterion can be applied, and then the search is terminated already when the target node is selected for expansion.In this case, typically substantially less nodes will have been expanded, and the obtained MDD is in general incomplete.Nevertheless, we know due to the optimality condition of A Ã search that at least one optimal path is contained and thus an optimal solution is indeed represented.

Constructing relaxed MDDs
To obtain a compact relaxed MDD we now extend the above A Ãbased construction by limiting the open list.This is achieved by merging similar and less promising nodes when the open list exceeds a certain size /.Details on how we choose the nodes to be merged will be presented in Section 4.4.Selected nodes are merged in the same problem-specific ways as in traditional relaxed DD construction techniques.In particular, it has to be guaranteed that no paths corresponding to feasible solutions get lost.Section 5.2 will show how this is done in for the PC-JSOCMSR.
When performing this MDD construction until the open list becomes empty, we now obtain a complete relaxed MDD that indeed represents a superset of all feasible solutions and yields an upper bound on the optimal solution value.
Alternatively, we may also here already terminate early once the target node is selected for expansion.Due to the merging and the optimality condition of A Ã search, we have then obtained a path whose length is a valid upper bound to the optimal solution value, and this bound cannot be further improved by continuing the MDD construction.Only longer paths corresponding to weaker bounds may later arise due to further node merges.Let us denote this best obtained bound by Z ub min .Thus, the termination criterion to be used depends on the goal for which the MDD is constructed.If we are only interested in the upper bound or, for example, a DD-based branch-and-bound (Bergman et al., 2016a) shall be performed, the early termination may be very meaningful and can save much time.However, should we indeed need a representation of a complete superset of all feasible solutions, the construction has to be continued.
Algorithm 1 shows the proposed MDD construction technique in pseudo-code.After the initialization phase, the main loop is entered.At each major iteration, a node u with maximum priority f u ð Þ is taken from the open list Q.As long as the target node t was not chosen for expansion, the node's f value provides a valid upper bound and Z ub min is updated accordingly in Line 7. If t was chosen, the optional early termination takes places.
Next, the case when node u has not yet been expanded is handled by considering all feasible transitions from state r u ð Þ and creating new nodes and arcs accordingly.If thereby a new path to a u was already expanded, a re-expansion has to take place because a longer path to u, yielding a larger Z lp u ð Þ, has been found in an iteration after the node's original expansion.This is done by propagating the updated Z lp u ð Þ to all its successor nodes and evaluating if they also need re-expansions.Note that, in general, we cannot avoid such re-expansions even when the upper bound function is consistent since node merges may lead to new longer paths.After each node expansion, the algorithm checks if the size of the open list jQ j exceeds the limit /.If this is the case, then the algorithm tries to reduce Q by merging nodes as explained in the next section.Algorithm 1 terminates regularly when the open list becomes empty and returns the relaxed MDD together with the best obtained upper bound Z ub min .

Reducing the open list by merging
Merging different nodes usually introduces new paths corresponding to infeasible solutions, and this typically weakens the upper bound obtained.Therefore we aim at quickly identifying nodes for merging that (a) are less likely to be part of some finally longest path; (b) are associated with similar states, since this should imply that the merged state still is a strong representative for both; (c) do not introduce cycles in the MDD as they would lead to infinite solutions; and (d) ensure that the open list gets empty after a finite number of expansions.The last two aspects are crucial conditions to ensure a proper termination of the approach, and they are not trivially fulfilled due to the possibility to merge across different layers.
Aspect (a) is considered by iterating over the nodes in the open list in an increasing Z lp -order and trying to merge each node with a suitably selected partner node in a pairwise fashion until the size of the open list does not exceed / anymore.The motivation for the increasing Z lp -order is that A Ã search has so far postponed the expansion of these nodes while other nodes with comparable Z lp values have already been expanded.Therefore, the nodes with small Z lp values can be argued to be less likely to appear in a longest path. 2he selection of the partner node for merging is done considering aspects (b) to (d) by utilizing a global set of so-called collector nodes V c .To this end, we define a problem-specific labeling function L u ð Þ that maps the data associated with a node u-in particular its state r u ð Þ-to a simpler label of a restricted finite domain D L , thereby partitioning the nodes into subsets of similar nodes.Our labeling function, for example, may drop, aggregate, or relax parts of the states considered less important and condense the information in this way.Similar principles as in state-space relaxation (Christofides et al., 1981) can be applied.The labeling function, however, may additionally also consider the upper bound Z ub u ð Þ as criterion for similarity; experimental results in Section 7 will show the particular usefulness of this.The global set of collector nodes V c is initially empty and realized as a dictionary (e.g., hash table) indexed by the labels so that for each label in D L , there is at most one collector node in V c , and thus jV c j 6 jD L j.In this way, we can efficiently determine for any node u if a related collector node with the same label L u ð Þ already exists and, in this case, directly access it.
Algorithm 2 shows the whole procedure to reduce the open list.As long as the open list is too large, nodes are selected in increasing Z lp -order.For a chosen node u, it is checked if it is not yet expanded and if a corresponding collector node v, that is also not yet expanded, exists (Line 4).In this case, u and v are merged, yielding the new node v 0 with state r v 0 , where È denotes the problem-specific state merging operation.All incoming arcs from u and v will be redirected to the new node v 0 .Consequently, u is removed from Q and v from Q as well as V c .Next, we have to integrate the new node v 0 into the node set V by avoiding multiple nodes in the set V associated with the same state (Line 7).Further-Algorithm 2: Reduce Q by merging nodes more v 0 becomes a collector node in V c , essentially replacing the former collector node v. Node v 0 may, however, have a different label than the former v, and some other collector node with the same label as v 0 may already exists in V c .In this case, we iterate the merging with these nodes by continuing the while-loop in Line 4.
Note that Algorithm 2 shows the main idea pointing out the important steps.In a concrete implementation, a few additional corner cases need to be considered, in particular when collector nodes get changed (e.g., expanded) between two calls of Algorithm 2.

A Ã -based MDD construction for PC-JSOCMSR
We now consider the problem-specific details to apply the A Ãbased construction of a relaxed MDD specifically to PC-JSOCMSR.The root node r represents the empty schedule.An arc a corresponds to job val a ð Þ being appended to a partial solution represented by a permutation p and this job being scheduled at its earliest feasible time.The length associated with arc a is the prize of its corresponding job, i.e., z a ð Þ ¼ z val a ð Þ .In this way, the length of a path from r to some node u corresponds to the total prize of all so far scheduled jobs.The target node t subsumes all states that cannot be further extended, and thus we want to find a maximum length r-t path.
In the following we define the states and state transitions as well as the underlying DP formulation for PC-JSOCMSR, as introduced in Horn et al. (2018).

States and state transitions
A state in PC-JSOCMSR must describe all relevant aspects in order to determine the earliest starting time of any successive job that can be scheduled.For a node u this is the tuple Þconsisting of the set P u ð Þ # J of jobs that can still be feasibly scheduled, and the vector Þ r2R 0 of the earliest times from which each resource r is available for performing a next job.
To simplify the consideration of the time windows, we introduce the function eft j; t ð Þ ¼ min t 0 P t j 9k : that yields the earliest feasible time, not smaller than the provided time t 6 T max , at which job j can be scheduled according to the time windows W j of the given job j 2 J.The value eft j; t ð Þ ¼ T max indicates that job j cannot be feasibly included in the schedule at time t or later.
The state of the root node is r r T min ; . . .; T min and represents the original instance of the problem, with no jobs scheduled or excluded yet, and the target node's state is r t Þthat is achieved by scheduling job j ¼ val a ð Þ, j 2 P u ð Þ, at its earliest possible time w.r.t.vector t u ð Þ.When performing this transition, the start time of job j w.r.
The transition function to obtain the successor state and where 0 represents the infeasible state.If a transition results in the infeasible state, the corresponding arc and node are omitted in the MDD.Using these definitions of states and transitions, we can express the optimal solution value of the PC-JSOCMSR subproblem represented by a node u by the recursive DP formulation and the overall PC-JSOCMSR solution value is Z Ã r ð Þ.In our implementation, each determined state further undergoes a strengthening procedure described in Horn et al. (2018) and summarized in Appendix A. This state strengthening exploits dominance relationships without omitting any feasible solutions.It typically reduces the number of states that need to be considered substantially and helps to earlier recognize infeasible transitions.
Concerning the auxiliary upper bound function Z ub u ð Þ for the cost-to-go from a node u, we investigated in Horn et al. (2020) different fast-to-compute alternatives for PC-JSOCMSR.We adopt here the strongest one which is based on solving a set of linear programming relaxations of knapsack problems; Appendix B repeats details on how this bound is calculated.

Merging of states
In order to compile a relaxed MDD we further have to define the merging operation.Here, when two nodes u; v 2 V are merged into a new single node, the merged state is By this construction, the merged state allows all feasible extensions that both original states did.Additional extensions and originally infeasible solutions may, however, become feasible due to the merge, as is usually the case in relaxed DDs.The validity of the merging operation È is discussed in Appendix C. If possible, the obtained state is further strengthened as described above.
Fig. 5 shows an example of an exact MDD and a corresponding relaxed MDD for a small PC-JSOCMSR instance.The states associated with the nodes are detailed in the tables below each MDD.Arc labels indicate the scheduled job and its prize.In the exact MDD, the longest path is highlighted and it has a total length of nine.The corresponding optimal solution is given by the sequence p Ã ¼ 2; 3; 4 ð Þand the respective schedule is depicted on the right side of the figure.A relaxed MDD is shown in the middle; it has been obtained by merging nodes a and b from the exact MDD, yielding node d.The longest path of this relaxed MDD has length ten and it represents the sequence p Ã ¼ 2; 2; 4 ð Þ , where job 2 is scheduled twice.It can here be easily verified that all r-t paths in the exact MDD, which correspond to all feasible solutions of this PC-JSOCMSR instance, have corresponding paths in the relaxed MDD, but there exist additional paths representing infeasible solutions such as 2; 2; 4 ð Þ .

Labeling function for collector nodes
As a final major component, closely related to merging, we have to define the labeling function L u ð Þ used for indexing the collector nodes V c .Remember that this function should partition the set of nodes into subsets such that nodes within a subset are similar enough to be promising to merge; thus, similar nodes should tend to get the same label.
In case of PC-JSOCMSR, we use for a node u the triple as label, where t 0 u ð Þ is again the time from which on the common resource is available, r u ð Þ refers to the secondary resource of the job scheduled last in the so far longest path to node u (ties are resolved by using the resource identified first), and Z ub u ð Þ is the upper bound for the cost-to-go.Note that by this definition, we do not explicitly consider P u ð Þ, the set of jobs that might still be scheduled, nor t r ; r 2 R, the individual availability times of the secondary resources.Instead of the latter, r u ð Þ is used as a rough substitute.The upper bound Z ub u ð Þ is an important additional indicator that can be seen to somehow summarize important information about the state of node u.In summary, two nodes are only merged in our A Ã -based construction if (a) the common resource 0 is used to the same extent, (b) the last used secondary resource is the same, and (c) the values of the problem-specific upper bounds coincide.
Note that a merged node will have the same t 0 value as the original nodes according to Eq. ( 10).Since each job requires the common resource 0 for a positive time, each transition from a node to a successor node increases the corresponding t 0 value.From this follows the important property that the t 0 values strictly increase along any path in our MDD.Consequently, it holds that cycles cannot occur and that the open list gets empty in a finite number of iterations (since when the t 0 values strictly increase along any path, the set of jobs that might be scheduled will decrease due to the deadline of the jobs).Hence, the increase of t 0 in each state transition helps to guarantee that the algorithm terminates with a complete relaxed MDD.
In Section 7 we will experimentally investigate also the following simpler labeling functions: Besides the argued theoretical convergence, it might be the case that the practical running time of the algorithm is still too large due to the not strongly limited domain size of the labels: Values t 0 u ð Þ as well as Z ub u ð Þ may be continuous and in the worst case, exponentially many different values may emerge in the course of our algorithm, leading to a potentially exponential number of col-lector nodes.In our experiments in Section 7, this situation did not occur.In case that it does, discretizing these values in the labeling function by appropriate rounding can be a solution.

Dominated merging
Algorithm 2 does not merge already expanded nodes since, in general, the operations of re-evaluating and updating the expanded sub-graphs would be too expensive.However, sometimes it is possible to merge nodes with already expanded collector nodes without further evaluations and updates.Let v 2 Q be a not yet expanded node and u 2 V be an already expanded node.If is possible to merge v into u without changing the state of u and without increasing the length of the currently longest path to it.
The last two conditions are important to (a) safely omit the reexpansion of node u and (b) to efficiently identify such possible merges by additionally indexing all so far encountered nodes u 2 V by their t 0 u ð Þ values.After each node expansion, each new or changed node in Q is considered for this type of merge by checking the condition in conjunction with all other nodes in V that have the same t 0 value.If a pair of nodes u and v that fulfills this condition is found, we remove v from the open list and merge v into u by redirecting all incoming arcs from v to u.Since this kind of merge does not introduce any relaxation loss, we perform this procedure after every node expansion even if jQ j 6 /.

Tie breaking in the priority function
The nodes in the open list Q are sorted according to the value of the priority function f, given in Eq. (2).It is not uncommon that different nodes have the same f-value, and we therefore use the following two-stage tie breaking in order to further guide the algorithm in a promising way.First, if two nodes have the same f-value, we always prefer exact nodes over non-exact nodes.We call a node exact when it has a longest path from the root node that does not contain any merged node where the merging induced a relaxation loss.In other words, an exact node is guaranteed to have a feasible solution that corresponds to this longest path.Such nodes are considered more promising to expand than non-exact nodes with the same f-value.In case of a remaining tie, we prefer 5. Examples of an exact MDD and a relaxed MDD for a PC-JSOCMSR instance with n ¼ 4 jobs and m ¼ 2 secondary resources.In the relaxed MDD, the original nodes a and b have been merged.
nodes where the corresponding state has fewer jobs that may still be scheduled, i.e., we prefer nodes u with smaller jP u ð Þj.

Construction of a restricted MDD based on a relaxed MDD
A restricted MDD represents only a subset of all feasible solutions.It is primarily used to obtain feasible solutions and corresponding lower bounds.The construction usually follows a layerby-layer top-down approach (Bergman et al., 2014(Bergman et al., , 2016b)).As for relaxed MDDs, the size of a restricted MDD is typically limited by imposing a maximum width b for each layer.Whenever the allowed width is exceeded, nodes are selected from the current layer according to a greedy criterion and removed together with their incoming arcs.Note that this approach for obtaining promising feasible solutions closely corresponds to the well-known beam search metaheuristic (Ow and Morton, 1988).
So far, we are only aware of previous approaches that construct restricted DDs independently of relaxed DDs.However, an earlier construction of a relaxed DD will, in general, have already collected substantial information.We propose to exploit this information in a successive construction of a restricted DD.The goal is to speed up the construction of the restricted DD and/or to obtain a stronger restricted DD representing better solutions.
Throughout this section, we denote all elements of restricted MDDs with primed symbols, while corresponding symbols of relaxed MDDs are not primed.Our approach applies the common top-down compilation principle.Each node u 0 2 V 0 in the restricted MDD always has a corresponding node u 2 V in the relaxed MDD M in the sense that a path from r 0 to u 0 represents a feasible partial solution that is also represented in M by a path from r to node u.
In other words, the node u 0 2 V 0 that corresponds to a node u 2 V is the node that can be reached by the same sequence of scheduled jobs.For each newly created node in the restricted MDD, we keep track of its corresponding node in the relaxed MDD.
When expanding node u 0 , this corresponding node u will allow us to skip certain transitions in the restricted MDD without evaluating them, i.e., we avoid to introduce the corresponding arcs and successor nodes.In this way, a vast amount of arcs and nodes for states that cannot lead to an optimal solution may be omitted.
Algorithm 3 shows this compilation of a restricted MDD M 0 that utilizes the relaxed MDD M. We starts with the first layer that consists of the root node r 0 .Then, each successive layer V 0 lþ1 is built from the preceding layer V 0 l by creating nodes and arcs for feasible transitions from the states associated with the nodes in V 0 l .Here comes the first novel aspect: For each node u 0 in layer V 0 l we consider only state transitions corresponding to outgoing arcs of the respective node u in the relaxed MDD.Other potentially feasible state transitions do not need to be considered since we know from the relaxed MDD that they cannot lead to an optimal feasible solution.Note, however, that the relaxed node u might have outgoing arcs representing transitions that are actually infeasible for node u 0 in the restricted MDD.This may happen since the states of u 0 and u do not need to be the same but u 0 may dominate u due to merged nodes on the path from r to u in the relaxed MDD.In Line 8, our algorithm therefore checks the feasibility of the respective transition (remember that 0 represents the infeasible state) and skips infeasible ones.For PC-JSOCMSR, this feasibility check simply corresponds to testing if val a ð Þ 2 P u ð Þ.When we have reached the maximum allowed width at the current layer, we can make an efficient pre-check if the node v 0 that Algorithm 3: Construction of a restricted MDD based on a relaxed MDD would be created next would be removed later when the set V 0 lþ1 is greedily reduced to b nodes.To this end, we evaluate the criterion that is used to decide which nodes are removed from the current layer for the corresponding node v in the relaxed MDD in conjunction with the so far obtained set V 0 lþ1 .If this criterion is chosen in a sensible way, the evaluation for v will never indicate a removal of node v when v 0 would not be removed, since either the associated states are identical or the state of v 0 dominates the state of v.In our algorithm, Line 10 realizes this pre-check and correspondingly skips the respective transitions.
For the remaining transitions, Line 12 calculates the obtained new state R and creates the corresponding node v 0 if no node in V 0 exists yet for R.Then, a new arc u 0 ; v 0 ð Þrepresenting the transition in the restricted MDD is added to A 0 .Finally, if V 0 lþ1 has grown to more than b nodes, a node is removed according to the used greedy criterion.
A typical way to select the nodes for removal at each layer is to take the nodes with the smallest lengths of their longest paths from the root node r 0 , i.e., the nodes with the smallest Bergman et al., 2014Bergman et al., , 2016b)).As already observed in Maschler and Raidl (2018) this strategy is not beneficial for PC-JSOCMSR since it disregards the advances in the time line.Instead, we remove nodes with the smallest Z lp v 0 ð Þ=t 0 v 0 ð Þ ratios in our implementation for the PC-JSOCMSR.When applying this removal criterion to the corresponding node v of the relaxed MDD in Line 10, it holds that We can even sharpen this estimation by and thus take advantage of our knowledge of Z lp u 0 ð Þ and the respective transition cost z a ð Þ to reach node v.
The benefits of exploiting the relaxed MDD in the compilation of the restricted MDD depends on how closely the exact states in the restricted MDD are approximated by the corresponding states in the relaxed MDD as well as the size of the solution space encoded in the relaxed MDD.Various filtering techniques, as for example described by Cire and van Hoeve (2013) for sequencing problems, can substantially reduce relaxed MDDs, and consequently, their application to the relaxed MDD before its exploitation in the construction of the restricted MDD may be advantageous.

Computational results
The A Ã -based construction of a relaxed MDD for the PC-JSOCMSR, which we abbreviate in the following by A Ã C, as well as the approach from the last section to further derive a restricted MDD were implemented in C++ using GNU g++ 5.4.1.All tests were performed on a cluster of machines with Intel Xeon E5-2640 v4 processors with 2.40 GHz in single-threaded mode with a memory limit of 16 GB per run.
We use two non-trivial sets of benchmark instances from Horn et al. (2020) and, applying the same randomized construction scheme, further extended these to include instances with up to 500 jobs.The first set is based on characteristics from the particle therapy application scenario and denoted here as set P (referred to as set B in the former work), whereas the second instance set is based on the avionic system scheduling scenario and called set A; cf.Section 3.3.
The two instance sets differ substantially in their structure.For the particle therapy ones, the number of jobs that can approximately be scheduled grows linearly with the instance size, and the prize for each job is correlated to the time the job needs the common resource.In contrast, for the avionic instances, the number of jobs that can be scheduled stays in the same order of magnitude irrespective of the instance size and the prize does not depend on a job's processing time but instead on a priority.The number of secondary resources is m 2 2; 3 f g in set P, which corresponds to the available rooms at a real particle therapy center in Austria, and m 2 3; 4 f g in set A; note that in general more secondary resources make the problem significantly easier to solve as the common resource tends to become the sole bottleneck.As we will see in the following results, the structural differences in the instance sets also impact the obtained relaxed MDDs.In particular, the height of relaxed MDDs compiled for the particle therapy instances grows with the problem size, whereas the relaxed MDDs obtained for avionic instances typically have a height of the same magnitude.All instances are available at https://www.ac.tuwien.ac.at/research/problem-instances and are described in more detail in Appendix D.
This section is structured such that first, Section 7.1 presents results from studying the impact of different values for the open list size limit / and of different choices for the labeling function L u ð Þ in the compilation of relaxed MDDs with A Ã C. Thereafter, in Section 7.2, we compare the quality of upper bounds obtained from A Ã C to those from other approaches.Section 7.3 finally compares primal bounds obtained from the derived restricted MDDs to those from other heuristic and exact approaches for PC-JSOCMSR.

Impact of open list size limit / and different labeling functions
We tested A Ã C with different open list size limits / and four different variants of the labeling function L u ð Þ used for mapping nodes to collector nodes.The considered labeling function variants , as proposed in Section 5.3.Fig. 6 illustrates the impact of the different choices for / and the labeling function on middle-sized instances with 250 jobs of set P with m ¼ 2 and of set A with m ¼ 3, respectively.
For each combination of value for / and labeling function variant, there is a box plot drawn that summarizes the obtained results over all 30 instances of the corresponding category.The diagrams at the top show the lengths Z lp t ð Þ of the longest paths from the obtained relaxed MDDs, whereas the diagrams in the middle show the corresponding CPU-times for compiling the MDDs.Moreover, the diagrams at the bottom state the size of the relaxed MDDs in terms of the number of nodes.The diagrams to the left in Fig. 6 show the results for instance set P using the values / 2 1000; 2000; 3000; 5000 f g .As one could expect, we see that with increasing /, the lengths of the longest paths of the obtained relaxed MDDs in general get smaller, i.e., the obtained upper bounds become stronger, while the MDD sizes and computation times naturally increase.Thus, parameter / indeed allows to control the MDD's size, although not in such a direct linearly related fashion as the width-limit in a classical top-down construction.This effect can be observed for all labeling functions.Concerning the different labeling functions, L 1 u ð Þ ¼ t 0 u ð Þ yields relaxed MDDs with in general the smallest sizes, but also the weakest bounds.This is, however, also achieved in the shortest times.The reason for this is that labeling function L 1 does only consider the time from which on the common resource is available and has therefore the smallest domain among the four considered labeling functions.Hence, when using L 1 , there are in general far more node merges than with one of the other more complex labeling functions which provide larger domains and therefore a finer differentiation of nodes.It can clearly be seen that the additional consideration of r u ð Þ or Z ub u ð Þ in the labeling function in general significantly improves the obtained bounds Z lp t ð Þ, and the combination of all these aspects in L 4 provides the best results.This, however, at the cost of larger MDDs and higher running times.The smallest median longest path length of 783 for instances with two secondary resources were obtained when limiting the size of the open list to / ¼ 5000 nodes and using L 4 .In more detail, note that parameter / has more impact when using labeling function L 1 and less when using labeling function L 4 .This can again be explained by the domain sizes of the labeling functions, but also the fact that the bounds obtained with L 4 are in general already closer to the optimal solution values and it becomes more and more difficult to find better bounds.When comparing the results of L 2 and L3 , we can see that L 2 yields mostly slightly better results, but this again at the cost of longer running times.
The diagrams to the right in Fig. 6 shows the results for instance set A using the values / 2 10000; 20000; 30000; 50000 f g .Note that, since the time horizon in this case never exceeds T ¼ 1000, larger values of / were considered than in the experiments for instance set P. This implies that also the MDDs' heights are restricted correspondingly, and larger values for / can be used to utilize roughly comparable computation times.Again, we can see that parameter / allows to control the quality of the obtained relaxed MDDs.Hence, with increasing /, the lengths of the longest paths of the obtained relaxed MDDs in general get smaller, while the computation times and MDD sizes increase.
Structurally similar results are obtained for instances of set P with three secondary resources as well as for instances of set A with four secondary resources, cf.Appendix E.
For all further experiments, we went for a compromise between expected quality of the relaxed MDD and compilation time and fixed the following settings.Instance set P: labeling function

Upper bound comparison
The five types of upper bounds to be compared are the following.The first two are from A Ã C, namely Z ub min , which is obtained when the target node is chosen for expansion, and Z lp t ð Þ, which is the longest path length of the completely constructed relaxed MDD.A third one is obtained by solving a MIP model with a commercial solver, while the last two come from MDDs built with traditional TDC and IR algorithms.Remember that Z lp t ð Þ may be larger than Z ub min due to additionally performed merging operations after having found Z ub min .The MIP approach to which we compare is the compact orderbased formulation from Horn et al. (2020), and we applied Gurobi Optimizer 8.1 3 in single-threaded mode with a CPU time limit of 900 s.The TDC and IR methods are those from Maschler and Raidl (2018).The latter is performed with a CPU time limit of 900 s and TDC is executed with two different width limits b which were chosen in a way so that the average running times are roughly in the same order of magnitude and usually not smaller than those of A Ã C: b 2 300; 500 f gfor set P and b 2 3000; 5000 f gfor set A. Fig. 7 documents the results of this comparative study for instance sets P and A. The diagrams at the top show the obtained upper bounds, the middle diagrams the computation times, and the diagrams at the bottom the sizes of obtained relaxed MDDs in terms of the number of nodes.Each group of bars on the horizontal axes corresponds to a specific instance class with the stated number of jobs, and each bar indicates the average value over all 30 instances of the corresponding instance class and the respective approach.
Concerning the depicted computation times, each first bar shows A Ã C's average time to obtain Z ub min , i.e., when the construction would stop according the classical A Ã termination criterion, while Fig. 6.Comparison of open list size limits / and labeling functions L i ; i ¼ 1; . . .; 4, for instances of sets P and A with 250 jobs and m ¼ 2 and m ¼ 3 secondary resources, respectively.
the second bar shows the average time required for the construction of the complete relaxed MDD.Since the MIP approach as well as IR exhausted the time limit of 900 s in almost all runs, we omit corresponding bars.More specifically, the MIP solver could only solve the smallest instances to proven optimality.The percentages of the instances with n ¼ 50 jobs are 23:3% and 10% of set P for m ¼ 2 and m ¼ 3, respectively.The IR approach was not able to solve any instance to proven optimality.
The results for instance set P, shown in Fig. 7 on the left side, give a rather clear picture.The average upper bounds Z ub min obtained by the A Ã C algorithm are always the strongest.They are in particular substantially better than those obtained from the TDC variants and the IR approach.The difference is more than a factor of four for the largest instances.Even more dramatic are the differences in the sizes of the respectively obtained MDDs.A Ã C's MDDs are usually more than an order of magnitude smaller than those compiled with TDC and IR.The A Ã C algorithm clearly can take advantage from avoiding multiple nodes for the same state at different layers, and the merging strategy we proposed appears to be effective.The bounds obtained from the MIP approach are clearly better than those of TDC and IR, but also significantly worse than those of A Ã C. Differences between Z ub min and Z lp t ð Þ are in comparison to the bounds from the other approaches not that large, but still significant.
For instance set A, Fig. 7 shows remarkable differences.The upper bounds obtained from the MIP approach are far worse than those obtained from A Ã C as well as TDC and IR.Differences between A Ã C, TDC, and IR are not that large anymore, but nevertheless, in each case the strongest upper bounds could be obtained by A Ã C. The better relative performance of the classical approaches TDC and IR on these instances in comparison to set P can be explained by the constant time horizon and the special prize structure, due to which the height of the MDDs is limited in a stronger way.Concerning the size of the obtained MDDs, A Ã C exhibits again substantial advantages over TDC: A Ã C's MDDs only have about half the size of TDC's MDDs, and those of IR are even more than three times larger than those of A Ã C for the smaller instances.
Similar results are obtained for instances of instance set P with three secondary resources as well as for instances of instance set A with four secondary resources, cf.Appendix E.

Lower bound comparison to other approaches
Finally, we consider the A Ã C approach to construct a relaxed MDD followed by the construction of a restricted MDD and compare to other heuristic methods to approach larger PC-JSOCMSR instances.Now, our focus is primarily on the quality of obtained heuristic solutions, i.e., lower bounds, but since our approach also yields upper bounds from the relaxed MDD, we will also study resulting gaps.We compare to a conventional TDC of a restricted MDD, a general variable neighborhood search (GVNS) metaheuristic, the MIP approach, and a basic CP formulation.
After a relaxed MDD has been constructed by A Ã C, it is postprocessed by filtering in order to reduce its size and strengthen it before deriving the restricted MDD.This is done as follows.
1.A first lower bound (and heuristic solution) is determined in a quick way by compiling a small restricted MDD in an independent way (maximum width b ¼ 100 for type P instances and b ¼ 15000 for type A instances). 2. Using the obtained lower bound, cost-based filtering (see, e.g., Cire and van Hoeve (2013)) is applied in order to get rid of many arcs and nodes that cannot be part of a path representing a better solution.3.For each node u in the relaxed MDD, we have the upper bound for the cost-to-go obtained from the auxiliary upper bound function Z ub u ð Þ, but also the length of the longest u-t path pro-Fig.7. Instance sets P and A with two and three secondary resources, respectively, average values of: upper bounds obtained from A Ã C, the classical TDC, the IR, and the orderbased MIP approach; respective computation times; and the sizes of the obtained relaxed MDDs.
vides an upper bound, which we denote by Z lp" u ð Þ.We keep the better of these bounds and check if further arcs and nodes may be removed due to it by cost-based filtering.Note that Z lp" u ð Þ can be determined for all u 2 V efficiently by a single bottomup traversal of the MDD. 4. When removing some ingoing arc of a node, we always redetermine the state of the node, and if the state changes, the auxiliary upper bound Z ub u ð Þ. Changes are always propagated to successor nodes as far as they are affected.
After the relaxed MDD has been filtered, it is used to compile the main restricted MDD.Experiments showed that on average 51:57% and 88:90% of all arcs can be removed from the relaxed MDD over all instance sizes for type P and type A instances, respectively.This substantial reduction leads, in particular for type A instances, to shorter computation times when compiling the main restricted MDD.
The conventional TDC of a restricted MDD uses the same greedy criterion from Section 6 to select nodes for removal as our compilation method based on the relaxed MDD.Fig. 8 shows for different maximum widths b a comparison between the conventional TDC and the TDC when utilizing a previously compiled and filtered relaxed MDD by A Ã C. The relaxed MDDs were compiled with different values of / and used labeling function L 3 u ð Þ and L 4 u ð Þ for instance set P and A, respectively.Although the choice of / has an impact on the quality of the obtained relaxed MDD, as shown in Section 7.1, the plots in Fig. 8 indicate that / does not significant influence the finally obtained objective values from a subsequently applied TDC for the considered instance classes.Regarding computation times, we can see that larger values of / will result in larger computation times.While the obtained objective values are not substantially different compared to those from the conventional TDC, the diagrams at the bottom row indicate substantial time savings when a relaxed MDD is used to compile a restricted MDD.For example for instances with 250 jobs and two secondary resources of instance set P the conventional TDC needs for b ¼ 20000 1407 s to terminate whereas the A Ã C + filtering + TDC approach only needs 170 s.This time saving of frequently almost an order of magnitude is the benefit of using the structural information of a previously compiled and filtered relaxed MDD.
Moreover, we also tried to create restricted MDDs by a variant of A Ã C in which nodes are removed from the open list instead of merging them in Line 29 of Algorithm 1.This, however, only yielded restricted MDDs with substantially worse objective values than the conventional TDC.Increasing parameter / to allow a larger open list size also did not help much in this case but just led to larger computation times.
Note that the computational experiments reported in Fig. 8 were done on a somewhat different cluster environment at a later time than all other experiments of this article.After a thorough analysis we concluded that computation times of our algorithms differed by a factor of 2.2 between the different environments, and we have scaled the reported times in Fig. 8 accordingly to make them directly comparable.
For the main results in Table 1 we compile restricted MDDs with b ¼ 2000 and b ¼ 12000 for benchmark sets P and A, respectively.Moreover, the A Ã C + filtering + TDC approach compiles restricted MDDs with b ¼ 12000 and b ¼ 45000 for benchmark sets P and A, respectively.These values have been selected so that the TDC terminates for the largest instances in about 900 CPUseconds.
The GVNS is the one from Maschler and Raidl (2018).It applies a job permutation encoding, starts with a random initial solution, and combines a classic exchange and insertion neighborhood search for intensification.For diversification (shaking), up to four random insertion moves are performed.The GVNS terminates when reaching a time limit of 900 s.
Moreover, we compare to the objective values of the best feasible solutions provided by the order-based MIP formulation from Horn et al. (2020), solved again by Gurobi using a single thread with a CPU time limit of 900 s.
Last but not least, we also consider the CP model from Horn et al. (2018).The model was implemented with MiniZinc 2.1.7 4 and we apply the backbone solver Chuffed with a time limit of 900 s. Results with Chuffed consistently dominated those obtained with M. Horn, J. Maschler, Günther R. Raidl et al. Computers and Operations Research 126 (2021) 105125 the alternative backbone solvers Gecode and G12 LazyFD.Note that we further performed tests with the newer MiniZinc version 2.3.2, but obtained results were inconsistent and mostly worse than those from version 2.1.7.
The results of all approaches are presented in Table 1.Each row shows the aggregated results over the 30 benchmark instances with the characteristics given in the first three columns.For all approaches columns obj and r obj ð Þstate the mean objective values of obtained heuristic solutions and corresponding standard deviations.For the MDD-based approaches these values correspond to the lengths of the longest paths in the restricted MDDs.Moreover, we list for the MDD-based approaches median total computation times in seconds in the t s ½ columns, and for the A Ã C based approach more specifically in column t f s ½ median times just for filtering the relaxed MDDs including the times for determining the required lower bound and in column t c s ½ median times for compiling the final restricted MDDs.For GVNS, MIP, and CP timing information is omitted as they were always terminated with the time limit of 900 s.The only exceptions are MIP and CP runs for the smallest instances with 50 jobs, which finished in some cases earlier with proven optimality.In addition, we list for the A Ã C based approach average optimality gaps, where If we disregard the results from the benchmark instances of type P with three secondary resources for now, Table 1 gives a clear picture.A Ã C + filtering + TDC provides in general the best solutions, followed by the GVNS and the TDC.While the TDC performs, on the P instances with two secondary resources, in most cases better than the GVNS, the GVNS is superior to the TDC on the other instances.The weakest solutions have on average been obtained by the MIP and CP approaches, which are only competitive for type P instances with 50 jobs.Especially, for the medium to large instances, the A Ã C based method typically requires less time than TDC.A Ã C + filtering + TDC is superior to the conventional TDC in two ways.Not only are we able to construct much larger restricted MDDs, usually yielding better solutions in less time, but since we first also determine the relaxed MDDs, our approach has the additional bonus of providing upper bounds.Average gaps never exceed 15% and are in particular for instance set A usually not larger than 8%.
On benchmark instances of set P with three secondary resources, GVNS typically provides the best solutions when more than 150 jobs are considered.The relative differences between the obtained objective values from GVNS and our A Ã C-based approach are typically about one to two percent.We believe that in these cases, the GVNS's local search is particularly effective.Clearly, an option would be to finally ''polish" the solutions of the MDD-based methods by applying a local search.Another particularity of the results for set P with m ¼ 3 are the required times t c for constructing the restricted MDDs.Although the same maximum width is used as for the instances with two secondary resources, these median times are considerably shorter for the case with three secondary resources than for two.This indicates an even better exploitation of the relaxed MDD and underlines the consistent performance improvements of A Ã C + filtering + TDC over the classical TDC of restricted MDDs.
The optimality gaps increase with the problem size on all instance sets, as one might expect for a compilation of relaxed and restricted MDDs with fixed parameter values.In comparison to instance set A, we obtain smaller optimality gaps on type P instances with few jobs but get larger optimality gaps for the instances with many jobs.This can be explained by the problem size independent time horizon of set A instances, which implies a certain maximal number of jobs that can be scheduled independently of the number of available jobs.
Last but not least, for some instances the optimality gap has been closed, i.e., they could be solved to proven optimality.This was the case for nine of the type P instances with two secondary resources and 50 jobs.For type P instances with three secondary resources we could optimally solve ten instances that consider 50 jobs.Furthermore, for a single benchmark instance with 50 jobs and four secondary resources of type A, the lower and upper bound coincided.

Conclusions and future work
We considered the PC-JSOCMSR problem, a prize-collecting scheduling problem, where a subset of jobs must be selected from a ground set of jobs and sequenced to form a feasible solution.By a simple extension, MDDs that are traditionally used for sequencing become suitable to represent the search space of the PC-JSOCMSR problem, where the solutions are of variable length.
By applying the principles of A Ã search, we proposed a new way of compiling relaxed MDDs for large instances of the PC-JSOCMSR that are challenging to solve to proven optimality.The suggested method has the advantage that it does not rely on a layer-tovariable correspondence, and consequently, multiple nodes for the same states at different layers are efficiently avoided.In contrast, traditional layer-oriented TDC and IR approaches would, for the PC-JSOCMSR, typically lead to relaxed MDDs with a substantial amount of redundant isomorphic substructures.Note further that also the merging of nodes is done across layers.
Moreover, our A Ã -based method utilizes an auxiliary heuristic function to estimate the cost-to-go from each reached node.This function guides the A Ã search, and thus the relaxed MDD may be constructed in a more meaningful way.As in any A Ã search, the better this heuristic function estimates the real cost-to-go, the more efficient the approach becomes.
We propose to restrict the number of nodes in the open list instead of restricting the width at each layer.If merging becomes necessary, a node that appears less promising to be part of a finally longest path is selected first and a similar partner node is efficiently determined by the proposed collector node concept.To this end, not yet expanded nodes are labeled in a state-spacerelaxation fashion and maintained in a dictionary for efficient lookup.Choosing a proper labeling is important both to obtain a strong relaxation but also to prevent cycles in the construction of the relaxed MDD and to ensure termination of the construction.Our experiments confirmed that substantially smaller and stronger relaxed MDDs could be obtained in the same or shorter times than with traditional TDC and IR methods.
While a relaxed MDD yields an upper bound on the optimal solution value for a maximization problem and encodes much useful information, it does in general not directly yield a promising heuristic solution and lower bound.For obtaining heuristic solutions, restricted MDDs are suitable.In previous works, they have been constructed independently of the relaxed MDD.We showed how the construction of a restricted MDD can be improved by constructing a relaxed MDD first and then exploiting the encoded knowledge.Again, our experiments for the PC-JSOCMSR confirmed the advantages: The main benefit is a substantial speedup in the construction of the restricted MDD.We even showed that the total time for constructing the relaxed MDD, filtering it, and deriving a restricted MDD of a certain size based on the relaxed MDD can take less time than the classical independent construction of a restricted MDD of the same size.Thus, one might say that in our combined approach, one gets the upper bound from the relaxed MDD and thus a quality guarantee in addition to a promising heuristic solution ''for free".
We compared this overall approach to an order-based MIP model solved by Gurobi, to a GVNS metaheuristic, and to a basic CP approach solved by MiniZinc.The MIP model only produced rather weak lower and upper bounds for all instances except the smallest.For most cases, our approach yielded the best solutions.An exception are the larger instances of the particle therapy benchmark set with three secondary resources, where the GVNS outperformed the other methods.
Naturally, it is interesting to test the proposed methods in future work also on other problems that include both the selection and sequencing aspects, like those referred to in Section 1.Although not a strong limitation, an important property of a suitable problem may be the order-invariance of the objective function, which is exploited by the proposed approach.Moreover, note that the idea of exploiting relaxed DDs in the construction of a successive restricted DD is more generally applicable.For some problems, the proposed way of finding similar partner nodes for merging may also be useful in the context of a classical layer-wise TDC of relaxed MDDs, where so far a simpler bulk merging is primarily used.
For some applications of relaxed DDs, an important aspect is incrementability, i.e., that a once obtained complete DD can be further refined, for example, to strengthen the obtained bound.Naturally, known iterative refinement methods based on node splitting and filtering can also directly be applied to relaxed DDs obtained from the A Ã -based construction.Moreover, the A Ã -based construction may be iteratively applied with increasing open list size limits, yielding stronger and stronger DDs over the time.Hereby, information contained in one DD can always be exploited to speed up the construction of a successive DD in a similar way as we derived a larger restricted DD on the basis of a relaxed DD.An interesting research question is if a completely constructed DD can also be effectively updated in-place by a following A Ã -based refinement pass.
Last but not least, it is of relevance to investigate the proposed A Ã -based MDD construction also from a more theoretical side.Unfortunately, a constant open list size limit / does in general not necessarily imply that the obtained relaxed MDD has polynomial size, and therefore also the algorithm's runtime is not necessarily polynomially bounded.Note, however, that similarly no better performance guarantees can be given for classical A Ã search without considering a more specific problem setting and a concrete heuristic function.In fact, the resulting MDD's actual size strongly depends on the interplay of /, the problem-specific heuristic function for the cost-to-go, the labeling function for the merging, and how the merging is performed.
One extension to guarantee a termination with a complete relaxed MDD when reaching a certain time limit or MDD size is to reduce / to a very small value from this point onward.However, solution associated with inequality (B.8) and therefore has a chance to be a good estimate of a value for k that gives a strong upper bound.
By solving the relaxations introduced above, the strongest bound on Z ub KP u ð Þ we can obtain, and the one that we use in our A Ã -based construction of a relaxed MDD, is Definition 1.A weighted DD is relaxed for an optimization problem P if (i) the DD represents a superset of the feasible solutions to P and (ii) each path that represents a feasible solution to P has a length that is an upper bound on the objective value of this solution.
Given an exact DD formulation and a merge operator, this operator is considered valid if (repeatedly) applying it to the DD will result in a DD that is relaxed with respect to the original problem.In order to show this, it is sufficient to show that if the merge operator is applied to a DD that complies with (i) and (ii), so will the resulting DD, and the result will follow by induction.(For the initial step of the induction, we assume the operator is applied to an exact DD, which trivially complies with (i) and (ii)).
Proposition 1.Given a relaxed MDD constructed for the PC-JSOCMSR according to Sections 5.1 and 5.2 that complies with (i) and (ii) in Definition 1.When the merge operator defined in Eq. ( 10) is applied to this MDD, then the resulting MDD will also comply with (i) and (ii).
Þcarries the following information.The set P u ð Þ# J of jobs that can still be feasibly scheduled, and the vector t u ð Þ ¼ t r u ð Þ ð Þ r2R 0 of the earliest times from which each resource r is available for performing a next job.When the merge operator r u ð Þ È r v ð Þ is applied to the two states Þ , the resulting state is For the merged state, the set of jobs that can be feasibly scheduled is a superset of both the original sets of jobs, and no feasible solutions are omitted due to the merge.As for the earliest times, since the merged state gets the component-wise earliest time from each of the original states, no feasible solution is lost.Because of this, (i) holds after the merge operation is applied.Note that after the merge operation, paths from the merged state that were not feasible with respect to nei- Condition (ii) follows because the longest path from r u ð Þ È r v ð Þ is selected from a superset of the paths that existed before the merge and that the cost of the arcs are the same.Moreover, note that the DD stays acyclic and therefore feasible thanks to the node selection mechanism.

Appendix D. Benchmark instances
For the experiments in this work, we adopted the set on ''balanced particle therapy instances", here denoted by P, and ''avionic instances", denoted by A, from Horn et al. (2020) and extended them with larger instances with up to 500 jobs using the same construction scheme.Note that in the previous work also a third set of ''skewed particle therapy instances has been considered, in which the usage of the secondary resources is not uniform.However, especially for large instances the differences between the balanced and skewed instances turned out to be less interesting, and we therefore do not consider the skewed instances here.
Both instance sets contain 30 instances for each combination of n 2 50; 100; . . .; 500 f gjobs and m 2 2; 3 f g secondary resources for instance set P and m 2 3; 4 f g secondary resources for instance set A.
Particle therapy instances (P).For these instances, the following values are sampled for each job j 2 J: (a) the secondary resource q j from the discrete uniform distribution U 1; m f g, (b) the preprocessing times p pre j and the post-processing times p post j from U 0; 8 f g, (c) the times p 0 j from U 1; 8 f g, and (d) the prize z j from U p 0 j ; 2p 0 j n o (such that this prize correlates to the usage of the common resource of job j).Time windows are chosen such that, on average, roughly 30 % of the jobs can be scheduled.For this purpose let the time horizon be T ¼ 0:3 n E p 0 À Á Ä Å , where E p 0 À Á is the expected value of the distribution for p 0 j .In the first step, the number of time windows x j of job j is sampled from U 1; 3 f g, i.e., a job can have up to three time windows.Second, for time window Avionic instances (A).For details on the motivation and background see Horn et al. (2020).A fixed time horizon of T ¼ 1000 is considered, and there are 20% communication jobs, 40% partition jobs, and 40% regular jobs.The time p 0 j is for partition jobs and regular jobs sampled from the discrete uniform distribution U 36; 44 f g and for communication jobs p 0 j ¼ 40.Each partition job is assigned a secondary resource and each secondary resource has the same probability to be selected.For partition jobs, the total processing time p j is sampled from U 5p 0 j ; 8p 0 j n o and then, with equal probability, p pre j or p post j is set to 0 and the respective other value is set to p j À p 0 j .Since the communication jobs and regular jobs do not use a secondary resource in the real scenario, an artificial secondary resource is introduced and assigned to all of these jobs, and p j ¼ p 0 j .The prize z j is for five of the partition jobs and ten of the communication jobs set to the high value 70 to give these jobs a higher priority, while for the remaining partition jobs and communication jobs the prize is sampled from U 10; 50 f g .For all regular jobs, the prize is sampled from U 10; 25 f g .For partition jobs and regular jobs, the number of time windows and the length of the time windows are computed as in the particle therapy case, but for the communication jobs the structure is different.The communication jobs can only be scheduled at certain points in time when the communication can be performed; these time points are 0; 80; 160; . . .; 880.Each time window of a communication job corresponds to one such time point and a job's total set of time windows corresponds to a number of consecutive such time points.
The number of time windows for a communication job is obtained by sampling a value from the uniform distribution U 1; 3 f g and multiplying it by three.

Appendix E. Further results
Fig. E.9 shows additional results for instances of sets P and A with three and four secondary resources, respectively.As in Section 7.1 the impact of the open list size limit / and different labeling functions are analyzed and conclusions are similar: In general, with increasing / the lengths of the longest paths of the obtained relaxed MDDs from A Ã C get smaller, while the computation times and the MDD sizes increase.The smallest relaxed MDDs with the weakest bounds could in general be obtained from labeling function L 1 whereas labeling function L 4 typically provides the largest MDDs with the strongest bounds.Regarding the comparison of upper bounds obtained from different approaches, Fig. E.10 shows in addition to the results presented in Section 7.2 corresponding results for instances of set P and A with three and four secondary resources, respectively.Average values of upper bounds, computation times, and the sizes of relaxed MDDs, obtained from A Ã C, the classical TDC, the IR, and the order based MIP approach are shown.Again, we observe remarkable differences between results obtained from instances of set P and A. Nevertheless, in each case the strongest average upper bounds could be obtained by A Ã C thereby creating as well the smallest obtained relaxed MDDs.

Fig. 4 .
Fig. 4. Phases of a job j 2 J with respective times and required resources.

Fig. 8 .
Fig. 8.Comparison of A Ã C + filtering + TDC and conventional TDC for instances of sets P and A with 250 jobs: average objective values and median computation times in dependence of b.
Validity of the merging operationThis section details the validity of the merge operator.In line with the common definition of a relaxation,Bergman et al.  (2016a)  defines a relaxed DD as follows.
k; k ¼ 1; . . .; x j , its start time w start jk is sampled from U 0; T À p j

Fig. E. 9 .
Fig. E.9.Comparison of open list size limits / and labeling functions L i ; i ¼ 1; . . .; 4, for instances of sets P and A with 250 jobs and m ¼ 3 and m ¼ 4 secondary resources, respectively.
The relaxed MDD approximates the exact MDD by merging nodes u and v into node v 0 .The corresponding longest path encodes the infeasible solution Þand yields the upper bound 35.In the restricted MDD, node v and its incident arcs are removed and therefore only a subset of all feasible solutions is encoded.Its

Table 1
Comparison of the subsequent application of A Ã C, filtering, and the construction of restricted MDDs to the conventional top-down construction of restricted MDDs, the GVNS, and MIP and CP approaches.Bold numbers indicate for each row the best obtained objective value over all considered approaches.