Showing papers on "Single-machine scheduling published in 1996"
03 Jun 1996
TL;DR: It is proved that the algorithms proposed have performance bound 2 and (√5 + 1)/2, respectively, and it is shown that for both problems there cannot exist an on-line algorithm with a better performance guarantee.
Abstract: We consider single-machine on-line scheduling problems where jobs arrive over time. A set of independent jobs has to be scheduled on the machine, where preemption is not allowed and the number of jobs is unknown in advance. Each job becomes available at its release date, which is not known in advance, and its characteristics, e.g., processing requirement, become known at its arrival. We deal with two problems: minimizing total completion time and minimizing the maximum time by which all jobs have been delivered. For both problems we propose and analyze an on-line algorithm based on the following idea: As soon as the machine becomes available for processing, choose an available job with highest priority, and schedule it if its processing requirement is not too large. Otherwise, postpone the start of this job for a while. We prove that our algorithms have performance bound 2 and (√5 + 1)/2, respectively, and we show that for both problems there cannot exist an on-line algorithm with a better performance guarantee.
144 citations
TL;DR: A relation between this problem and the parallel machine scheduling problem is identified, which enables the establishment of complexity results and algorithms for the former problem based on known results for the latter problem.
129 citations
TL;DR: A polynomial dynamic programming algorithm is presented for solving a single machine scheduling problem involving both the scheduling of job processing and the Scheduling of job delivery.
117 citations
TL;DR: The problem of scheduling n jobs on a single machine is studied and the problem is shown to be solvable in O(n log n) time if the resource is continuously divisible.
109 citations
TL;DR: This paper introduces the components of 'case-based reasoning' (CB R) and describes a CB R solution to a 'travelling salesman problem' in order to illustrate the use of CB R in optimization problems.
Abstract: In this paper we explore the reuse of components of known good schedules in new scheduling problems. This involves accumulating a case-base of good quality schedules, retrieving a case (or cases) similar to a new scheduling problem and building a new schedule from components of the retrieved cases. We start by introducing the components of 'case-based reasoning' (CB R) and we describe a CB R solution to a 'travelling salesman problem' in order to illustrate the use of CB R in optimization problems. Two CB R solutions to a single machine scheduling problem with sequence dependent setup times are described. These are evaluated by comparing them with two more conventional alternative techniques simulated annealed and myopic search. Both CB R techniques are shown to provide good quality solutions quickly.
77 citations
TL;DR: In this article, a fuzzy approach to a single machine scheduling problem is considered, where the system's variables are defined using linguistic terms and each of these variables may take values described via fuzzy triangular numbers.
73 citations
TL;DR: This work studies single machine scheduling problems with the objective of minimizing the number of early and tardy jobs, and proposes several cost structures: job-independent, job- dependent and symmetric, and job-dependent and asymmetric.
71 citations
TL;DR: A set of jobs is scheduled using the SLK due-date determination method, according to which all the jobs are given the same flow allowance, and an analytical solution is given and an algorithm is presented, which provides optimal solutions.
Abstract: In this paper, a set of jobs is scheduled using the SLK due-date determination method, according to which all the jobs are given the same flow allowance. The single machine case is considered. The objective function is a cost function including three components, namely flow allowance and weighted earliness and tardiness. An analytical solution is given and an algorithm, which provides optimal solutions, is presented. Finally, the parallel machines case is discussed.
69 citations
TL;DR: In this article, the static deterministic single machine scheduling problem with a common due window was considered and an O(n log n )-approximation algorithm was proposed to solve the problem.
63 citations
TL;DR: The objective is to determine the optimal sequence, the optimal due-dates and the optimal processing time compressions to minimize a total penalty function based on earliness, tardiness, due- dates and compressions.
62 citations
TL;DR: A polynomial algorithm is presented for schedulingnjobs on a single machine that is continuously available from time zero onward and that can handle no more than one job at a time and these can be used if precedence constraints exist between the jobs or if all penalty functions are nonincreasing in the job completion times.
TL;DR: It is shown that the single machine earliness/tardiness problem with arbitrary time windows is NP-hard and then decompose it into the subproblems of finding a good job sequence and optimally inserting idle time into a given sequence.
TL;DR: A novel methodology, Greedy Randomized Adaptive Search Procedure (GRASP), is used in this paper to develop an efficient heuristic for the SMS problem that compares favorably to both the DP and tabu search methods with respect to the solution values obtained and the CPU times required.
TL;DR: This work proposes to use dynamic programming in the process of obtaining new generation solutions in the genetic algorithm, and calls it a genetic DP algorithm, to evaluate the effectiveness of this approach to deal with computationally hard problems.
TL;DR: In this paper, a branch-and-bound algorithm based on many dominance rules and various lower bounds was proposed to minimize the sum of total completion time and earliness with β > α, which can be rewritten as an earliness-tardiness problem.
Abstract: We address the NP-hard single-machine problem of scheduling n independent jobs so as to minimize the sum of α times total completion time and β times total earliness with β > α, which can be rewritten as an earliness–tardiness problem. Postponing jobs by leaving the machine idle may then be advantageous. The allowance of machine idle time between the execution of jobs singles out our problem from most concurrent research on problems with earliness penalties. Solving the problem to optimality poses a computational challenge, since the possibility of leaving the machine idle has a major effect on designing a branch-and-bound algorithm in general, and on computing lower bounds in particular. We present a branch-and-bound algorithm which is based upon many dominance rules and various lower bound approaches, including relaxation of the machine capacity, data manipulation, and Lagrangian relaxation. The algorithm is shown to solve small instances with up to 20 jobs.
01 Jan 1996
TL;DR: A branch-and-bound algorithm for scheduling n independent jobs with release dates, due dates, and family setup times on a single machine to minimize the maximum lateness is presented in this paper.
Abstract: textWe address the NP-hard problem of scheduling n independent jobs with release dates, due dates, and family setup times on a single machine to minimize the maximum lateness. This problem arises from the constant tug-of-war going on in manufacturing between efficient production and delivery performance, between maximizing machine utilization by batching similar jobs and maximizing customers' satisfaction by completing jobs before their due dates. We develop a branch-and-bound algorithm, and our computational results show that it solves almost all instances with up to about 40 jobs to optimality. The main algorithmic contribution is out lower bounding strategy to deal with family setup times. The key idea is to see a setup time as a setup job with a specific processing time, release date, due date, and precedence relations. We develop several sufficient conditions to derive setup jobs. We specify their parameters and precedence relations such that the optimal solution value of the modified problem obtained by ignoring the setup times, not the setup jobs, is no larger than the optimal solution value of the original problem. One lower bound for the modified problem proceeds by allowing preemption. Due to the agreeable procedure structure, the preemptive problem is solvable in O(n log n) time.
TL;DR: A branch-and-bound algorithm for scheduling n independent jobs with release dates, due dates, and family setup times on a single machine to minimize the maximum lateness is presented in this article.
Abstract: We address the NP-hard problem of scheduling n independent jobs with release dates, due dates, and family setup times on a single machine to minimize the maximum lateness. This problem arises from the constant tug-of-war going on in manufacturing between efficient production and delivery performance, between maximizing machine utilization by batching similar jobs and maximizing customers' satisfaction by completing jobs before their due dates. We develop a branch-and-bound algorithm, and our computational results show that it solves almost all instances with up to about 40 jobs to optimality. The main algorithmic contribution is our lower bounding strategy to deal with family setup times. The key idea is to see a setup time as a setup job with a specific processing time, release date, due date, and precedence relations. We develop several sufficient conditions to derive setup jobs. We specify their parameters and precedence relations such that the optimal solution value of the modified problem obtained by ignoring the setup times, not the setup jobs, is no larger than the optimal solution value of the original problem. One lower bound for the modified problem proceeds by allowing preemption. Due to the agreeable precedence structure, the preemptive problem is solvable in On log n time.
TL;DR: In the case of unit execution times and integer lengths of delays, the problem is NP-hard in the strong sense, and an O(n2) optimal algorithm is provided.
TL;DR: It is proved in this note that single-machine scheduling with a common due date to minimize earliness-tardiness and batch delivery costs is strongly NP-hard by a simple reduction from 3-Partition.
TL;DR: Four alternative local search methods are proposed: multi-start descent, simulated annealing, tabu search and a genetic algorithm; the best results are obtained with the genetic algorithm.
TL;DR: The paper develops a new decomposition rule and presents a special and very fast branch and bound algorithm based on pure decomposition that is tested on 2400 problems whose sizes vary from 100 to 150 jobs.
01 Dec 1996
TL;DR: It is proved that the single machine scheduling problem studied to improve the efficiency of an automated medical laboratory is nonpolynomial (NP)-complete and three heuristics for large size problems and a branch and bound based algorithm for small size problems are proposed.
Abstract: We consider a single machine scheduling problem which we studied to improve the efficiency of an automated medical laboratory. In this problem, there are not only chain structured precedence constraints, but also minimal and maximal times separating successive jobs in the same chain (separation time windows). The criterion to be minimized is the makespan. Potential applications are not restricted to medical analysis. This problem often arises in systems where chemical processes are involved. Therefore the problem studied in this paper is important in practice. We prove that the problem is nonpolynomial (NP)-complete. As a consequence, we propose three heuristics for large size problems and a branch and bound based algorithm for small size problems. Computational results are reported.
TL;DR: An NP-hardness proof is presented for the problem of minimizing the total amount of allocated resource subject to a limited number of tardy jobs and a pseudo-polynomial-time dynamic programming algorithm is proposed for constructing the trade-off curve.
TL;DR: This article considers the single-machine dynamic scheduling problem where the jobs have different arrival times and the objective is to minimize the sum of completion times and develops decomposition results that can be used with any implicit enumeration method to develop an optimal algorithm.
Abstract: This article considers the single-machine dynamic scheduling problem where the jobs have different arrival times and the objective is to minimize the sum of completion times. This problem is known to be strongly NP-hard. We develop decomposition results for this problem such that a large problem can be solved by combining optimal solutions for several smaller problems. The decomposition results can be used with any implicit enumeration method to develop an optimal algorithm. Our computational experiment indicates that the computational efficiency of the currently best available branch-and-bound algorithm can be improved with the use of our decomposition results. © 1996 John Wiley & Sons, Inc.
TL;DR: The results of a simulation experiment indicate that the proposed annealing approach for solving the single machine mean tardiness scheduling problem provides much better solutions than two heuristics that gave good results in previous studies.
TL;DR: It is shown that the single machine scheduling problem with multiple operations per job separated by minimum specified time-lags is NP-hard in the strong sense and seven simple and polynomially bounded heuristic algorithms are developed for its solution.
Abstract: This paper shows that the single machine scheduling problem with multiple operations per job separated by minimum specified time-lags is NP-hard in the strong sense. Seven simple and polynomially bounded heuristic algorithms are developed for its solution when each job requires only two operations. Empirical evaluation shows that the percentage deviation of the heuristic solutions from their lower bounds is quite low and the effectiveness of these heuristic algorithms in finding optimal schedules increases with an increase in the number of jobs.
TL;DR: This paper relaxes this restriction and allows for idle time immediately prior to starting the first job on the machine, and presents a branch-and-bound methodology for the problem.
01 Jan 1996
TL;DR: This paper discusses how Dantzig Wolfe decomposition techniques can be applied to alleviate the di culties associated with the size of time indexed formulations and that the application of these techniques still allows the use of cut generation techniques.
Abstract: Time indexed formulations for single machine scheduling problems have received a lot of attention because the linear program relaxations provide strong bounds Unfortunately time indexed formulations have one major disadvantage their size Even for relatively small instances the number of constraints and the number of variables can be large In this paper we discuss how Dantzig Wolfe decomposition techniques can be applied to alleviate the di culties associated with the size of time indexed formulations and that the application of these techniques still allows the use of cut generation techniques
TL;DR: In this paper, a branch-and-bound based algorithm was proposed to solve the single machine scheduling problem with the constraints of prespecified ready and due times and the assumption of sequence-dependent setup times.
TL;DR: A new polynomial-time heuristic is proposed based on a number of necessary conditions for a schedule to minimize mean flow time, and its performance is compared with some existing heuristics.
Abstract: This paper examines the problem of scheduling jobs on a single machine with set-up times. The jobs are divided into mutually exclusive classes and a set-up task is required when processing switches from a job of one class to a job of another class. The set-up times are assumed to be sequence independent. A number of necessary conditions for a schedule to minimize mean flow time have previously been stated, but do not uniquely define the optimal solution, and the problem is apparently NP-complete. We propose a new polynomial-time heuristic, based on these conditions, and compare its performance with some existing heuristics.