**SLOPE=(Crash Cost-Normal Cost)/(Crash Time-normal Time; if <0 as the time required for a project/task decrease, the cost increase**

To formulate a project crashing problem as a linear programming problem, the user must :

- define variables.
- Define an objective function as a linear combination of decision variables.
- Define constraints which use linear combinations of the decision variables.

Defining the decision variables is fairly easy. The user should define two variables for each activity. The first variable should represent the amount of reduction (“crashing”) in each activity. Render and Stair use the variable :**Y _{j} = amount of reduction in activity j.**

Y_{i,j }= amount of reduction in activity defined from beginning node i to ending node j.

The second variable should be :**end _{j} = time at which activity j ends.**

The objective function, which is to be minimized, is :

**Total cost of crashing = S C _{j} * Y_{j} **

**Crash cost**

_{j}– normal cost_{j}**where C**

_{j}= crash cost per day =**normal time**

_{j}– crash time_{j}One set of constraints recognizes the limitations in crashing any individual activity. This set of constraints can be stated as :**Y _{j} <= normal time_{j} – crash time_{j}**

A second set of constraints recognizes that the ending time of every activity is the starting time plus the duration of that activity, and no activity can start until all of its predecessors have been completed. This set of constraints can be written as :**end _{j} >= end_{pred} + t_{j} -Y_{j}**

If an activity has only one predecessor, the inequality in the constraint above could be changed to a strict equality. In general, constraints can have more than one predecessor, so the entire set of constraints is written with the more general >= relationship. Before we can use a computer program to solve the linear programming formulation, the constraint above must be put into standard form (all variables on the left side, only constants on the right side). We do this by adding the term Y_{j} to both sides of the inequality, and subtracting the term end_{pred }from both sides. The result can be written as :**– end _{pred} + end_{j} + Y_{j }>= t_{j}**

The final constraint recognizes the target for crashing. It can be stated as :**end _{last} <= Target**

where Target must be a constant and end_{last} represents the end of the last activity in the project (activity with no successors). If there are several activities without successors, then it may be necessary to repeat the constraint above for each possible last activity.

If there is a specific deadline that causes a penalty if it is not met, a new variable and a special constraint should be added. The new variable can be called “late”, defined by the following statement :**late >= end _{last} – deadline**

This statement can be turned into a constraint by multiplying both sides by -1 (which reverses the inequality) and adding the term end_{last }to both sides. The result will look like this :**end _{last} – late <= deadline**

The term ‘ + penalty * late’ (where ‘penalty’ is a numerical constant ) should be added to the objective function.

you can use the following steps to crash a project :

1. Predict the time characteristics of the project including the critical path

2. Calculate ** crash cost / day **for each activity using the formula

**Crash cost**

_{j}– normal cost_{j}**C**

_{j}= crash cost per day = ——————————**normal time**

_{j}– crash time_{j}3. Select the activity on the critical path with the lowest crash cost/day

4. Crash the selected activity until

it can’t be crashed any more, or

you have reached your target, or

you use up all of the slack and changed the critical path

5. repeat steps 3 and 4 until you have reached your target