Integrated Project Scheduling and Staff Assignment with Controllable Processing Times

This paper addresses a decision problem related to simultaneously scheduling the tasks in a project and assigning the staff to these tasks, taking into account that a task can be performed only by employees with certain skills, and that the length of each task depends on the number of employees assigned. This type of problems usually appears in service companies, where both tasks scheduling and staff assignment are closely related. An integer programming model for the problem is proposed, together with some extensions to cope with different situations. Additionally, the advantages of the controllable processing times approach are compared with the fixed processing times. Due to the complexity of the integrated model, a simple GRASP algorithm is implemented in order to obtain good, approximate solutions in short computation times.


Introduction
The lead time required to carry out a project-project makespan-has turned to be one of the main sources of competitive advantage for companies (see, e.g., [1,2]). Since, in many cases, the processing times of the tasks that compose a project depend on the resources allocated to the task (see, e.g., [3]), it is clear that the project lead time depends both on the scheduling of the tasks and on the allocation of staff to these tasks. Regarding task scheduling, it encompasses the sequence to be followed by each task over time, and it is usually regarded as an important aspect of the industrial organization [4] and production [5]. On the other hand, staff assignment is essential in a project [6] and it can be defined as the allocation of company workers to different tasks. Traditionally, staff assignment is included within the manpower planning as one of its steps. Thus, several authors [7][8][9][10] have considered the following structure: (1) planning; (2) scheduling; (3) allocation. In staff assignment, worker's satisfaction tends to be maximized whereas makespan and production costs are often minimized in task scheduling. To execute a task, it is essential that a particular employee is available at that time; otherwise the realization of such task should be postponed until the employee becomes available and, consequently, staff assignment directly influences task schedule. Due to the importance of the scheduling and the assignment in a project environment and since both are very related, it is critical to address both problems in an integrated manner. Furthermore, the majority of scheduling problems in the literature consider fixed processing times [11] and most of the rest assume that processing times depend linearly on the amount of resources assigned [12]. As lead times strongly depend on the processing times of the task, and since the processing time of a task depends on the number of employees assigned to this task, in this paper we explicitly take into account this relationship.
In this paper, an integration of project scheduling and staff assignment (PSSA) problem with controllable processing times (CPT) is presented using renewable resources and nonpreemptive tasks. Minimization of the makespan has been chosen as the objective function since delays can lead to an increase in costs and even to the loss of customers. This problem can be placed within the project management process. According to Demeulemeester and Herroelen [13], the project life cycle is as follows. The Scientific World Journal Table 1: Names for the integrated problem.

Reference
Name used for the integrated problem Bellenguez and Néron [14], Bellenguez-Morineau and Né ron [15] Multiskill project scheduling problem Brucker and Knust [16], Drezet and Billaut [17] Project scheduling with labor constraints Vairaktarakis [18] Resource-constrained job assignment problem Valls et al. [19] Skilled workforce project scheduling Corominas et al. [20] Problem of assigning and scheduling a set of tasks to a set of workers Drexl [21] Scheduling of project networks by job assignment Dodin and Elimam [22] Problem of audit staff scheduling Heimerl and Kolisch [23], Kolisch and Heimerl [24], Gutjahr et al. [25], and Gutjahr et al. [26] Project scheduling and staffing Wu and Sun [27] Project scheduling and staff assignment (i) Concept Phase. There is a need of a customer to perform a project. This need is transmitted to the company.
(ii) Definition Phase. First, the goal of the project is defined. Next, the work content is defined and, finally, a project strategy is elaborated to achieve the goal.
(iii) Planning Phase. The project is divided into tasks. Then, their processing times are estimated and both the resources requirements and the precedence relationships between tasks are identified.
(iv) Scheduling Phase. Both task scheduling and the amount of resources in each period of time are defined in this phase (v) Control Phase. In this phase it is controlled that the project is implemented following the aspects defined in the planning and scheduling phases.
(vi) Termination Phase. This phase corresponds to the delivery of the results of the project.
Note that between the scheduling phase (where the amount of resources is known) and the control phase there must be an assignment of resources to the tasks if the resources are not identical. For these cases, an additional phase is therefore needed. This phase-named "resources assignment phase"-must be placed between the scheduling phase and the control phase. Alternatively, integration between the scheduling and the resources assignment phases can be done. The latter is the adopted approach in this paper, which is organized as follows: a state of the art and a description of the problem are shown in Section 2. An extended explanation of the CPT is also presented, while the problem statement and a formulation of the integer linear programming model are shown in Section 3. Additionally this integer linear programming model is compared with a multimode formulation. In Section 4, we define a simple GRASP heuristic algorithm for the problem. Section 5 contains computational experiments based on a test bed. Besides, a comparison between the model with and without CPT is shown there. Lastly, conclusions are described in Section 6.

Literature Review
The model presented in this paper includes two decision problems: task scheduling and staff assignment. Task scheduling is traditionally denoted in the literature as project scheduling problem (PSP). Furthermore, if limitations regarding the number of resources per activity are assumed, it is named resource-constraint project scheduling problem (RCPSP). This problem has been extensively studied in the literature, and recent reviews can be found in Węglarz et al. [32] and Hartmann and Briskorn [33]. Staff assignment is a type of assignment decision problem that has also been extensively addressed [34]. Nevertheless, the integration between project scheduling and staff assignment has not been so comprehensively studied, and hence there is still no consensus about the name of this joint problem (see in Table 1 different names that have been used to denote the problem). In our work, we consider the name "project scheduling and staff assignment" as denomination for the problem.
Our problem is related to several contributions in the literature, which are summarized in Table 2. Bassett [29] presents a model of project scheduling and staff assignment considering time windows for the completion times of the tasks. Vairaktarakis [18] adds precedence relationships to the integrated problem. However, no time units are used in the linear programming model (the order of the tasks defines the schedule of the project). Time units are included in a similar problem by Bellenguez and Néron [14] and Bellenguez-Morineau and Néron [15] where some lower bounds are calculated in the former reference, while in the latter the authors implement a branch and bound algorithm. External and internal resources constraints are considered by Kolisch and Heimerl [24]. Wu and Sun [27] present the integrated problem proposing a nonlinear model, which is solved by a genetic algorithm. Although learning effect (i.e., the longer an employee works on a task, the greater his/her efficiency is) is considered in the model, neither precedence relationships nor skill constraints are used in their model. Gutjahr et al. [26] consider portfolio selection and skills in the integrated problem with learning effect but with precedence relationship which are included by Gutjahr et al. [25]. Precedence relationships are also included by Corominas et al. [20] in an The Scientific World Journal 3 Processing times are preprocessed depending on the number of assigned employees or on the level of skills of the assigned employee(s) and then they are introduced in the model as data.
2 An integer programming model is solved, although the way to do it is not explained.

4
The Scientific World Journal integrated problem, similar to the problem of Wu and Sun [27], also with learning effect. Drezet and Billaut [17] propose a linear programming model for a project scheduling and staff assignment problem. However, they do not consider learning effects in the model and include move constraints (i.e., the number of assignment movements of the employees from one nonfinished task to another is bounded). Moreover, the number of employees assigned to each task at each period of time is set between a minimum and a maximum depending on the level of skills of the workers. However, the processing times of the tasks are assumed to be fixed and not depending on the number of employees assigned. Since no solutions can be found for medium-sized instances of the problem, a tabu search algorithm was implemented using a greedy algorithm as initial solution.
A common feature in all the aforementioned works is that none of them include variable processing times. Regarding CPT, Hachicha et al. [30] propose a staff assignment model considering multiskilled employees, preference of the employees for some tasks, and skill-based processing times (i.e., the processing times of the tasks depend on the skills of the employee). Nevertheless, they are preprocessed before solving the model, which means that the processing times do not change during the planning horizon. More specifically, processing times are first calculated depending on the skills of each employee and then introduced in the model as data. Heimerl and Kolisch [31] analyze a staff assignment problem without scheduling considering learning effect on the employees, so the processing times are now variables of the problem as they depend on the experience of the staff. In order to solve this problem, a nonlinear model is implemented. Hachicha et al. [30] and Heimerl and Kolisch [31] use CPT in their models, although none of them solve the integrated problem (only the staff assignment problem). Variable processing times in a scheduling problem can be found in Alfares and Bailey [28]. They use a linear programming model to schedule the task of a project and to assign the number of employees to each task; that is, the variables of the problem are the starting times of each task, the processing times, and the number of employees per period. Regarding the processing times, they are chosen to minimize the costs, but they do not depend on any variable. Moreover, staff assignment for each employee is not considered there.
CPT in an integrated PSSA problem are considered in Drexl [21], Dodin and Elimam [22] with the objective of costs minimization. However, in their models, the processing times depend on the skills of the employee assigned (and consequently are introduced in the model as data), but not on the amount of resources allocated; that is, processing times are defined by a matrix of two dimensions where the rows are the processing times of the tasks and the columns the employees. In Valls et al. [19], each task has to be performed by a single employee and its processing time increases or decreases depending on the efficiency of the employee. Nonpreemptive tasks with release times and due dates are taken into account, as well as precedence relations with time lags. No programming model is implemented, but a hybrid genetic algorithm is developed to solve the cost minimization problem. This contribution is the one most related to our problem, since the authors implement an integrated PSSA with CPT. However, in our paper, a linear programming model is considered to minimize the makespan of the project where the processing times of the tasks depend piecewise linearly on the number of employees assigned instead of the efficiency level of the employee and multiple assignments to each task are also allowed as well, while in Valls et al. [19] each task must be implemented by a single employee. To the best of our knowledge, the proposed model has not been analyzed before.

Model Proposal for the Integrated PSSA Problem
3.1. Problem Statement. This paper presents a PSSA problem in which a company is responsible for the implementation of a project consisting of tasks (with task = 1, . . . , ) with (known) precedence relations between tasks (i.e., some tasks should be finished before carrying out others). The order of execution of each task has to be decided to minimize the corresponding objective function. Each task must be performed by some workers from total of employees (employee = 1, . . . , ) with certain skills in each period ( = 1, . . . , ) of the planning horizon .
It is assumed that each task has a release time , so it must always start after this time. Furthermore, once a task starts, it runs continuously until its end (nonpreemptive approach). One employee can be assigned to a task if the employee possesses the required skills for the task. We assume that there is an optimal number of employees, , to be assigned to each task, although overcoverage and undercoverage of employees are allowed by the model. Under-and overcoverage would lead to different values of the efficiency of the employees and, consequently, to different processing times of the tasks.

Controllable Processing Times (CPT).
In this paper, we assume that processing times depend on the resources (or employees, as we would use both terms as equivalent in this paper) assigned. Such type of processing times has been studied in the literature as a function of the resources allocated and of the experience of the workers (level of skills). The relationship between time and amount of resources has been mainly analysed under two different approaches, namely, linear and convex (see the review by [12]). In the linear approach (see, e.g., [35]), a linear relationship between the processing times of a task and the resources allocated to this task is assumed. Denoting as the processing time of task and as the number of resources allocated to this task, this relationship can be expressed as = − ⋅ , with and constants. However, this approach is not well suited to many realistic situations, since according to Belbin [36], there must be an optimal number of employees to be assigned to task in order to achieve maximum workers' The Scientific World Journal efficiency (point [ , ]). Therefore, it is easy to see that the linear approach is not flexible to this concept, at least for values to each side of the efficiency level since the efficiency point of worker must always be in an extreme of the line (see, e.g., Figure 2(a), where the efficiency point is placed for / resources).
In the convex approach it is assumed that there is an inverse relationship between processing times and employees (see, e.g., [37]), where and (normally denoted workload of the task ) are constants: For = 1, the number of resources and the processing times are inversely proportional (e.g., doubling the employees would cut the processing time by half and vice versa; see the red line of Figure 1). The convex relationship is closer to real life than the linear and it has been used for many actual government and industrial projects [38], distributed communication network, time-sharing computing system, and chemical plant or commercial construction projects [39]. Nevertheless, its nonlinearity would preclude modeling the problem using linear programming. Thus, in this paper a piecewise linear relationship to represent the relationship between processing times and amount of resources assigned to the task is proposed. The relationship is shown in (2), being the slope of each section for a task in the piecewise linear relationship and the number of employees fulfilled of that task in each section, where section has a length ( ). This piecewise linear relationship can be adjusted to the convex relationship (with = 1) as shown in the blue line of Figure 1. This relationship is over the convex relationship representing a safer configuration of processing times and amount of resources: The superscript for processing times, , and for the amount of resources, , denotes that they correspond to point .
According to Lanigan [40], the convex relationships between the processing time of a task and the number of employees assigned do not entirely match the reality, and there shall be a penalty due to assigning different numbers of employees. On the one hand, if > , then a penalty for communication exists. In contrast (see, e.g., [41,42]), if < then there is a penalty for lack of specialization [43]. Hence, each feasible point different than the optimum ( , ) must be placed over the convex curve; otherwise many optima would exist and there would be no penalties for under-and overcoverage. The feasible area formed by these points is represented by the light red area in Figure 2(a) (this feasible area is also taken into account by [44,45]). Moreover, it shall be considered that the processing time of a task decreases when the number of employees increases; otherwise it would make no sense to assign more employees to the tasks. Thus, the feasible area can be reduced by considering that the processing time of a task cannot increase when the number of employees increases (Figure 2(b)). In this way, the feasible relationships between both aspects must be in this area. Therefore, we propose using a piecewise linear relationship with a maximum and minimum possible number of workers on each task. Depending on the maximum and minimum possible number of workers, the slopes of the lines must be different to avoid that both lines are under the convex curve (i.e., in the infeasible region) in any point. The directions of the slope of the piecewise relationships are placed in the feasible region and shown in Figure 2(c). By doing so, linear programming can be used to model and solve the problem. Furthermore, the piecewise relationship is on the safe side with respect to the convex relation, since the piecewise relationship is always over the convex relation.
To define the slopes of the lines, we propose introducing the parameters and . The higher these parameters are, the bigger the penalties for under-and overassignment of employees with respect to the optimal value, and consequently the closer the problem to the PSSA with fixed processing times (FPT). In the most extreme case, both problems are the same. The piecewise linear relation left and right of the optimum can be written as follows (see Figure 2(d)): Analogously, let us now consider − as ℎ + the undercoverage of task and − as the overcoverage of task , ℎ − :

Proposed Integer Linear Programming Model.
In the previous section, we have presented a mechanism for formulating a realistic relationship between the processing times of the task and the number of employees assigned. Furthermore, this relationship can be embedded into a piecewise linear function; therefore a linear programming model can be formulated for the PSSA. In this section, a formal description of this model is given. : optimal number of employees of task . : processing time of task for the optimal number employees .
The Scientific World Journal 7 : maximum allowed undercoverage for task .
: maximum allowed overcoverage for task . , : constants related to the slopes of the lines defining the processing times. max : project makespan. ℎ : auxiliary variable. It is used to enforce that the constraint set (18) is satisfied if is zero since the auxiliary variable takes the value of the over-or undercoverage.

Extension 1:
Limitation of Moves. The model presented above allows moving the staff from a task to another. These moves can be detrimental for the service company since they may involve setup and learning times as well as instability in the team composition that performs each task. This limitation of moves can be easily incorporated in the model adding the following two constraints: where yields 1 if the employee is assigned to the task , 0 otherwise. Constraints (29) and (30) force that an employee have to be assigned to the task during the whole duration of the task when is equal to 1.
is introduced to define with 1 the sections with = , 0 otherwise (constraint (35)). Finally, constraint (32) delimits the upper value of the variable and the constraints (37)-(38) establish = 1 in each section preceding the section, where = 1, = 0 otherwise. Thereby, any piecewise linear relationship could be considered in the model by means of these constraints. To adjust this relationship to the convex relationship with = 1, it is necessary only define the parameter replacing the term ( ) by / in (2) Thus, the PSSA-FPT model consists of the constraint sets (6)-(12), (18), and (21)-(28), where the above variable is now a data of the problem. Obviously, the PSSA-CPT problem is harder than the PSSA-FPT since it has more variables and constraints. It will be analyzed again in the computational results.

Formulation of the Model Using Discrete Time/Resource Trade-Off Problem (DTRTP) Approach with Staff Assignment.
The model presented in this paper could be also modeled using a DTRTP approach adding the staff assignment and the release times constraints. However, the results found by this approach were considerably worse in computational time and in average relative percentage deviation. When both models were compared for each instance presented in Section 5.1 (several instances are shown in Table 3), only 363 optimal solutions were found using the DTRTP approach compared to the 567 of the proposed model and the computational time by the DTRTP approach presented a deviation of 287.1% over our proposed model (the deviation runtime is calculated considering only the instances which were optimal solutions found for both models; the amount of these instances is presented in the column of Table 3 denoted by "Both optimum") as well, justifying the PSSA-CPT model proposed here.
The Scientific World Journal 9

Complexity of the Problem.
The PSSA can be reduced to the identical parallel machine problem with two machines ( 2 | prec, 1 ≤ ≤ 2, max according to Graham et al. [46]), when = 2, = = 1, and = = = 0 are considered. As this problem is NP-hard [47] and our problem is a generalization of it, the PSSA is NP-hard.
On the other hand, the constraint sets (6)-(23) approximately form a total of 9 ⋅ + 8 ⋅ ⋅ + ⋅ + ⋅ ⋅ + ⋅ /2 constraints. Regarding the variables, there are 6 ⋅ + 3 ⋅ ⋅ + ⋅ ⋅ in the model, where 2 ⋅ ⋅ + ⋅ ⋅ are binary (i.e., , , and ). The number of constraints and variables is calculated in Table 4 for some instances of the test beds presented in Section 5.1. Since the PSSA with CPT is an NP-hard problem and since the number of constraints and variables for medium-large size of the problem is very high, exact solvers for integer programming problems have difficulties to find feasible and optimal solutions in such instances and therefore approximate algorithms have to be implemented. In the next section, a simple GRASP algorithm is presented to get feasible solutions in lower computational times.

A Simple GRASP Heuristic Algorithm
Given the complexity of the problem, a greedy randomized adaptive search procedure (GRASP) is presented in this section to solve the PSSA problem with CPT. GRASP was first introduced by Feo and Resende [48] and it has been widely applied to several combinatorial optimization problems. A review of the application fields of this algorithm is done in Festa and Resende [49]. The algorithm consists of two phases: first a constructive phase is implemented, and then a local search phase is made to find better solutions in the neighborhood. The constructive phase is usually employed to find a feasible solution for the problem, while the local search phase is performed to improve the solution found in the constructive phase. Both phases are repeated until the stopping criterion is reached (see Procedure 1).
In our problem, fixed processing times are considered during the constructive phase. In the local search phase, the task schedule is fixed and more employees are gradually assigned to each task in order to decrease the processing times and thus possibly improving the makespan of the project. In summary, a project scheduling problem is solved in the constructive phase, a CPT problem in the local search phase, while the staff assignment problem is treated in both phases (see Figure 3). In the next subsections the phases are explained in detail.

Constructive Phase.
The constructive phase consists in the successive allocation of employees and starting times to tasks. The goal is to assign the tasks as early as possible until all tasks are scheduled. In this phase, both the processing times and the number of assigned employees are kept fixed. The number of employees allocated to each task ( ) is randomly assigned within the upper and lower limits. The processing times of each task are calculated for the soobtained number of employees using the expressions shown in Section 3. With respect to the task to be chosen at each step, a restricted candidate list (RCL) is defined based on the tasks' precedence relations. According to these relations, the tasks are classified into sets: set 1 corresponds to tasks without predecessors, set 2 is tasks which only have predecessors of set , and, in general, set contains tasks with predecessors in sets −1 , −2 , . . . , 1 . The tasks are iteratively inserted in the schedule according to the following procedure. First, the RCL contains all tasks in set 1 . A task is randomly chosen from the RCL to be placed in the schedule. The process is repeated until the RCL is empty. Then, the tasks of set 2 are moved to. The same procedure is carried out until each task is introduced in the schedule.
Once a task is chosen from the RCL, it has to be placed into the schedule. To do this, the earliest possible start time for the task is calculated. Next, the starting time of the task is fixed to this earliest time and employees (from those having the required skills for the task) are assigned until the  number of employees, , is reached. Employees are assigned one by one at random. At each step, the feasibility of the problem is checked. If, at some point, the resulting schedule is not feasible, the starting time of the task is postponed until feasibility is achieved. This process is repeated until the task is definitely inserted in a time period (see function buildSolution() in Procedure 3). It is important to note that the processing times are fixed at this phase. The steps of the constructive phase are shown in Procedure 2.

Local Search Phase.
After obtaining a schedule of tasks and a staff assignment in the constructive phase, the local search phase aims to improve the solution by reducing the processing times of each task. To do so, tasks are first ordered again at random and then, step by step, the number of employees ( ) allocated to each task (following this order) is increased. In each step, the processing time of the task is updated and the makespan is analyzed (using the buildSolution() function, Procedure 3). If the makespan decreases, then the new solution is kept and the new amount of assigned employees is updated. Next, another employee is assigned to the same task and the objective function is analyzed. This process is repeated until the maximum overcoverage allowed for the task is reached. Then, we continue with the following task in the same way. The local search phase finishes when all tasks have been analyzed. The output of this phase is the best solution found. The pseudocode of this phase is shown in Procedure 4.

Computational Results
In this section, the problem under consideration is solved using the PSSA-CPT model introduced in Section 3 and the GRASP algorithm presented in Section 4. The PSSA-CPT model is implemented using the software Gurobi Optimizer 4.51 and ILOG CPLEX 12.4 and the GRASP heuristic is coded in C#. The computational experiments were tested on an Intel Core i7-930, 2.8 GHz, 16 GB RAM under Windows 7. This section is divided into two parts. An explanation of the test bed is presented in Section 5.1 and, next, in Section 5.2, a comparison of the computational results discussed is made, along the following aspects: (i) comparison between CPLEX and Gurobi solvers; (ii) comparison between GRASP algorithm results and exact results; (iii) impact of CPT on reducing the makespan of the project.

Test Bed.
The integer programming problem presented in this paper was solved by the software Gurobi Optimizer 4.5 for instances based on the sets j30 and j60 of the PSPLIB classical instances [50], which are a reference test beds for project scheduling. Each combination of parameters is replicated ten times and the mean value is taken to represent it. In order to adapt the test beds to our problem, additional parameters have to be defined: maximum possible over-and Procedure buildSolution(ne , TO, EO) foreach set do foreach task according to TO do set the starting time of the task (denoted ) according to the release time of this task and the completion times of the predecessors of the task, looking for the minimum possible starting time repeat assign employees, who are able to perform the task, to the task following the EO until the ne is reached if the assignment is unfeasible then := + 1 end until the assignment is feasible; end end check the feasibility of the solution end  [17], where an employee was assigned a 70% probability to master a skill. In our paper, it is assigned an 85% probability to avoid infeasibility in the test beds. The parameters and are set to 2.5 according to the slope of the piecewise relationships explained in Section 3.2. In total, 960 instances were generated where 10 replicates were obtained for each combination of the parameters in Table 5 (see [51] for a detailed description of the parameters NC, RF, and RS).

Comparison and Analysis of Computational Results.
The integer linear programming model was solved in this paper using the Gurobi software and ILOG CPLEX. Firstly, time limit was set to 30 min using Gurobi. The average results out of the 10 replicates for each parameter combination are shown in the 7th and 8th columns of Tables 6 and 7 (for the j30 and j60 instances, resp.). Dashed lines are used in some combination to specify that no solution was found for any replicate. The 9th, 10th, and 11th columns indicate the number of optimal, feasible, and nonfound solutions, respectively, for each combination of parameters found by Gurobi. It can be seen that optimal solutions were achieved for 567 instances from the total of 960 instances, feasible solutions were found for 16 cases, and no solutions before 30 minutes were therefore obtained for 377. The latter represents a huge amount of instances without solution and thus different method of resolution has to be implemented. More specifically, exact

14
The Scientific World Journal solutions were achieved for 325 instances considering 30 tasks in the project, and only in 242 instances with 60 tasks. Using the same time limit than CPLEX, makespan and runtime are shown in the second and third columns. Optimal solutions were found only for 216 from the total of 960 instances (only 13 in the set j60) and feasible solutions for 352 instances and, hence, no solutions were found in 608 instances. This represents worse results as compared to that of Gurobi. With respect to the value of the makespan for the instances where feasible solutions were found, the ARPD (average relative percentage deviation) for CPLEX in these 352 instances was 58.4%, calculated using the expression (41), in contrast to the ARPD of 3.4% found by Gurobi in the 583 feasible solutions: . (41) Finally, the GRASP heuristic was compared with the exact solutions. The time limit of the GRASP heuristic was set to ⋅ /10 seconds; that is, it increases with the difficulty of the problem. Results are shown in Tables 6 and 7. Each row corresponds to a given combination of parameters and the first column indicates the chosen parameters in the format (j-NC-RF-RS). The column " GRASP max " represents the average makespan using the GRASP algorithm for 10 iterations and the column " GRASP " is corresponding computation time ( ⋅ /10). The mean deviation between the solutions by Gurobi with time limit of 30 min and the solutions by GRASP with time limit of ⋅ /10 are shown in the column "ARPD" using the expression (41).
The ARPD of the GRASP algorithm for all problems was 0.38%. Comparing the results of the exact solutions found by Gurobi (567 instances), the deviation of the solutions obtained by the GRASP algorithm is 0.62%, and optimal solutions using GRASP were found in 457 of these 567 instances (80.7% of the instances). Furthermore, feasible solutions were found by GRASP in each instance while feasible solutions were found in 587 instances using Gurobi.
Even better results are obtained when the GRASP algorithm is compared with Gurobi with the same time limit; that is, the time limit ⋅ /10 is fixed for both GRASP heuristic and Gurobi. In this case, Gurobi found only optimal solutions in 201 of the total of 960 instances of the test bed while our heuristic found feasible solutions for all instances. Furthermore, the deviation of the heuristic from the optimal solutions was only 0.05% for these 201 instances and optimal solutions were found in 195 instances which represents a 97.01%.
In Section 3.4.1, the interest to compare the PSSA problem with CPT with the PSSA problem with FPT was discussed. The PSSA problem with FPT was solved by Gurobi setting also a time limit of 30 minutes. The makespan and runtime of this problem for each instance are shown in the 11th and 12th columns, respectively. Results of the PSSA-CPT and PSSA-FPT are compared in the 13th column. The objective function of PSSA-FPT represents an upper bound of the function objective of the PSSA-CPT ( PSSACPT max ≤ PSSA max ), since a solution of PSSA-FPT is always a feasible solution for PSSA-CPT. The difference between the makespan and the runtimes of both models is analyzed. Considering only the instances with optimal solution (567 instances), the makespan decreases by 13.4% using CPT. On the other hand, runtime increased by 160.03%, which may seem an excessive increase in runtimes. However, since the planning horizon is always over 75 days, it seems reasonable that such a long and important decision must be performed carefully, so the runtime increase must not be so significant in that case.

Conclusions
In this paper, a project scheduling and staff assignment problem has been integrated. As in many real-life cases, the processing times of the tasks depend on the number of employees assigned; CPT were analyzed. There exists a feasible region where the relation of processing times and number of employees can be placed, so a piecewise linear relationship was proposed and included in a linear programming model for the problem in order to better represent the reality considering the penalty for communication in bigger teams and the penalty for lack of specialization in small teams. The consideration of a piecewise linear relationship between the processing times and the amount of resources in the PSSA-CPT provided a large reduction in runtime compared to the adaptation of the DTRTP adding staff assigned.
Different instances of the problem were first solved using the solver Gurobi Optimizer 4.5 and ILOG CPLEX 12.4, the former being more computationally efficient. Furthermore, a comparison between the model with CPT and with FPT was performed to justify the introduction of such CPT. The results obtained highlight an important decrease of the makespan by considering variable processing times. However, due to the complexity of the problem, extremely high computational times were needed for medium-large size instances by Gurobi, justifying the implementation of an approximate algorithm (GRASP). Computational times were greatly decreased there maintaining good ARPDs.
Regarding the future research lines of this paper, different approximate algorithms may be implemented in order to decrease the computational times comparing the results to the GRASP algorithm presented here and with other approximate algorithms employed for similar problems. Finally, a future research line relates to the CPT. In this paper, a piecewise linear relationship between processing times and number of employees (renewable discrete resources) has been introduced in the model. However, different relationships between both variables may be analyzed, such as a convex relationship and hyperbola, in order to adapt the model presented in this paper to continuous renewable and nonrenewable resources.