At the building phase of a GRASP algorithm a feasible solution is constructed by joining one element at a time. Each element is evaluated by a heuristic function and incorporated (or not) in a restricted candidate list
(
RCL)
according to its evaluation.Then the element to join the solution is chosen randomly from the RCL . We define the sequence of operations at each machine as the elements to join the solution, and the makespan of the one machine problem (max
(
ti +pi)
,i∈Ok,k∈M) as the greedy function to evaluate them. In order to build the restricted candidate list we find the optimal solution for the one machine problems of all machines not yet scheduled (K ⊆M is the set of unscheduled machines), and identify the best( )
f and worst( )
f5. An OSH Combining GRASP with Branch-and-Bound
54
makespans. A machine k is included in the RCL if f(xk)≥ f −α
(
f − f)
, where) (xk
f is the makespan of machine k and α is a uniform random number in
( )
0,1 .We explain how the one machine problems are defined and solved in the next section 5.1.1.
After solving the subproblems of all unscheduled machines and building the restricted candidate list, a semigreedy procedure chooses one machine to enter the solution in a semi-greedy randomised way.
Algorithm SemiGreedy
( )
K(1) α :=Random(0,1)
(2) f :=max
{
f(xk),k∈K}
(3) f :=min
{
f(xk),k∈K}
(4) RCL=
{ }
(5) foreach k∈K
(6) if f(xk)≥ f −α
(
f − f)
(7) RCL:=RCL∪
{ }
k(8) returnRandomChoice
(
RCL)
Fig. 5.1 Outline of Procedure SemiGreedy
This semi-greedy randomised procedure is biased towards the machine with the higher makespan, the bottleneck machine, in the sense that machines with low values of makespan have less probability of being included in the restricted candidate list.
The next chapter presents the definition of the one machine scheduling subproblems and the algorithm to solve them.
5.1.1 One Machine Problem
Defining the One Machine Subproblems Given a job shop scheduling problem and its representation on a disjunctive graph G=(O,A,E), the one machine subproblems for each machine k∈M are obtained considering only the nodes of the operations processed on k and the set of edges between them
( )
Ek . The subproblems are represented by the clique Ck =(Ok,Ek) with the objective function of minimisingthe completion times of all operations and considering three parameters associated with each operation i in C . One parameter is the processing time k p . Let i K⊆M be the set of unscheduled machines. The two other measures associated with each operation of the one machine subproblems are computed from the graph
) ,
,
( M K
K
M O AS
G − = − , obtained from G replacing the edges of scheduled machines by the arcs corresponding to the sequence of processing their operations and removing the edges corresponding to all unscheduled machines. The two measures are the release dates r computed as the length of the longest path in i GM−K from the source node to the node of operation i and the queue values q computed as the length of the i longest path in GM−K from the node of operation i to the end node (minus the processing time of operation i ). The release date of an operation i represents the time that the job to which operation i belongs has been in the system before the processing of the operation starts. The queue value, also called tail, represents the time that the job to which operation i belongs stays in the system after the processing of the operation ends. At the first iteration of the algorithm GRASP_B&B, release dates and tails are computed considering the graph D=(O,A).
Solving the One Machine Problems To solve to optimality the one machine scheduling problems we use the branch-and-bound algorithm of Carlier (Carlier 1982) described earlier on section 4.3.1.
At each node of the branch-and-bound tree the upper bound is computed using the algorithm of Schrage (Schrage 1970). This algorithm gives priority to higher values of the tails
( )
q when scheduling released jobs. We break ties by preferring larger iprocessing times.
The computation of the lower bound, computed like in (Carlier 1982) is based on the critical path with more jobs of the solution found by the algorithm of Schrage (Schrage 1970) and on a critical job, as shown in chapter 4. The value of the solution with pre-emption is used to strengthen this lower bound. We introduce a slight modification, forcing the lower bound of a node never to be smaller than the one of its father in the tree. (The makespans of the one machine scheduling subproblems are lower bounds to the makespan of the job shop scheduling problem.)
5. An OSH Combining GRASP with Branch-and-Bound
56
The algorithm of Carlier (Carlier 1982) uses some proven properties of the one machine scheduling problem, showed earlier in chapter 4, to define the branching strategy, and also to reduce the number of inspected nodes of the branch-and-bound tree.
Incorporating the One Machine Solution Incorporating a new machine in the solution means adding to the set of arcs SM−K of graph GM−K =(O,A,SM−K) the set of arcs corresponding to the optimal sequence for processing operations on machine k - S . In terms of the mathematical formulation, this means choosing one k of the inequalities of the disjunctive constraints (4.11) corresponding to the machine
k .
When a new machine is added to a partial solution the makespan of the solution and the release dates and tails of unscheduled operations are updated. In the proposed procedure GRASP_B&B these updates are accomplished using an algorithm similar to the one used by Taillard (Taillard 1994). This algorithm has a module that updates the release dates by building and maintaining a list of the operations which either do not have operations that precede them (both in the job and in the machine), or have the predecessors with the release dates already updated. The module is repeated with a modification to update the tails of the operations, building a list of operations without successors or with successors with the tails already updated. Finally for each operation the updated values of release dates and tails are added to the processing time and the makespan of the partial solution is computed.
Before proceeding to the section where the local search step of the algorithm GRASP_B&B is described, let us illustrate the building step with an example.
Illustrating the Building Step To exemplify how the building step of the procedure GRASP_B&B works let us illustrate one iteration considering the disjunctive graph of the instance of Table 4.2.
Deleting all the edges connecting operations that share a same machine in the graph of Fig. 4.2 we get the graph shown in Fig. 5.2. Computing the one machine problems for each of the machines, we get the problems present bellow the graph.
Fig. 5.2 Graph for instance of Table 4.2 without all edges and the respective one machine subproblems
The branch-and-bound algorithm finds the optimal solution 7 partial solution would be the one represented in the graph of Fig. 5.3 and the new one machine subproblems for machines 2 and 3 the ones presented in the tables next to it.
Fig. 5.3 Graph of a partial solution to instance of Table 4.2, and the respective one machine problems for machines 2 and 3
5. An OSH Combining GRASP with Branch-and-Bound
58