Finding the Shortest Non-Delay Schedule for a

International Journal of Operations Research and Information Systems, 3(4), 41-58, October-December 2012 41

Finding the Shortest Non-Delay Schedule for a Resource-Constrained Project Yuval Cohen, Department of Industrial Engineering, Tel-Aviv Afeka College of Engineering, Open University of Israel, Tel-Aviv, Israel Arik Sadeh, Technology Management Department, Holon Academic Institute of Technology, Holon, Israel Ofer Zwikael, Research School of Management, Marketing and International Business, College of Business and Economics, Australian National University, Canberra, ACT, Australia

ABSTRACT Non-delay schedules lack non-essential idle time intervals. Many heuristics for solving the resource-constrained project scheduling problem yield non-delay schedules. This paper presents a technique for finding the shortest non-delay schedule, which should be as good as the leading heuristics for this purpose. The authors combine branch-and-bound and dynamic programming approaches to yield a surprisingly simple algorithm. (The simplicity is reflected in the number of calculations and memory required.) Due to its simplicity, a project manager should be able to trace the algorithm’s stages and results without difficulty. This simplicity is a result of: (1) the number of stages equals the number of activities; (2) each stage uses only information from the previous stage, and the number of different schedules is typically limited; and (3) the proposed method becomes simpler the more it is constrained. A detailed example illustrates the technique, which is validated by comparisons to models from the literature. Keywords:

Algorithm, Heuristic Scheduling, Non-Delay Scheduling, Project Scheduling, Resource Constraints, Resource-Constrained Project Scheduling Problem (RCPSP), Time Intervals

INTRODUCTION This paper suggests a new heuristic technique to solve the well known resource-constrained project scheduling problem (RCPSP). RCPSP is related to any business project having limited resources, a characteristic of most business proj-

ects. However, the proposed approach may suit (with minor modifications) other resource constrained scheduling environments. The quality of the solution compared to other heuristic solutions is guaranteed since the proposed technique finds the optimal non-delay schedule whereas most heuristics generate non-delay schedules.

DOI: 10.4018/joris.2012100103 Copyright © 2012, IGI Global. Copying or distributing in print or electronic forms without written permission of IGI Global is prohibited.

42 International Journal of Operations Research and Information Systems, 3(4), 41-58, October-December 2012

RCPSP is the problem of finding a schedule that minimizes the makespan of a project under resource and precedence constraints (Herroelen & Leus, 2005). RCPSPs are characterized by a set of one or more limited resource types and a set of activities to be scheduled. Each activity lasts a given duration and during its execution has a fixed consumption level for each type of resource. In resource-constrained scheduling, the aim is to find a feasible schedule with the shortest makespan. Although the RCPSP can be easily formulated, its solution complexity is known to be NP-hard (Blazewicz, 1983; Demeulemeester & Herroelen, 2002; Sprecher, 2002). This renders exact solution approaches impractical for large-scale projects. The motivation for seeking a heuristic procedure is therefore obvious. This paper provides a very simple and efficient heuristic technique with an approach that could be extended to other resource constrained scheduling environments. Many excellent heuristics yield schedules that belong to a class known in the literature as “non-delay” schedules (Kolisch, 1996; Kolisch & Hartman, 1999; Demeulemeester & Herroelen, 2002). The non-delay approach is similar to the “early start” approach. According to this approach, any activity that can be started without postponing other activities should not be delayed. The non-delay/early start approach is very popular among project managers, since delaying activities may increase, in general, the risk of not completing the project on time. The proposed scheduling technique finds the best schedule within the class of non-delay schedules. The technique utilizes both precedence and resource constraints to form a surprisingly efficient branch-and-bound procedure (both the efficiency and quality of the proposed technique are discussed towards the end of the paper). Moreover, the technique is flexible in that it can serve (with minor modifications) any number of resources and changes in their levels (as long as they are known in advance). In contrast with many other scheduling methods, the technique and its results can easily be traced and intuitively understood by a project manager. As such, the generated schedule could

serve as a managerial tool for planning when there are changes in resource levels (as a result of initiative or unplanned events). As explained above, the problem is finding a feasible schedule that minimizes the makespan of a project under resource and precedence constraints. The classical resource-constrained problem is formally described in Sprecher et al. (1995). This paper uses part of their notation as follows. Consider a single project that is implemented over a finite number of periods with T being the upper bound on the project makespan and t=1,…,T being the a period index. The project consists of J activities. R is the set of renewable resource types and each resource type r∈R has limited availability of Krt at any given time t. Each activity j has duration of dj and resource consumption of kjr. The activities are partially ordered by precedence constraints where Pj is the set of the immediate predecessors of activity j. The activities are numerically or alphabetically labeled, so that any predecessor of j has a smaller number than j. The precedence relations can be represented by a table or an acyclic network of activities on nodes (AON) or activities on arcs (AOA). Using the traditional forward and backward recursion, the earliest and latest start (ESj, LSj), and finish times (EFj, LFj) can be computed for each activity j. If we disregard resource constraints, these times could be used as intervals for the start and end of activity j. However, due to resource constraints, some combinations of activities cannot be carried out simultaneously, so these intervals might be infeasible. To enable these intervals to include the optimal feasible schedule (and some other feasible schedules), the definitions of LFj and LSj are changed as follows: Use any resource leveling heuristic technique to generate a feasible solution and mark the activity finish times by Fj. Take the maximum of {Fj, LFj} to be the new LFj and the new LSj becomes: LFj-dj. This definition ensures that the intervals include at least one feasible schedule with task times starting within the interval (ESj, LSj), and finishing within the interval (EFj, LFj) for all j∈J.

Copyright © 2012, IGI Global. Copying or distributing in print or electronic forms without written permission of IGI Global is prohibited.


Figure 1 briefly summarizes the RCPSP schedule type definitions (Sprecher et al., 1995; Kolisch et al., 1995) which include non-delay schedules (NDS). NDS are a subset of active schedules (AS) that are themselves a subset of semi-active schedules (SAS) which are a subset of feasible schedules (FS). Thus, NDS⊆AS⊆SAS⊆FS⊆S. Sprecher et al. (1995) showed that an optimal RCPSP schedule must be an active schedule (see Figure 2 for an example). A non-delay schedule typically contains near-optimal solutions. However, the optimal schedule may or may not be a non-delay schedule. Figure 1 depicts the relationships between the different groups of schedules. To illustrate the definitions we shall use the example in Figure 2 (inspired by Demeulemeester & Herroelen, 2002), to show the various types of schedules in Figure 3. Note that the possible improvement marked in Figure 3(d) would yield another non-delay schedule.

The rest of the paper is structured as follows: the next section presents the related literature. It is followed by a section describing the algorithm logic; a section is dedicated to illustrating the algorithm using a detailed example, a discussion on the solutions’ quality and the proposed algorithm’s complexity. The last section concludes the paper.

RELATED LITERATURE Since the RCPSP is known to be NP-hard (in the strong sense), all exact optimal techniques have a non-polynomial complexity and none of these exact techniques can solve large-scale projects in a timely manner (Blazewicz, 1983; Kolisch & Hartman, 1999; Demeulemeester & Herroelen, 2002). Accordingly, exact procedures will only be mentioned for the readers who may be interested in the formulation of the RCPSP problem. The proposed technique, however, is compared to heuristic procedures.

Figure 1. Van diagram for all groups of schedules. The optimum is contained within the active solutions group, which also contains the non-delay schedules group (adapted from Baker, 1974).



Figure 2. Activities-on-nodes (AON) network of the project example used in Figure 3 (inspired by Demeulemeester & Herroelen, 2002)

Figure 3. Illustration of the main types of schedules for the RCPSP based on Figure 2



For modeling the RCPSP problem as an integer programming (IP) problem, Pritsker et al. (1969) defined binary variables Xj,t, to indicate when the job is executed. Since j=1,…, J and t={EFj, EFj+1,….,LFj} the number of variables could be prohibitive. Following this work, the following researchers improved the mathematical programming formulation of the RCPSP problem: (Kolisch, 1996; AlvarezValdes & Tamarit, 1989; Mingozzi et al., 1998; Klein, 2000). An old branch-and-bound (BB) concept solving RCPSP problems (Agin, 1966) has been renewed by Demeulemeester et al. (2000). Moreover, Demeulemeester and Herroelen (2002) introduced an efficient BB approach allowing some delays in the schedule. Sperecher et al. (1995) defined “active” and “semi-active” schedules in the realm of project scheduling and their definition is used in our study. While search techniques such as simulated annealing, tabu-search and genetic algorithms can find acceptable solutions, their quality is a function of the run length (Lee & Kim, 1996; Cho & Kim, 1997). In addition to search techniques, there are two main types of heuristic procedures which characterize RCPSPs: (1) constructive heuristics, and (2) improvement heuristics. Constructive heuristics start from an empty schedule and iteratively add activities to the schedule. Improvement heuristics, on the other hand, begin with a feasible schedule that was obtained by a constructive heuristic. Improvement trials continue until a local optimum is obtained (Zhu et al., 2005). Since this paper presents a constructive scheduling technique, it should be compared with the other constructive methods. Most constructive heuristics are composed of two major components: (1) scheduling schemes and (2) priority rules. Scheduling schemes deal with the order of adding activities to the schedule. For example, the activity addition to the schedule can be serial (Kelley 1963), parallel (Brooks & White, 1965), backward, or bi-directional (Demeulemeester & Herroelen, 2002). Priority rules are for choosing the specific activity (or activities) to be added to the schedule at each step of the scheduling scheme.

Pinson et al. (1994) showed that the complexity of a serial scheduling scheme is O(mJ2) where m is the number of precedence relations, and J the number of tasks. Kolish (1996) proved that a serial scheduling scheme can generate an active schedule (as defined previously). The results for serial scheduling apply also to backward scheduling. Kolish and Hartman (1999) showed that parallel scheduling scheme complexity is O(mJ2). Kolish (1996) proved that parallel scheduling schemes generate non-delay schedules. These conclusions for parallel scheduling apply also to bi-directional scheduling techniques also generate non-delay schedules. Each of the above schemes generates a single schedule using a given priority rule. Changing the priority rules generates more solutions. Multi-scheduling schemes (using several schemes) have been proposed by Li and Willis (1992), Ozdamar and Ulusoy, (1996a, 1996b), and Tormos and Lova (2001). As noted, both parallel and bi-directional scheduling techniques generate only non-delay schedules (regardless of the priority rules). Since the proposed technique described in this paper finds the best non-delay schedule, its solution (non-delay schedule) must be better or equal to the non-delay schedule produced by any other heuristic.

THE PROPOSED ALGORITHM The proposed algorithm can work nicely for any number of tasks or activities (of course, it is trivial for one, two or few activities). Moreover, the algorithm can easily be adjusted to changes and activity additions. The effect of an increase in the number of activities depends on where they are added: if they are added randomly or in various places, the algorithm has to be run again. However, if they are added at the end (after the previous activities), the algorithm can be started by repetitive opening of the intervals from the end (from the last interval backwards) as long as there are enough slack resources for accommodating at least one of the added activi-



ties. While the proposed algorithm requires the precedence relations it does not depend on their graphic representation. Thus, it can work with a table, AON or AOA as long as they represent the same precedence relations.

Principles and Concepts of the Proposed Algorithm’s Logic The proposed algorithm’s logic is based on J stages (J being the number of tasks). The first stage enumerates all the feasible single tasks that could be scheduled first (at time zero). The second stage takes each task of the first stage, and enumerates all feasible task additions to this initial task. Subsequently, the second stage eliminates dominated schedules (with the same tasks but of longer duration). Each stage repeats the actions of the second stage: the jth stage develops the j-1 stage schedules by enumerating all feasible additions of a single task, and subsequently eliminating dominated schedules. The algorithm combines the form of dynamic programming (in which each stage utilizes the information included in the previous stage) and branch-and-bound (BB) techniques. The algorithm significantly narrows the enumeration at each stage to generate a limited set of feasible candidates for the next stage. This is done by utilizing: (1) the concept of closed intervals, (2) bounding; and (3) precedence and resources constraints (as pertains to each specific partial schedule) To elucidate the discussion of the algorithm, two new terms have been formulated: closed interval and open-set. A closed interval is an interval of time in which a set of activities is scheduled so that no other non-scheduled activities can be processed simultaneously in the same time interval (due to either precedence constraints or resource availability). By forming consecutive closed intervals of maximal resource utilization, the algorithm ensures that no left-shift can be made either locally or globally. The following notation is used for a closed interval: a list of activities followed by its duration as a subscript. For example, a closed interval with activities A and B and duration

of 5 would appear as AB5. The symbol “||” is used to signify the end of all closed intervals of a schedule. As an example of a closed interval, consider scheduling activities {B,C,D}in Figure 2 (since there are three activities to be scheduled, the schedule belongs to the third stage.) Since all three activities can start at time zero, the resource is fully consumed during the first two time units. As a result, no other activity can start during (2≥t ≥0). Thus, BCD2 becomes a closed interval. At time t=2, activities B and C are completed. After time t=2, activity D continues to consume two resource units. However, since at t=2 we can start at least one more activity (E, or H, or F), no more intervals can be closed until the next stage (of adding an activity to the group {B, C, D}). This means that BCD2 is the last closed interval and the symbol “||” could be placed to its right. Thus, the notation for this schedule is BCD2||D. We use the term open-set to describe the set of activities which are active at the end of the closed intervals. The open-set is registered as the remaining activities on the right side of the “||” of a schedule. For example, at t=2 the open-set for BCD2||D is D. As an example, consider the next stage of BCD2||D, with {H}. Activity H starts at t=2 (while D is running) and the interval still cannot be closed (E, or F could still be added at t=2). So the new schedule is BCD2||DH and the open set is {D,H}. A more formal definition for the term open-set is: A set of activities, ongoing and scheduled directly after the last closed interval so that at least one more activity can be processed simultaneously directly after the closed intervals. In short, an open-set comprises the activities that follow the closed intervals. For each schedule, the algorithm categorizes activities into four groups: 1. Activities in scheduled closed intervals; 2. Activities scheduled in an open-set (more activities could be scheduled in parallel); 3. Immediate, feasible candidate activities (that could be added to a certain schedule);



4. Other activities (to be scheduled in future stages). Some activities can participate in more than one closed interval, and some activities may continue (protrude) into the open-set after the last closed interval. The algorithm starts at stage zero with a set of activities that has no predecessors. For example, in Figure 2 this set is composed of activities {B, C, D, E}. Stage 1 continues with the selection of each activity and a check as to which additional activities can be executed at the same time. For example, activity {B} in Figure 2 is selected first, and then the candidates for simultaneous execution (with {B}) are activities: C, D, E. While checking the feasibility of adding each activity, one should account for both precedence and resource constraints. While the proposed algorithm requires the precedence relations (typically given in a table) it does not depend on their graphic representation. As long as both AON and AOA are based on the same precedence relations– there should not be any difference in the algorithm process. Generally, resource constraints are very effective in limiting the number of feasible candidates. For example, consider the following three schedules (pairs of activities from Figure 2): {C, D} {D, E} {C, E}. During the third stage, the resource constraints limit the set of simultaneous start candidates for each of these three schedules to be only {B}. This means that each of these pairs (generated in the second stage), contribute only one partial schedule to the third stage. In closed intervals, the order of activities and the candidates are unimportant (e.g., {C, D} is equivalent to {D, C}). This order independence is extremely important for complexity reduction. For example, we can use BCD2||D schedule from last page, to eliminate the other five: {BDC2||D, CBD2||D, CDB2||D, DBC2||D, DCB2||D}. This characteristic reduces the number of partial schedules, that start at time zero at the 3rd stage, to three: {BCD2||D, BDE2DE1||D and BCE2|| E}.

While this order independence within closed intervals effectively reduces complexity, bounding drives complexity reduction even more aggressively by disposing of dominated schedules. Dominated schedules are those that have the same set of scheduled activities in all closed intervals as a schedule with a shorter time span (time is measured from the start to the end of the last closed interval). For example, suppose we wish to eliminate one of two schedules both of which contain the same activities {U,V, W, X, Y, Z}: (a) UVW2WX1XYZ3|| and (b) XV2XW2UYZ2Z1||. The length of the schedules is the sum of the closed intervals times which is the sum of the subscripts of each schedule. Since schedule (a) lasts 2+1+3=6, and schedule (b) lasts 2+2+2+1=7, the bounding is done by eliminating schedule (b). The last two factors that reduce the branching complexity, are the precedence and resource constraints. While the complexity reduction depends on the structure of precedence constraints and the resource availability level, in all of the benchmark cases we checked these factors had large effect on the number of feasible branches at each stage. To summarize, the proposed algorithm’s efficiency stems from the combination of utilizing the concept of closed intervals, bounding, and precedence and resources constraints. The algorithm can work on any number of activities but is trivial for one or two activities.

Outline of the Algorithm The algorithm advances along three hierarchical loops: (1) stages, (2) schedules, and (3) iterations. Stages: There are exactly J stages (J is the number of tasks) where each stage j enumerates the feasible, non-dominated, schedules of j tasks (developed from stage j-1, by a single activity addition. Schedules: The schedules at each stage are extensions of previous stage schedules. As discussed above, the algorithm utilizes several means to substantially reduce the growth in the number of schedules.



Figure 4. The computational structure of the proposed algorithm

Iterations: An iteration closes an interval of a given schedule. The iterations done on each new schedule are meant to close as many intervals as possible on this schedule. Since each iteration closes an interval, finishing an iteration means that at least one task in the open set is completed. Therefore, the open set of the next iteration has at least one less activity. So the maximal number of iterations cannot exceed the number of activities in the open set (reaching this number totally empties the open set). Figure 4 illustrates the structure of the proposed algorithm’s embedded loops. Since J is the upper bound for the number of iterations, schedules, and stages, and since an iteration may need J computations, O(J4) bounds the algorithm’s worst case complexity. However, our experience with practical cases yielded much lower growth in the number of schedules, especially in the number of iterations, which rarely exceeded three (even for very large problems). Each stage of the algorithm starts with the results of the previous stage. These results include all the partial schedules of the previous stage, and for each partial schedule: the closed intervals, the open-set, and a list of im-

mediate feasible candidate activities to add to each schedule. With this data from a particular schedule (of the previous stage), a new schedule is developed for each activity in the feasible candidate set. Closing intervals of a schedule within a stage may require several iterations (largest number of iterations must be equal to the number of activities in the open set.) Here is what happens to each schedule during a single stage: 1. The establishment of a schedule begins by removing an activity from the set of feasible immediate-successors of the previous stage schedule and adding it to the open-set of that schedule. 2. Next, for the open-set activities, the total resource requirement and slack per unit of time are calculated. 3. At this point, it is necessary to decide whether to close an interval or not. Closing an interval occurs only when no more feasible candidates can be started immediately after the last closed interval. If a feasible successor has been found, closure is not possible and the schedule processing is finished for the particular stage. However,



if no feasible successor can be found, an iteration procedure starts for closing an interval. The duration of the next closed interval is the time duration for which all activities in the open-set are ongoing. The first completion of an activity in the open-set marks the end of the new closed interval to be added to the closed intervals of the schedule. The duration of this closed interval is subtracted from the activities in the open-set. After each iteration, the feasible candidate set (that had been empty) is updated for determining whether to close another interval (empty candidate set) or not. Closing intervals may take several iterations until a feasible candidate activity (or more) is found. Having an immediate feasible candidate to be added to the open-set immediately completes the stage for the schedule under consideration. At the end of the stage, inferior schedules are found by comparison and bounded. This effectively limits the branching.

Nomenclature The following conventions signs and definitions are used in describing the model: 3 Duration of A. 2 Resource consumption of A. Activity A. ||t - A sign for closed interval and its duration t. {} - A set of activities or schedules. J = number of activities/stages. j = activity index. n = current stage (n=1,…,J). i = index (serial numbers) of partial schedules in stage n. m = index (serial numbers) of partial schedules in previous stage. In = number of schedules at the end of stage n after eliminating inferior and redundant partial schedules. kjr = resource type r consumption level of activity j. Kr = availability limit for resource type r∈R has.

Sn,i = ith partial schedule of the nth stage. This is a set of closed intervals and an open set. Lr(Sn,i) = the available resource of type r after the allocation for the open-set activities (per unit of time). C(Sn,i) = the closed intervals generated at schedule i of the nth stage. O(Sn,i) = the set of activities in the open-set at schedule i of the nth stage. CC(Sn,i) = an ordered set of all closed interval of schedule Sn,i. CID(Sn,i) = the duration of all closed interval of schedule Sn,i. d(O(Sn,i))= a set of durations of the activities in the open-set O(Sn,i) at iteration g of schedule i of the nth stage. Cmin = Min(d(O(Sn,i))) the least duration in the open-set. F(Sn,i) = a set of all feasible immediate candidate activities of schedule i of the nth stage. NF(Sn,i) = number of all feasible immediate candidate activities of schedule i of the nth stage. Bn,I = true/false indicator for bounding schedule i in the nth stage.

The Algorithm Schedules are numbered using two parameters: the first is the stage number (n); the second is the serial number of the schedule (i). To simplify explanations, we use m as the schedule index from the previous stage. Step 0: Construct the first immediate feasible candidate activity set F(S0,1) from all activities that have no precedence. Initiate accordingly the parameters I0=1, n=0, and m. Step 1: Set the current stage number n:=n+1. Step 2: Generate the schedules of stage n: LOOP: for m=1 to In-1 do (*for each previous stage schedule*). LOOP: for i=1 to NF(Sn-1,m) (*for each feasible candidate of a previous schedule)*). Step 2.1: Sn,i = Sn −1,m + j (generate (Sn,i) by adding activity j to previous schedule).



Step 2.2: F (Sn −1,m ) = F (Sn −1,m ) − j (Remove an activity j from a set of immediate feasible candidate activities of previous schedule). Step 2.3: Set the open group and calculate its parameters O(Sn,i)=O(Sn-1,m)+j. Step 2.3.1: For each resource r, calculate the resource requirements by the open-set acclivities and mark the resource slack Lr (Sn ,i ) = K r − ∑ kr , j . j ∈O

Step 2.4: LOOP for closing intervals: ≤ Lr (Sn ,i ) ∀r ∈ R, for at least one j ∈ F (Sn,i ) } (untiil no closing is possible)

Until

{

kr , j

Step2.4.5: Update the F(Sn,i). As a result of closing an interval, some activities might be completed and additional activities should be entered to the F(Sn,i). END-LOOP: {Step 2.4 LOOP for closing intervals}. END-LOOP: {for i=1 to NF(Sn-1,m); for each feasible candidate (of a previous schedule)}. END-LOOP: {for m=1 to In-1; for each previous stage schedule}. Step 3: Bounding at the end of a stage. Step 3a: When a partial schedule is identical to any previous generated schedule, its B(Sn,i)=Y which means it is bounded and cannot produce branches. Step 3b: For each schedule that has an empty open-set (and is not yet marked as bounded), seek the set of schedules that has an empty open-set and possesses the same set of completed activities. Mark the schedule with the smallest CID(Sn,i) with B(Sn,i) = N and otherwise by B(Sn,i) = Y. A schedule with B(Sn,i)=Y is bounded and will not produce branches in the next stage. Step 4: If O(Sn,i) and F(Sn,i) are empty, then stop (the best non-delay solution has been found). Otherwise Arrange In and m for the next stage and go to step 1 (to next stage).

* Note: If the above condition holds (for all resources of at least one candidate activity j), no closing is possible. However, having at least one violation of the condition for each activity enables the closing of the interval. Step 2.4.1: Close an interval for the open-set members (O(Sn,i)) with duration of Cmin Where C min = Min(d (O(Sn ,i ))) Step 2.4.2: Add the closed interval to the already existing set of closed intervals of this schedule: ILLUSTRATION OF THE CC(Sn,i):=CC(Sn,i)+C(Sn,i) PROPOSED ALGORITHM Step 2.4.3: Update the closed intervals The example presented below illustrates the duration: CID(Sn ,i ) = CID(Sn ,i ) + d (C (S n ,i )) Step 2.4.4: Update the duration of ac- algorithm’s methodology. The purpose of the tivities in the open-set by reducing example was to illustrate all the details of the the closed interval duration from algorithm logic on a compact model and enable the previous iteration. Note that at the reader to trace it. The algorithm has no least one activity is dropped off restrictions on the number of activities or the the open set. presentation scheme (AON, AOA, or a table). A small size network was deliberately chosen d (O(Sn ,i )) = d (O(Sn,i )) − C min ∀j ∈ O(Sn ,i ) to facilitate tracing the algorithm logic.



Figure 5. The Activities-on-nodes (AON) network

Figure 5 depicts a network with six activities (A through F) on nodes. Each activity lasts a certain number of days and requires a particular number of workers. The number of available workers (resource level) is 6 throughout the project. We summarize the proposed algorithm with Table 1. Table 1 concludes at stage 6 with a minimal makespan solution of 14. The Gantt chart for the best non-delay solution is given in Figure 6. (Interestingly, even for such a small problem, the MS-Project makespan for this problem is 15, worse than the proposed method.) Continuing the example, let us suppose that another resource, the number of vehicles is added. If enough vehicles are available at any time to carry out any combination of scheduled activities we can simply ignore the vehicles in our planning. However, if the additional resource renders some of the schedules infeasible, this resource availability must be taken into consideration. For the example, let us suppose that there are only two vehicles available, and that each activity requires one vehicle, except for E, which requires two. We see from Figure 6 that such a constraint would cause a one-day delay for activity E, which, in turn, would cause a one-day delay for activities D and F. Thus the whole project would be extended by one day.

Note that the example is a toy problem for illustration purposes only. It was kept small to allow elaborating on all of the steps of the algorithm. The addition of more activities at the end of the example would require opening its few last closed intervals and continuing the algorithm of building closed intervals until the last activity is scheduled. However, if more activities are added before the end of the example, the algorithm would have to re-run from the start.

THE QUALITY OF THE PROPOSED METHOD SOLUTIONS Many RCPSP heuristics yield non-delay schedules (Demeulemeester & Herroelen, 2002). The proposed algorithm enumerates all the branches/ possibilities of non-delay schedules and therefore considers them all, and chooses the best non-delay schedule. A non-delay schedule is one in which, at any given time, there is no possibility of starting the implementation of a new task that is not already scheduled. In a similar manner, a closed interval is one for which no other activity can be added due to resource and precedence constraints. Just as no activity could be added to a closed interval, no activity could be added to a group of several sequential closed


||AB

AB3||B

||AC

AC2||A

||BA

AB3||B

||BC

BC2||B

||CA

AC2||A

||CB

BC2||B

AB3||BC

AB3BC1||C

AB3BC1C1||

AC2||AB

AC2AB1||B

AC2AB1B3||

I

II

I

II

I

II

I

II

I

II

I

II

I

II

III

I

II

III

3

2

1

6

5

4

3

2

1

I

3

2

||C

I

2

||B

||A

I

1

1

0 (6)

3 (3)

5 (1)

0 (6)

3 (3)

6 (0)

3 (3)

6 (0)

2 (4)

5 (1)

3 (3)

6 (0)

3 (3)

5 (1)

2 (4)

5 (1)

3 (3)

5 (1)

3 (3)

3 (3)

2 (4)

Lr

Sn,i

g

I

Open Set Resource Cons. and (Slack)

Starting Schedule (for each Iteration) “||” is the end of the closed intervals of each schedule.

N

Iteration

Schedule Number

Stage Number

E

A

B

A

C

B

C

A,B

A,C

B,C

F(Sn,i)

Immediate Feasible Candidate Activities

3

3

1

1

1

1

2

2

2

2

2

2

3

3

2

2

3

3

C min

B3

AB1

C1

BC1

BC2

AC2

BC2

AB3

AC2

AB3

Generated Closed Interval

6

6

6

5

5

5

4

4

3

3

4

4

4

4

3

3

4

4

2

4

3

Makespan

6

6

3

5

5

4

2

2

2

2

2

2

3

3

2

2

3

3

CID(Sn,i)

CID Closed Intervals Duration

B

C

B, C

B

B

A

A

B

B

B

B

A

A

B

B

C

B

A

Open Set

Y

NA

NA

N

NA

NA

Y

NA

Y

NA

N

NA

Y

NA

N

NA

N

NA

N

N

N

Bn,i

Bound? Y=yes N=no N.A.


Table 1. A summary of the algorithm’s steps. The bounds are computed at the end of each stage.

continued on the following page


6

5

4

3

3

1

2

1

4

3

2

1

4

Schedule Number

Stage Number

Starting Schedule (for each Iteration) “||” is the end of the closed intervals of each schedule.

AC2||AE

AC2AE1||E

AC2AE1E2||

BC2||BA

BC2AB2||A

BC2AB2||AE

BC2AB2AE1||E

BC2AB2AE1E2||

AB3BC1C1||D

AB3BC1C1D4||

AB3BC1C1||E

AB3BC1C1E3||

AC2AE1E2||B

AC2AE1E2B4||

BC2AB2AE1E2||D

BC2AB2AE1E2D4||

AB3BC1C1D4||E

AB3BC1C1D4E3||

BC2AB2AE1E2D4||F

BC2AB2AE1E2D4F3||

Iteration

I

II

III

I

II

I

II

III

I

II

I

II

I

II

I

II

I

II

I

II

2 (4)

2 (4)

0 (6)

4 (2)

0 (6)

4 (2)

0 (6)

3 (3)

0 (6)

4 (2)

0 (6)

4 (2)

0 (6)

4 (2)

6 (0)

2 (4)

5 (1)

0 (6)

4 (2)

6 (0)

Open Set Resource Cons. and (Slack)

D

E

E

B

Immediate Feasible Candidate Activities

3

3

3

3

4

4

4

4

3

3

4

4

2

2

1

2

2

2

2

1

C min

F3

E3

D4

B4

E3

D4

E2

AE1

AB2

E2

AE1

Generated Closed Interval

14

14

12

12

11

11

9

9

8

8

9

9

7

7

7

5

5

5

5

5

Makespan

14

14

12

12

11

11

9

9

8

8

9

9

7

7

5

4

4

5

5

3

CID Closed Intervals Duration

F

E

A

A

E

Open Set

N

NA

Y

NA

N

NA

Y

NA

N

NA

N

NA

N

NA

NA

N

NA

N

NA

NA

Bound? Y=yes N=no N.A.


Table 1. Continued



Figure 6. Best non-delay schedule (schedule 6.1 in Table 1)

intervals. Therefore, a continuous sequence of such intervals ensures a non-delay schedule. The proposed algorithm is based on the principle of sequentially filling and closing intervals until the final solution is a sequence of closed intervals including all the activities. Therefore, the proposed solution must be a non-delay schedule. However, this does not ensure certain quality of the solution, and therefore compares the results with cases from the literature.

Comparison to Some Results from the Literature The proposed method was applied to several examples reported in the literature. We compare the best makespan achieved by each method versus the method presented here and with respect to the minimal makespan that could have been achieved. Table 2 shows that the proposed method gave the optimal solution in six out of nine cases and a near-optimal solution in the other cases. This comparison is somewhat biased against the proposed method since projects 2, 4, and 9 in Table 2 are deliberate examples where the optimal solution includes a delay. For example, Demeulemeester and Herroelen (2002, p. 165) showed that deliberate delays in active and semi-active schedules yield an optimal makespan of 7, whereas a non-delay makespan was 9. However, the proposed algorithm found a better non-delay solution with a makespan of 8. Note that among the non-delay

procedures, the method presented will always get the best results.

COMPLEXITY OF THE PROPOSED METHOD There is an immense gap between the actual small computational requirements that we experienced empirically, and the huge worst-case complexity. None of the projects that we analyzed including those presented above required more than 10 milliseconds of CPU on a Pentium 3.00 Ghz processor. This clearly would not have been the case for combinatorial complexity. We attribute this to the following reasons: Closed Intervals Contribution to Complexity Reduction: Since the order within a closed interval does not matter, a closed interval eliminates the need to enumerate the different order of the tasks within itself. Thus, if there are n tasks within a closed interval, the total number of generated schedules is reduced by (n!). If resource constraints are very tight, n is typically small (in Table 1, n is usually 2), but there will be many closed intervals as a result. A schedule with k closed intervals reduces complexity by

K

∏ (n !) . i =1

i

Bounding Contribution to Complexity Reduction: Bounding is implemented to eliminate inferior and redundant schedules. The bounding procedure only treats schedules with closed intervals and no open sets at the end of every stage. Any two of these schedules are compared



Table 2. Method comparison (with reference to Demeulemeester & Herroelen, 2002; Sprecher et al., 1995, Globerson & Shtub, 2004; Microsoft, 2000; Ingalls & Morrice, 2004; Ahsan & Tsao, 2003; Demeulemeester & De-Reyck, 2003) Project Number

Makespan Minimal

Comparison to Other Methods

Cohen et.al

Method

Source

Makespan

1

15

15

Optimal

15

Demeulemester and Herrolen (D&H) (2002) p. 207

2

7

8

Active

7

Semi-Active

7

Demeulemeester and Herroelen (2002, p. 265)

Non-delay

9

Serial Scheduling Scheme

8

Parallel Scheduling Scheme

8

Backwards Parallel Scheduling Scheme

8

Bidirectional Planning

7

MS project

22

As Late as Possible

22

Active

5

3

22

22

Globerson and Shtub (2004) p. 224

4

5

6

Non-delay

6

5

12

12

Ms Project

12

MS Project Manual (2000)

6

35

35

MS Project Resource leveling

35

MS Project Manual (2000)

7

34

34

Qualitative Simulation Graphs

34

Ingalls and Morrice (2004)

8

17

17

Composite multi-criteria search technique

17

Ahsan and Tsao (2003).

9

20

21

Optimal Branch & Bound (with delays)

20

Demeulemeester, De-Reyck, and Herroelen (2000)

in order to find schedules that contain the same set of tasks. If a pair of these schedules with the same tasks is found, the schedule with the higher finish time is eliminated (since it is inferior). Constraints Contribution to Complexity Reduction: The worst case for complexity is when there are no constraints, and any combination of tasks can be scheduled simultaneously. However the presence of constraints immensely reduces the complexity. For example, if lax constraints allow simultaneous processing of any 5 activities out of 10 available activities, the number of possibilities

Sprecher et al. (1995)

is huge compared with tight constraints that allow only 2 simultaneous activities of the same 10. In general, it is difficult to quantify the effect of resource constraints on the complexity. However, it is clear that the combination of precedence constraints and resource constraints, drastically reduces the number of possible task assignments in each moment, and therefore it is greatly reduce the complexity. The memory requirements of the algorithm are modest since the computations of current stage always relate to the results of the previous stage. So at any given time the algorithm



requires remembering only the schedules of the previous stages that that were not culled by bounding. The bounding and the constraints discussed above considerably limit the number of schedules required for further computations.

CONCLUSION This paper presents an algorithm that efficiently enumerates all the relevant non-delay schedules and gives a near-optimal (and in many cases, optimal) solution to RCPSPs. A model together with a simplified but detailed example and comparison are presented. Any project having limited resources which affect the project’s duration pose a RCPSP. In contrast with many other solution techniques, the progression and results of the proposed algorithm could be easily understood by any project manager and could be a basis for his/her plans and changes. While a large variety of projects can be characterized as RCPSPs, they are especially important for high scale projects management such as software development, generation plants building, design, development and building of nuclear submarines., etc. (Pinedo & Chao, 1999). However, in such projects the number of activities is too large for exact methods, and the proposed heuristic offers a good practical solution. The algorithm was compared with other heuristics and with the optimal solutions of a set of RCPSP problems from the literature and demonstrated its ability to find near- optimal (and optimal) solutions. It often happens that a project manager who negotiated for resources in his project cannot afford using a delay approach in scheduling (delays may not be acceptable in some organizational cultures). In such cases, the proposed technique yields the best possible schedule.

ACKNOWLEDGMENT The authors would like to thank the Editor-in Chief of the journal, Professor John Wang, and the anonymous reviewers for their valuable

comments and suggestions that improved the article significantly.

REFERENCES Agin, N. (1966). Optimum seeking with branch and bound. Management Science, 13(4), 176–185. doi:10.1287/mnsc.13.4.B176 Ahsan, M. K., & Tsao, D. (2003). A heuristic search algorithm for solving resource-constrained project scheduling problems. Asia-Pacific Journal of Operational Research, 20(2), 143–160. Alvarez-Valdes, R., & Tamarit, J. M. (1989). Heuristic algorithms for resource constrained project scheduling. In Slowinsky, R., & Weglarz, J. (Eds.), Advances in project scheduling. Amsterdam, The Netherlands: Elsevier. Baker, K. R. (1974). Introduction to sequencing and scheduling. New York, NY: John Wiley & Sons. Blazewicz, J., Lenstra, J. K., & Rinnooy, K. (1983). Scheduling projects to resource constraints: Classification and complexity. Discrete Applied Mathematics, 5, 11–24. doi:10.1016/0166-218X(83)90012-4 Brooks, G. H., & White, C. R. (1965). An algorithm for finding optimal or near optimal solutions to the production scheduling problem. Journal of Industrial Engineering, 1(1), 34–40. Cho, J. H., & Kim, Y. D. (1997). A simulated annealing algorithm for resource constrained project scheduling problems. The Journal of the Operational Research Society, 48(7), 736–744. Demeulemeester, E., De-Reyck, B., & Herroelen, W. S. (2000). The discrete time/resource tradeoff problem in project networks: A branch and bound approach. IIE Transactions, 32, 1059–1069. doi:10.1080/07408170008967461 Demeulemeester, E. D., & Herroelen, W. S. (2002). Project scheduling: A research handbook. Boston, MA: Kluwer Academic. Globerson, S., & Shtub, A. (2004). Project management: Planning, executing and control. Tel-Aviv, Israel: Dyunon. Herroelen, W. S., & Leus, R. (2005). Identification and illumination of popular misconceptions about project scheduling and time buffering in a resource-constrained environment. The Journal of the Operational Research Society, 56(1), 102–109. doi:10.1057/palgrave.jors.2601813



Ingalls, R. G., & Morrice, D. J. (2004). PERT scheduling with resource constraints using qualitative simulation graphs. Project Management Journal, 35(3), 5–14. Kelley, J. E. Jr. (1963). Critical path methods: Resources planning and scheduling. In Muth, J. F., & Thompson, G. L. (Eds.), Industrial scheduling (pp. 347–365). Upper Saddle River, NJ: Prentice Hall. Klein, R. (2000). Scheduling of resource constrained projects. Boston, MA: Kluwer Academic. Kolisch, R. (1996). Series of parallel resourceconstrained project scheduling methods revisited: Theory and computation. European Journal of Operational Research, 90, 320–333. doi:10.1016/03772217(95)00357-6 Kolisch, R., & Hartman, S. (1999). Heuristic algorithms for solving the resource constrained project scheduling problem: Classification and computational analysis. In Weglarz, J. (Ed.), Handbook of recent advances in project scheduling (pp. 147–178). Dordrecht, The Netherlands: Kluwer Academic. Kolisch, R., Sprecher, A., & Drexl, A. (1995). Characterization and generation of a general class of resource-constrained project scheduling problems. Management Science, 41, 1693–1703. doi:10.1287/ mnsc.41.10.1693 Lee, J. K., & Kim, Y. D. (1996). Search heuristics for resource constrained project scheduling. The Journal of the Operational Research Society, 47(5), 678–689. Li, R. Y., & Willis, J. (1992). An iterative scheduling technique for resource-constrained project scheduling. European Journal of Operational Research, 56, 370–379. doi:10.1016/0377-2217(92)90320-9 Microsoft. (2000). MS Project 2000 manual. Redmond, WA: Microsoft. Mingozzi, A., Maniezzo, V., Ricciardelli, S., & Bianco, L. (1998). An exact algorithm for resource constrained projects scheduling problem based on a new mathematical formulation. Management Science, 44(5), 714–729. doi:10.1287/mnsc.44.5.714

Ozdamar, L., & Ulusoy, G. (1996a). A note on an iterative forward/backward scheduling technique with reference to a procedure by Li and Willis. European Journal of Operational Research, 89(2), 400–407. doi:10.1016/0377-2217(94)00272-X Ozdamar, L., & Ulusoy, G. (1996b). An iterative local constraint based analysis for solving the resource constrained project scheduling problem. Journal of Operations Management, 14(3), 193–208. doi:10.1016/0272-6963(95)00015-1 Pinedo, M., & Chao, X. (1999). Operations scheduling and applications in manufacturing, algorithms and systems (2nd ed.). Upper Saddle River, NJ: Prentice Hall. Pinson, E., Prince, C., & Rullier, F. (1994). Using tabu search for solving the resource constrained project scheduling problem. In Proceedings of the Fourth International Workshop on Project Management and Scheduling. Pritsker, A. A. B., Watters, L. J., & Wolfe, P. M. (1969). Multi project scheduling with limited resources: A zero-one programming approach. Management Science, 16(1), 93–108. doi:10.1287/mnsc.16.1.93 Sprecher, A. (2002). Network decomposition techniques for resource-constrained project scheduling. The Journal of the Operational Research Society, 53(4), 405–414. doi:10.1057/palgrave.jors.2601308 Sprecher, A., Kolish, R., & Drexl, A. (1995). Semiactive, active, and non-delay schedules for the resource constrained project scheduling problem. European Journal of Operational Research, 80(1), 94–102. doi:10.1016/0377-2217(93)E0294-8 Tavares, V. (1999). Advanced models in project management. Boston, MA: Kluwer Academic. Tormos, P., & Lova, A. (2001). A competitive heuristic solution technique for resource constrained project scheduling. Annals of Operations Research, 102(1), 65–81. doi:10.1023/A:1010997814183 Zhu, G., Bard, J. F., & Yu, G. (2005). Disruption management for resource-constrained project scheduling. The Journal of the Operational Research Society, 56(4), 365–381. doi:10.1057/palgrave.jors.2601860



Yuval Cohen is the head of the Industrial Engineering program at the Open University of Israel. His areas of specialty are production planning, project management, industrial learning, operations and logistics management. He has published many papers in these areas and a book on project management. Dr. Cohen served several years as a senior operations planner at FedEx Ground (USA) and received several awards for his contributions to the hub and terminal network planning. He received his PhD from the University of Pittsburgh (USA), his MSc from the Technion ― Israel Institute of Technology, and BSc from Ben-Gurion University. Dr. Cohen is a Fellow of the Institute of Industrial Engineers (IIE), and a full member of the Institute for Operations Research and Management Sciences (INFORMS). Arik Sadeh is a senior lecturer at Holon institute of Technology in Israel. Dr. Sadeh earned his PhD degree at Texas A&M University in 1986. He worked for an American high tech solar energy company in financial and business planning of huge scale projects. He held a research position in the Department of Statistics and Operations Research of the Agricultural Research Organization (ARO). Since 1995, Dr. Sadeh has been a senior member in the academic staff of the Management of Technology Department at the Holon Institute of Technology. He conducts research projects in the disciplines of risk, project and operations management, ethics and e commerce, economics, and finance. Ofer Zwikael is an Associate Professor and a deputy head of school at the Australian National University. Dr. Zwikael is the author of 2 books and more than 90 scholarly peer reviewed papers that have appeared in a variety of academic journals and conference proceedings, including top journals, such as the Journal of Operations Management and the British Journal of Management. He is currently on the Editorial Board of three journals. Dr Zwikael is an accredited Project Management Professional (PMP®) and has served on the Executive Board of three Project Management Institute chapters. He is regularly invited to deliver workshops, keynote presentations and seminars around the world. Dr Zwikael holds a bachelor degree with distinction in Industrial Engineering, MBA and PhD (in project management). Dr. Zwikael is the recipient of the International Project Management Association's Outstanding Research Contributions Award.


Finding the Shortest Non-Delay Schedule for a

Finding the Shortest Non-Delay Schedule for a

Suggest Documents

application genetics algorithm for finding shortest path

A Nearly Optimal Algorithm for Finding L1 Shortest Paths among ...

A Fast Algorithm Finding the Shortest Reset Words

Finding Shortest Paths between Graph Colourings

Reliable shortest path finding in stochastic

Finding Small Administrative Lengths for Shortest ... - Semantic Scholar

Non-iterative algorithm for finding shortest route ...

A genetic algorithm for finding the k shortest paths in a network

A Matlab program for finding shortest paths in the network: Application ...

Finding the Shortest Path with Vertex Constraint over Large ...www.researchgate.net › publication › fulltext › Finding-th

A New Shortest Path Finding Algorithm for a Maze ... - CS Journals

Finding Shortest Paths in Large Network Systems - CiteSeerX

Finding Reliable Shortest Path in Stochastic Time ... - ScienceDirect.com

Finding Reliable Shortest Path in Stochastic Time-dependent Network

Multi-Sentence Compression: Finding Shortest Paths in Word Graphs

Finding Shortest Paths in Large Network Systems - CiteSeerX

Finding Top-k Shortest Path Distance Changes in an ... - CiteSeerX

finding shortest gentle paths - Department of Computer Science and ...

Finding Risk-Averse Shortest Path with Time-dependent Stochastic ...

Finding Shortest Paths on Surfaces by Fast Global ... - Semantic Scholar

Reliable shortest path finding in stochastic networks with spatial

THE SHORTEST PATH PROBLEM FOR THE ...

PHA: Finding the Shortest Path with A in An Unknown Physical

Finding Reliable Shortest Path in Stochastic Time-dependent ...www.researchgate.net › publication › fulltext › Finding-R

Finding the Shortest Non-Delay Schedule for a