Scheduling linear deteriorating jobs to minimize makespan with an availability constraint on a single machine

The scheduling problem with deteriorating jobs to minimize the makespan on a single machine where the facility has an availability constraint is studied in this paper. By a deteriorating job we mean that the processing time for the job is a function of its starting time. Even with the introduction of the availability to a facility, the linear deteriorating model can be solved using the 0-1 integer programming technique if the actual job processing time is proportional to the starting time.     

Scheduling resumable simple linear deteriorating jobs on a single machine with an availability constraint to minimize makespan

We consider a single-machine scheduling problem in which the processing time of each job is a simple linear deteriorating function of its waiting time. The machine is subject to an availability constraint. Jobs interrupted by machine unavailability can resume their processing. The objective is to minimize the makespan. We first show that the problem can be solved optimally by 0–1 integer programming. We then prove that the problem is NP-hard in the ordinary sense and there exists a fully polynomial time approximation scheme for it.     

Two-agent singe-machine scheduling with release times to minimize the total weighted completion time

In many management situations multiple agents pursuing different objectives compete on the usage of common processing resources. In this paper we study a two-agent single-machine scheduling problem with release times where the objective is to minimize the total weighted completion time of the jobs of one agent with the constraint that the maximum lateness of the jobs of the other agent does not exceed a given limit. We propose a branch-and-bound algorithm to solve the problem, and a primary and a secondary simulated annealing algorithm to find near-optimal solutions. We conduct computational experiments to test the effectiveness of the algorithms. The computational results show that the branch-and-bound algorithm can solve most of the problem instances with up to 24 jobs in a reasonable amount of time and the primary simulated annealing algorithm performs well with an average percentage error of less than 0.5% for all the tested cases.     

An approximation scheme for two-machine flowshop scheduling with setup times and an availability constraint

This paper studies the two-machine permutation flowshop scheduling problem with anticipatory setup times and an availability constraint imposed only on the first machine. The objective is to minimize the makespan. Under the assumption that interrupted jobs can resume their operations, we present a polynomial-time approximation scheme for this problem.     

Parallel-machine scheduling with an availability constraint

e consider two parallel machines scheduling problem where one machine is not available in a specified time period. The unavailable time period is fixed and known in advance. The objective is to minimize the total weighted completion time. The problem is known to be NP-hard. We give a fully polynomial-time approximation scheme (FPTAS) for the problem. We then generalize the results to the case with m parallel machines.     

Single-machine scheduling to minimize total convex resource consumption with a constraint on total weighted flow time

In this paper, we consider single-machine scheduling problem in which processing time of a job is described by a convex decreasing resource consumption function. The objective is to minimize the total amount of resource consumed subject to a constraint on total weighted flow time. The optimal resource allocation is obtained for any arbitrary job sequence. The computational complexity of the general problem remains an open question, but we present and analyze some special cases that are solvable by using polynomial time algorithms. For the general problem, several dominance properties and some lower bounds are derived, which are used to speed up the elimination process of a branch-and-bound algorithm proposed to solve the problem. A heuristic algorithm is also proposed, which is shown by computational experiments to perform effectively and efficiently in obtaining near-optimal solutions. The results show that the average percentage error of the proposed heuristic algorithm from optimal solutions is less than 3%.     

A branch-and-bound algorithm to minimize total weighted completion time on identical parallel machines with job release dates

In this paper, we consider an identical parallel machine scheduling problem with release dates. The objective is to minimize the total weighted completion time. This problem is known to be strongly NP-hard. We propose some dominance properties and two lower bounds. We also present an efficient heuristic. A branch-and-bound algorithm, in which the heuristic, the lower bounds and the dominance properties are incorporated, is proposed and tested on a large set of randomly generated instances.     

Single machine scheduling problem with interval processing times to minimize mean weighted completion time

The single resource scheduling problem is commonly applicable in practice not only when there is a single resource but also in some multiple-resource production systems where only one of the resources is bottle neck. Thus, the single resource (machine) scheduling problem has been widely addressed in the scheduling literature. In this paper, the single machine scheduling problem with uncertain and interval processing times is addressed. The objective is to minimize mean weighted completion time. The problem has been addressed in the literature and efficient heuristics have been presented. In this paper, some new polynomial time heuristics, utilizing the bounds of processing times, are proposed. The proposed and existing heuristics are compared by extensive computational experiments. The conducted experiments include a generalized simulation environment and several additional representative distributions in addition to the restricted experiments used in the literature. The results indicate that the proposed heuristics perform significantly better than the existing heuristics. Specifically, the best performing proposed heuristic reduces the error of the best existing heuristic in the literature by more than 75% while the computational time of the best performing proposed heuristic is less than that of the best existing heuristic. Moreover, the absolute error of the best performing heuristic is only about 1% of the optimal solution. Having a very small absolute error along with a negligible computational time indicates the superiority of the proposed heuristics.     

Flow shop scheduling to minimize the total completion time with a permanently present operator: Models and ant colony optimization metaheuristic

This paper studies the one-operator m-machine flow shop scheduling problem with the objective of minimizing the total completion time. In this problem, the processing of jobs and setup of machines require the continuous presence of a single operator. We compare three different mathematical formulations and propose an ant colony optimization based metaheuristic to solve this flow shop scheduling problem. A series of experiments are carried out to compare the properties of three formulations and to investigate the performance of the proposed ant colony optimization metaheuristic. The computational results show that (1) an assignment-based formulation performs best, and (2) the ant colony optimization based metaheuristic is a computationally efficient algorithm.     

Openshop and flowshop scheduling to minimize sum of completion times

This paper deals with efficiently solvable special cases of openshop and permutation-flowshop scheduling where the objective function is minimum sum of completion times.Two O(mn) algorithms for openshop scheduling where all operations have equal processing times, are presented. The first constructs a no-wait schedule and the second a schedule where both criteria (sum of completion times and schedule length) take on their minimal values.For permutation-flowshop scheduling where processing times satisfy dominancy and/or ordered relations, SPT rules are proved to be optimal.     

A branch, bound, and remember algorithm for the 1|r i |∑t i scheduling problem

This paper presents a modified Branch and Bound (B&B) algorithm called, the Branch, Bound, and Remember (BB&R) algorithm, which uses the Distributed Best First Search (DBFS) exploration strategy for solving the 1|r _i |∑t _i scheduling problem, a single machine scheduling problem where the objective is to find a schedule with the minimum total tardiness. Memory-based dominance strategies are incorporated into the BB&R algorithm. In addition, a modified memory-based dynamic programming algorithm is also introduced to efficiently compute lower bounds for the 1|r _i |∑t _i scheduling problem. Computational results are reported, which shows that the BB&R algorithm with the DBFS exploration strategy outperforms the best known algorithms reported in the literature.     

Optimizing blocking flow shop scheduling problem with total completion time criterion

The blocking flow shop scheduling problem has found many applications in manufacturing systems. There are a few exact methods for solving this problem with different criteria. In this paper, efforts will be made to optimize the total completion time criterion for this problem. We present two mixed binary integer programming models, one of which is based on the departure times of jobs from machines, and the other is based on the idle and blocking times of jobs. An initial upper bound generator and some lower bounds and dominance rules are also developed to be used in a branch and bound algorithm. The algorithm solves 17 instances of the Taillard's benchmark problem set in less than 20 min.     

Minimizing total weighted completion time under makespan constraint for two-agent scheduling with job-dependent aging effects

In this paper, we consider a two-agent single-machine scheduling problem with linear position-based aging effects and job-dependent aging ratios. The objective is to minimize the total weighted completion time of all jobs for two agents, where the makespan for one agent is constrained under an upper bound. After showing that this problem is at least NP-hard, we develop two solution algorithms: First, we devise a branch-and-bound algorithm to find an optimal solution through the establishment of several dominance and feasibility properties, and a lower bound. Second, we propose efficient simulated annealing algorithms, using three different methods to generate an initial solution. Through a numerical experiment, we demonstrate that the suggested algorithms can be applied to efficiently find near-optimal solutions within a reasonable amount of CPU time. In particular, we show that the initial solution method (arranging the jobs for one agent in non-increasing order of aging ratio, and scheduling the jobs for the other in the weighted shortest normal processing time order) is superior to others. Moreover, through scalability testing, we verify its consistent and relatively outstanding performance for larger systems with many processing jobs.     

Makespan minimization for two parallel machines scheduling with a periodic availability constraint

A two parallel machines scheduling problem where one machine is periodically unavailable with the objective of minimizing makespan is considered. It is showed that the worst-case ratio of the classical LPT algorithm and the competitive ratio of the LS algorithm are 3/2 and 2, respectively, for the offline version and the online version of the problem.     

A branch-and-bound algorithm for single-machine scheduling with batch delivery and job release times

This paper addresses scheduling a set of jobs with specified release times on a single machine for delivery in batches to customers or to other machines for further processing. This problem is a natural extension of minimizing the sum of flow times in the presence of release time by considering the possibility of delivering jobs in batches and introducing batch delivery costs. The scheduling objective adopted is that of minimizing the sum of flow times and delivery costs. The extended problem arises in the context of coordination between machine scheduling and a distribution system in a supply chain network. Structural properties of the problem are investigated and used to devise a branch-and-bound solution scheme. Computational experiments show significant improvement over an existing dynamic programming algorithm.     

The two-stage assembly scheduling problem to minimize total completion time with setup times

We address the two-stage assembly scheduling problem where there are m machines at the first stage and an assembly machine at the second stage. The objective is to schedule the available n jobs so that total completion time of all n jobs is minimized. Setup times are treated as separate from processing times. This problem is NP-hard, and therefore we present a dominance relation and propose three heuristics. The heuristics are evaluated based on randomly generated data. One of the proposed heuristics is known to be the best heuristic for the case of zero setup times while another heuristic is known to perform well for such problems. A new version of the latter heuristic, which utilizes the dominance relation, is proposed and shown to perform much better than the other two heuristics.     

A new Lagrangian relaxation algorithm for hybrid flowshop scheduling to minimize total weighted completion time

We investigate the problem of scheduling n jobs in s-stage hybrid flowshops with parallel identical machines at each stage. The objective is to find a schedule that minimizes the sum of weighted completion times of the jobs. This problem has been proven to be NP-hard. In this paper, an integer programming formulation is constructed for the problem. A new Lagrangian relaxation algorithm is presented in which precedence constraints are relaxed to the objective function by introducing Lagrangian multipliers, unlike the commonly used method of relaxing capacity constraints. In this way the relaxed problem can be decomposed into machine type subproblems, each of which corresponds to a specific stage. A dynamic programming algorithm is designed for solving parallel identical machine subproblems where jobs may have negative weights. The multipliers are then iteratively updated along a subgradient direction. The new algorithm is computationally compared with the commonly used Lagrangian relaxation algorithms which, after capacity constraints are relaxed, decompose the relaxed problem into job level subproblems and solve the subproblems by using the regular and speed-up dynamic programming algorithms, respectively. Numerical results show that the new Lagrangian relaxation method produces better schedules in much shorter computation time, especially for large-scale problems.     

Scheduling machine-dependent jobs to minimize lateness on machines with identical speed under availability constraints

In this paper we consider the problem of scheduling n$n$ preemptive jobs on m$m$ machines with identical speed under machine availability and eligibility constraints when minimizing maximum lateness (_Lmax$(L_{\max }$). The lateness of a job is defined to be its completion time minus its due date, and _Lmax$L_{\max }$ is the maximum value of lateness among all jobs. We assume that each machine is not continuously available at all time throughout the planning horizon and each job is only allowed to be processed on specific machines. Network flow technique is used to formulate this scheduling problem into a series of maximum flow problems. We propose a polynomial time two-phase binary search algorithm to verify the feasibility of the problem and to solve the scheduling problem optimally if a feasible schedule exists. Finally, we show that the time complexity of the algorithm is O((n+(2n+2x))³log(UB-LB))$O((n+(2n+2x){)}^3\log (\text{<italic>UB</italic>}-\text{<italic>LB</italic>}))$. Most literature in parallel machine scheduling assume that all machines are continuously available for processing and all jobs can be processed at any available machine throughout the planning horizon. But both assumptions might not be true in some practical environment, such as machine preventive maintenance and machines that have different capabilities to process jobs. This type of scheduling problem is seldom studied in the literature. The purpose of this paper is to examine the scheduling problem with machines with identical speed under machine availability and eligibility constraints. The objective is to minimize maximum lateness. We formulate this scheduling problem into a series of maximum flow problems with different values of _Lmax$L_{\max }$. A polynomial time two-phase binary search algorithm is proposed to verify the feasibility of the problem and to determine the optimal _Lmax$L_{\max }$.