Dynamic Programming Algorithms for Solving Single Machine Scheduling Problems with a Fixed Complexity Time

We solve in this paper some machine scheduling problems with certain conditions; the solution had been made by using dynamic programming procedures with a fixed time for all the algorithms. Some of the algorithms described in the paper represent a modification to some mathematical programming algorithms and some of them are new or a generalization to others. The optimal solution of all these algorithms will be done with a fixed complexity time, which may lead us to solve them easier and faster.


Introduction
In the recent years, there has been a large importance in scheduling problems with set up times.The set up times occur when we have different families of jobs, as an example of families and set ups; this may happen in an industrial unit of coloring or painting plastic or wood products.Products (jobs) with the same colors may represent a one class (family).Cleaning the machine from a particular color to receive another different product color will represent a set-up time so the products with the same color will represent a family, the families of jobs may possibly take place in other fields of the life.We derive in this paper some dynamic programming algorithms to solve single machine scheduling problems with set up time families with an order of complexity which is fixed for all our dynamic programming algorithms, in other words with the same complexity algorithm time which may help us to solve the problems more rapidly.Before describing the dynamic programming algorithms we will use the standard classification scheme for scheduling problems (Graham et al. [7]) which is , where α indicates the machine environment, in this paper α will be equal to 1, which indicates that we will have single machine problems( α =1), β describes the job and family characteristics and the constraints on the jobs, and ϕ defines the objective function to be minimized.Before describing the algorithms, let {1, 2, …,n} denote the set of jobs to be processed, also for each family f (f=1, 2, ...,F), we will define the following parameters: which represent the processing time, the due date and the weight of the i th job of the f th family, respectively.Also for each family f we will assign a positive specific amount, which is called the set-up time s f .
For each job i we will define the following variables: : is the lateness of job i, T i = max {L i , 0} : is the tardiness of job i. [10] gave a preview of solving some machine scheduling problems for single machine and more than one machine, by using dynamic programming algorithms, the rest of this paper will be organized as follows: First we will give in section 2, a general description of our algorithm and then we will give the complexity time of the algorithm.In section 3, we will discuss our dynamic programming algorithms.This discussion may be made as follows:-We will discuss the dynamic algorithm for the sum of completion times problem 1/s f / ∑ i C which is a generalization to that one which is described in [9], moreover in the same section, we will describe the sum of the weighted completion times problem

Potts and Kovalyov
w and solve it by another dynamic programming algorithm which will represent a generalization to that which is described in [1], we will use a dynamic programming algorithm to solve the square completion times problem 1/s f / ∑ 2 i C , in the same section, an algorithm of finding the optimal solution of the weighted summation of square completion times, with equal weights 1/ s f , , and the weighted sum of square completion times, with equal processing times 1/ s f , p i f = p f / ∑ 2 i i C w will also be considered in this section.In the same section, we will use a dynamic programming algorithm to solve the sum of tardy jobs with equal due dates 1/ s f , d i f = d f / ∑ i T , and to solve the sum of tardy jobs with equal processing times 1/ s f , p i f = p f / ∑ i T , also in the same section, we will describe a dynamic programming algorithm to solve the weighted summation of tardy jobs with equal weighted due dates 1/ s f , w i f d i f = w f d f / ∑ i i T w .Finally the same section, will describe an algorithm which finds the optimal solution of the maximum lateness 1/s f /L max .At last section 4 gives us some conclusions on the algorithms.

Algorithms Description and Complexity Time
The dynamic programming algorithms which have been discussed in this paper; compute values ) , ,..., ,..., , ( for f = 1, 2, ..., F, these values represent the minimum total overall contribution to the cost of the objective function, when n f job(s) from family f (f = 1, 2, …, F) is(are) sequenced, the last term f of the recursive equations g , indicates that the last sequenced job is from family f (f = 1, 2, …, F).For example the value g (2, 1, 1, 2) will indicate that we have three families where two jobs from family 1, one job from family 2 and one job from family 3 are sequenced, the last term of the value g (2, 1, 1, 2) is equal to two, which indicates that the last sequenced job is from family 2.
Suppose that the current state is , then no set up would be required before the job (n 1 , 1), so its overall contribution to the objective function will become: where . The cost here is one of our objective functions which are described in the previous section.Some of the machine scheduling problems will have unit weights, in other words these jobs share the same weight (importance), and for this reason expression 1 will be converted to: Now to find all the values of . The non existence of some values of the recursive equations g will lead us to let them be equal to infinity that is all other initial values are set to infinity, observe that if the recursive equations are of the maximum type then we must let some of the values equal to minus infinity, we will explain the non existence of these values in the next section.Our aim is to determine: Where f q is the total number of the jobs of family f (f = 1, 2, …, F).The time complexity of the dynamic programming algorithms will depend on the number of the states of the recursive equations which described in (3), the desired time can be described as follows, for each family f, we have , so for all the F families, we will have (1+q 1 ) (1+q 2 ) … (1+q F ) states, we observe that for each state the corresponding recursive equation is solved in a constant time.Now since we have q 1 < n 1 , q 2 < n 2 , …, q F < n F , so we deduce that the algorithm will require O(n 1 .n 2 .n 3 .… .nF ) time, now since n f < n for all f then we deduce that the algorithm would be of O(n F ) complexity time.All the algorithms described in this paper will share a fixed time of complexity which is n F as mentioned above, so rather than solving the algorithms in different times it is better to solve them in fixed computation time, hence the fixed time will lead us to solve these algorithms faster and easier.

Dynamic Algorithms for the Objective Functions
This section will be devoted to describe the dynamic programming algorithms of our objective functions.

The sum of the completion and weighted completion times
The dynamic programming algorithm for the sum of completion times problem and the dynamic programming algorithm of the sum of weighted completion times problem are considered first.Before describing the recursive equations we must first rearrange the jobs of each family in non decreasing order of the processing time [8], the optimal solution of the , now since some of the cases will be impossible, for instance the case g(1, 0, …, 2) means that the last sequenced job is from the family 2 but we have no any sequenced job from this family so we set the value of this case to be infinity, that is the reason of setting all other initial values to infinity.
The recursive equations of Potts [9] were given to solve the sum of completion times with only two families and these recursions are: We generalize the idea of Potts [9] to more than two families in other words to F families as mentioned in the recursive equations (4).
Before applying the recursive equations of the sum of the weighted completion times, the jobs of each family must be sequenced in non decreasing order of the ratios p if /w if [8].The optimal sequence of the sum of weighted completion times 1/ s f / ∑ i i C w can be determined by applying the following recursive equations: , as mentioned above all other initial values are set to infinity.The recursive equations of Abdullah [1] were given to solve the sum of completion times with only two families and these recursions are: We generalize the idea of Abdullah [1] to more than two families in other words to F families as mentioned in the recursive equations (4).Crauwels et el.[4] and Abdul-Razaq and Abdullah [2] propose branch and bund algorithms for the problem 1/ s f / ∑ i i C w , also this problem has been solved by an O(n F ) algorithm by Ghosh [5], which is equivalent to our algorithm, Ahn and Hyun [3], propose a forward dynamic programming algorithm with job appending that also requires O(n F ) time.

The sum of the square completion and weighted square completion times
The optimal solution of the sum of the square completion times problem / s f / ∑ 2 i C , can be determined first by rearranging the jobs according to non decreasing order of the processing times p if , see [11], and second by applying the following recursive equations: , all other initial values are set to infinity.

The sum of the tardy and weighted tardy jobs
Next in this section we will find the optimal solution of the sum of tardiness jobs with equal due dates 1/ s f , d i f = d f / ∑ i T , we see that: We notice from equation ( 8) that since d is a fixed due date time then we can rearrange the jobs of each family by non decreasing order of the processing times p if , the rearrangement will lead us to the best solution, our aim here is to find the optimal solution, and this can be reached by applying the following recursive equations: − is the completion time of the n f -1's job of family f (f=1, 2, …, F) which can be obtained from the previous state of the recursive equations that is from the minimum solution of the preceding state.
Figure 1 The 1/ s f , p i f = p f / ∑ i T problem can be solved first by rearranging the jobs according to non decreasing order of d i f and second by applying the following recursive equations: The sum of the weighted tardy jobs problem with equal weighted due dates 1/ s f , w i f d i f = w f d f / ∑ i i T w will be considered now, here we have: Now from the last equation of (11) we notice that since wd is a fixed weighted due date time for all the families so rearranging the jobs of each family according to non decreasing order of p/w and then applying the recursive equations (12) will give us the optimal solution of the last problem.
To the best of our knowledge the algorithms which are described in this section are new ones.

The maximum lateness
The last problem which is considered in this paper is maximum lateness with set-up times that is the 1/s f /L max problem.This problem can be solved by applying the following steps: the first step is to rearrange the jobs according to non decreasing order of their due dates see [8], while the second step is to find the optimal solution by applying the following recursive equations: To explain the last recursive equations let us take the following example: consider a problem which consists of 4 jobs divided into two families f 1 and f 2 where f 1 ={1, 3} and f 2 ={2, 4} with set-up times s 1 =s 2 =2 of both families, the processing times the jobs are: p 1 =2, p 2 =1, p 3 =3 and p 4 =8 while the due dates of the jobs are d 1 =5, d 2 =10, d 3 =8 and d 4 =19.By applying the recursive equations (13) we will obtain the following table of solutions: (n 1 , n 2 ) (1, 0) (0, 1) (2, 0) (0, 2) (1, 1) (1, 2) (2, 1) (2, 2) g(n 1 ,n 2 ,1) -1 From the last column of the above table we see that the optimal solution is equal to 2, backtracking shows that the best sequence is (1,3,2,4).We Notice that our dynamic algorithm to solve the maximum lateness problem with set-up times is equivalent to that of Ghosh and Gupta [4], since it required the same complexity time, that is of order O(n F ).

Conclusions
In this paper we see that some special kinds of machine scheduling problems can be solved by applying dynamic programming algorithms with a fixed time, in other words all our dynamic algorithms are solvable in the same time of complexity.Some of these algorithms represent a generalization to other algorithms and some of them represent a modification of other ones while some of them are new ones.You can make use of this paper to solve other objective functions or to apply it to more than one machine.