SINGLE MACHINE GROUP SCHEDULING PROBLEM WITH MAKESPAN OBJECTIVE AND A PROPORTIONAL LINEAR SHORTENING

. This paper considers a group scheduling problem with shorten ( i


Introduction
In the classic scheduling, the processing time of a job is generally a specified constant. But in some actual situations, the processing time of some job is variable, which will transform around the expected value with the start time of the job. For instance, in a fire accident, the disaster situation will soar over the time. When the start time of fire extinguishing is delayed, the time of fire fighting will be prolonged and the loss of resources will increase, this is the phenomenon of deterioration effects [1,5,9]. On the other hand, the phenomenon of "learning effects" can be described by a non-increasing function of start time (or position) dependent function. For example, in a radar detection system, the distance between radar and target gradually decreases as the target approaches. Similarly, the time required to detect the target will be gradually shortened with the time elapsed by the radar electromagnetic wave. Extensive surveys on position dependent learning effects can be found in Biskup [4] and Azzouz et al. [2], and an extensive book on time dependent learning effects (i.e., shortening job processing times) can be found in Gawiejnowicz [7].
Group technology is a technique that takes advantage of the similarities between things and groups into job families according to specific criteria. Due to the similarity of the jobs in one group, the processing efficiency of a job will increase and processing time will be shortened. In many countries, group technology is applied to the field of computer technology and automation technology to develop flexible manufacturing systems and provide multi-variety, small and medium-sized and highly automated production, which has great application value in actual production. Therefore, such as Potts and Van Wassenhove [19], Keshavarz et al. [11], Neufeld et al. [18], Ji and Li [10] and Lu et al. [17], many scholars had done lots of research on group technology. Wang et al. [24], Wang et al. [25] and Xu et al. [30] introduced a simple deterioration function into the single machine grouping problem. Bai et al. [3] studied the problem of single group scheduling with a general learning effect of deteriorating conditions. They proved that minimizing makespan was polynomial solvability in this case. The resource allocation single machine scheduling problem with the deteriorating jobs was considered by Wang et al. [26]. Wang and Wang [21] investigated the single machine scheduling problem with group technology and ready times, where the setup (installation) time and job processing time of each group are proportional linear deterioration functions of their start time. For the makespan minimization, they proved that it could be solved in polynomial time. Liu et al. [14] considered the single machine group scheduling problem with simple linear deterioration and ready times. Under independent setup time, for the makespan minimization, they proposed heuristic and branch-and-bound algorithms to solve the problem.
To our knowledge, the scheduling problems that are related to time dependent processing times are widely reflected in real production, and many scholars have studied in this field (see [7,12,16]). The model with time dependent learning effects (i.e., shortening job processing times) is also widely reflected in the real scene (see [7]). Ho et al. [8] first proposed the scheduling problem of which the job processing time was a decreasing function of its starting time. Wang and Xia [22] and Wang et al. [27] studied scheduling with linear shortening job processing times. For the single machine problem, Wang and Xia [22] proved that some regular objective function minimizations can be solved in polynomial time respectively. For the three-machine flow shop problem of minimizing makespan, Wang et al. [27] proposed a branch-and-bound algorithm and a heuristic algorithm. Wang et al. [23] considered single machine group scheduling with shortening job processing times. Under independent setup of groups, they proved that the makespan and the total completion time minimizations can be solved in polynomial time. Wang and Sun [20] concentrated on single machine group scheduling problems with shortening job processing times. Under group setup times and job processing times are a decreasing function of their starting time, they illustrated that the makespan minimization problem can be solved in polynomial time. They also proved that the total weighted completion time minimization problem remains polynomially solvable under the proportional shortening job processing times. Lu et al. [15] studied the single machine group scheduling problem with proportional shortening job processing times and release dates. Under the group setup times and job processing times are both shortening job processing times, they proved that the makespan minimization was polynomial time solvable.
Recently, Wang et al. [28] examined the single machine group scheduling problem with proportional shortening job processing times and release dates. When the setup time of a group is fixed, they proved that the general case of the problem was polynomial time solvable problem when the number of groups had been determined; they also showed that some special cases of the makespan minimization can be solved in polynomial time respectively. Compared to many classic scheduling problems, most of the scheduling problems in the real world are not polynomial solvable and not special, therefore, in this paper, we continue the work of Wang et al. [28], we study the general case of single machine group scheduling problem with release dates and a proportional linear shortening processing time. The main contributions of this article are summarized as follows: first, this article presents an attempt to study the makespan minimisation single machine scheduling problem with a proportional linear shortening. Second, we develop a heuristic algorithm and a branch-and-bound algorithm to solve the problem. Finally, the results of numerical simulations are given to show that our algorithms can generate effective and efficient schedules.
The remaining part of this paper is organized as follows. Section 2 presents the problem formulation. Section 3 studies the scheduling problem under general conditions. And Section 4 summarizes conclusion in this study and future research directions.

Problem formulation
In the actual situation we are considering, the actual processing time is less than the standard processing time of the job. Generally speaking, the actual processing time of a job is related to three factors that are the standard processing time, learning factor and start-up time. On the basis of Wang et al. [28], we make the assumption that the actual machine processing time of a job is a linear decreasing function of its start time.
The expression of the model is given as follows.
Under the group technology, a total of jobs are divided into groups: 1 , 2 , . . . , . Assume that each group of (1 ≤ ≤ ) contains jobs { ,1 , ,2 , . . . , , }. A job is continuously processed on the machine. Only one job can be processed on the machine at the same time, and the machining process can not be interrupted. Let , denote the th job in group , , ≥ 0 ( , > 0) denote the ready time (actual processing time) of job , , = 1, 2, . . . , ; = 1, 2, . . . , , ( > 0, = 1, 2, . . . , ) denote the separate installation time for each group. We assume that the jobs which are in the same group must be processed without being interrupted. For the linear shortening job processing times, the actual processing time of the job is where , is the normal processing time of job , (the processing time without any shortening (learning) effects), is the shortening rate of job , (the positive compression rate of unit time), and is its start time. Assume that the shortening rate meets the following two conditions: and , where ,max = max{ ,ℎ |ℎ = 1, 2, . . . , } ( = 1, 2, . . . , ). In this paper, we consider a special case, i.e., Let , be the completion time of job , , max = max{ , | = 1, 2, . . . , , = 1, 2, . . . , } be the makespan of a permutation. Our goal is to minimize the makepan, i.e., the maximal completion time of all jobs. This problem has two influencing factors. One of the factors is to determine the optimal job sequence * within the group , and the other is to determine the optimal sequence * between the groups. The above problem is defined by the three-field notation (see [7]) as where GT denotes the group technology assumption. Wang et al. [28] considered the problem 1| , , , = Lu et al. [15] studied the problem 1| , , , = , (1 − ), = (1 − ), GT| max with the variable setup times, where > 0 is the normal setup time of the group , they showed that this problem can be solved in ( log ) time.
From the Wang et al. [28], and the heuristic of Framinan and Leisten [6], the following heuristic algorithm can be given.
Step 3.4. Groups are scheduled by the nonincreaseing order of ∏︀ Step 4. Choose the better solution from Steps 3.1-3.4.
Step 5. Pick the two groups from the first and second position of the list of Step 4, and find the best sequence for these two groups by calculating max for the two possible sequences. Do not change the relative positions of these two groups with respect to each other in the remaining steps of the algorithm. Set = 3.
Step 6. Pick the group in the th position of the list generated in Step 4 and find the best sequence by placing it at all possible positions in the partial sequence found in the previous step, without changing the relative positions to each other of the already assigned groups. The number of enumerations at this step equals .
Step 7. For the list generated in step 6, select two groups from the previous groups and only swap the positions of the two groups. By traversing all cases of the two selectable groups, the two groups of the best swap result are found by calculating max , and then the best sequence is updated. The number of enumerations at this step equals *( −1) 2 .

A lower bound
Let = (PS , US ) be a complete sequence, the first groups be the scheduled part (i.e., the part PS ), and the unscheduled groups have − groups (i.e., the part US ). By definition [28], the completion time of the ( + 1)th group is Using equation (3.1), considering the completion time and setup time, the following two specific calculation methods for the lower bound are given.

Lower bound 1
From equation (3.1), we have Therefore, the maximum completion time of the sequence satisfies the condition is minimized in which the unscheduled groups are in the non-increasing order of ,( ) ) , = + 1, + 2, . . . , . Hence the first lower bound can be obtained as follows: .

Lower bound 2
When considering the setup time of the job is long, the calculation process of the lower bound only considers the completion time of the job which is not rigorous. So considering the setup time of the job, the second lower bound of the problem can be obtained. According to formula (3.1), Similarly, Similarly, the completion time of the last job in the th group in the sequence is Therefore, the maximum completion time of the sequence satisfies the condition Consequently, we obtain the second lower bound

Branch-and-bound algorithm
Step 1. Determine an initial solution (i.e., the upper bound) by using Algorithm 1.
Step 2. A depth-first search is used in the branching procedure until all the nodes are explored or eliminated. Start the assignment of groups at the beginning of a sequence and move forward one step at a time.
Step 3. In the th level node, the first positions are occupied by specific groups. Select one of the remaining − groups for the node at level + 1.
Step 4. Calculate the lower bound of the unfathomed partial sequences by using (3.5). During the search, any unfathomed branch that has a lower bound which is larger than or equal to the initial solution is fathomed, i.e., eliminated from further consideration. If the value of the completed sequence is less than the initial solution, use it as the new initial solution. Otherwise, eliminate it.
Step 5. Continue to search all the nodes, and the remaining initial solution is optimal.

Computational experiments
Algorithms 1 and 2 (the Branch-and-bound algorithm) were programmed in VC++ 6.0 and tests were run on CPU Intel Core i5 2.5 GHz and 8GB RAM for several sizes of the problem ( = 1000, 1250, 1500, 1750, 2000, =250, 275, 300, 325, 350 and each group must contain at least one job). The following parameters are randomly generated: (1) = 0.00005; (2) are uniformly distributed over [1,100]; (3) are uniformly distributed over [1,100] As a consequence, 25 experimental conditions were examined and 40 replications were randomly generated for each condition. A total of 1000 problems were tested. The percentage error of the solution produced by Algorithm 2 is calculated as   where max ( 1) ( * max ) is the makespan value generated by using Algorithm 1 (the optimal sequence can be obtained by Algorithm 2).
In addition, we define "A1-CPU time (s)" ("B&B CPU time (s)") as the running time of Algorithm 1 (the B&B algorithm, i.e., Algorithm 2). The corresponding results are summarized in Table 1. From Table 1, we can see that the performance of Algorithm 1 performs very well in terms of the error percentages. Moreover, Table 1 reveals that a relatively large number of instances (2000 jobs and 350 groups) were solved by B&B algorithm (a maximum CPU time less than 602 s).

Conclusions
This study researches the single-machine group scheduling problem with ready times and shortened job processing times. The processing time of a job is a proportional linear shortening function of its start time, the setup time of each group is a constant, and the objective function is the maximum completion time of all jobs. The goal is to find the job sequence within each group and the group sequence such that the makespan is minimized. For the general case of the problem, we propose a branch-and-bound algorithm and a heuristic algorithm to solve this problem. From the experimental results, it can be seen that the effect of heuristic algorithm is significant. In future research, we can extend it to multi-machine problems such as parallel machines or flow shop settings. It is also interesting to extend the model to the single-machine group scheduling problem with general shortened job processing times, due-date assignment (see [29]) or positional-dependent learning effects (see [2,4,13]).