Two-machine Open Shop Problem Research Articles

Two-machine open shop problem with a single server and set-up time considerations

We address in this paper the two-machine open shop problem with set-up time considerations to build schedules that minimize the overall completion time, known as the makespan. In the model we are considering, the set-up, handled by a single server, consists of a preparation phase separated from the processing phase. Once the server completes the preparation of a job, it becomes again available for setting up other jobs, leaving the current one to complete its processing. We prove several NP-completeness results, exhibit a linear time algorithm for a special case, and develop heuristic and hyper-heuristic algorithms to solve the general problem along with an experimental study.

Two-machine open shop problem with agreement graph

This paper addresses the problem of scheduling jobs on a two-machine open shop subject to constraints given by an agreement graph G, such that jobs can be processed simultaneously on different machines if and only if they are represented by adjacent vertices in G. The problem of minimizing the maximum completion time (makespan) is strongly NP-hard for three distinct values of processing times and for G being a bipartite graph. We extend the study presented in [3] and [4] to the proportionate open shop system. We first prove the NP-hardness of the case of two values of processing times and more general agreement graphs which closes definitely the complexity status of the problem. Then, we present some restricted cases that can be solved in polynomial time. We also derive new complexity results of the open shop under resource constraints and of the partition into triangles problem.

No-idle, no-wait: when shop scheduling meets dominoes, Eulerian paths and Hamiltonian paths

In shop scheduling, several applications require that some components perform consecutively. We refer to “no-idle schedules” if machines are required to operate with no inserted idle time and to “no-wait schedules” if tasks cannot wait between the end of an operation and the start of the following one. We consider here no-idle/no-wait shop scheduling problems with makespan as the performance measure and determine related complexity results. We first analyse the two-machine no-idle/no-wait flow shop problem and show that it is equivalent to a special version of the game of dominoes which is polynomially solvable by tackling an Eulerian path problem on a directed graph. We present for this problem an O(n) exact algorithm. As a by-product, we show that the Hamiltonian path problem on a digraph G(V, A) with a special structure (where any two vertices i and j either have all successors in common or have no common successors) reduces to the two-machine no-idle/no-wait flow shop problem. Correspondingly, we provide a new polynomially solvable special case of the Hamiltonian path problem. Then, we show that also the m-machine no-idle/no-wait flow shop problem is polynomially solvable and provide an $$O(mn \log n)$$ exact algorithm. Finally, we prove that the decision versions of the two-machine job shop problem and the two-machine open shop problem are NP-complete in the strong sense.

Minimizing the number of tardy jobs in two-machine settings with common due date

We consider two-machine scheduling problems with job selection. We analyze first the two-machine open shop problem and provide a best possible linear time algorithm. Then, a best possible linear time algorithm is derived for the job selection problem on two unrelated parallel machines. We also show that an exact approach can be derived for both problems with complexity $$O(p(n) \times \sqrt{2}^n)$$O(p(n)×2n), p being a polynomial function of n.

Scheduling the two-machine open shop problem under resource constraints for setting the jobs

This paper addresses the problem of open shop scheduling on two machines with resources constraints. In the context of our study, in order to be executed, a job requires first, for its preparation for a given period of time, a number of resources which cannot exceed a given resource capacity. Then, it goes onto its execution while the resources allocated to it become available again. We seek a schedule that minimizes the makespan. We first prove the $\mathcal{N}\mathcal{P}$ -hardness of several versions of this problem. Then, we present a well solvable case, lower bounds, and heuristic algorithms along with an experimental study.

The two-machine open-shop problem with unit-time operations and time delays to minimize the makespan

This paper addresses the problem of scheduling unit-time operations with integral and non-negative time delay considerations on a two-machine open-shop environment. The criterion to minimize is the makespan. Two well solvable cases and two approximation algorithms, with their worst-case analyses, are presented.

Two-machine open shop problem with controllable processing times

We consider a two-machine open shop problem in which the job processing times are controllable and can be compressed while incurring additional costs. We show that the problem of minimizing a linear compression cost function for a given upper bound on the makespan can be solved in O ( n ) time. For the bicriteria problem of minimizing the makespan and compression cost, we propose an O ( n log n ) algorithm that finds all breakpoints of the efficient frontier.

Two machine preemptive scheduling problem with release dates, equal processing times and precedence constraints

We consider a scheduling problem with two identical parallel machines and n jobs. For each job we are given its release date when job becomes available for processing. All jobs have equal processing times. Preemptions are allowed. There are precedence constraints between jobs which are given by a (di)graph consisting of a set of outtrees and a number of isolated vertices. The objective is to find a schedule minimizing mean flow time. We suggest an O( n 2) algorithm to solve this problem. The suggested algorithm also can be used to solve the related two-machine open shop problem with integer release dates, unit processing times and analogous precedence constraints.

The two-machine open shop problem: To fit or not to fit, that is the question

We consider the open shop scheduling problem with two machines. Each job consists of two operations, and it is prescribed that the first (second) operation has to be executed by the first (second) machine. The order in which the two operations are scheduled is not fixed, but their execution intervals cannot overlap. We are interested in the question whether, for two given values D 1 and D 2, there exists a feasible schedule such that the first and second machine process all jobs during the intervals [0, D 1] and [0, D 2], respectively. We formulate four simple conditions on D 1 and D 2, which can be verified in linear time. These conditions are necessary and sufficient for the existence of a feasible schedule. The proof of sufficiency is algorithmical, and yields a feasible schedule in linear time. Furthermore, we show that there are at most two non-dominated points ( D 1, D 2) for which there exists a feasible schedule.

On the complexity and some properties of multi-stage scheduling problems with earliness and tardiness penalties

In this paper, the complexity and some other properties of several multi-stage problems with a non-regular performance measure are investigated. Mainly, we deal with two-machine problems. The problems are extensions of a one-machine problem with a common due date and a non-regular optimization criterion, where the sum of absolute deviations of the completion times from the due date is to be minimized. There are two reasonable generalizations: Either, the objective function is kept the same as in the one-machine problem, where the completion time is now the completion time of the last operation of the job, or a second penalty is added to this term which takes into account the storage costs of the intermediate. For both types of problems, we study the flow shop, the job shop, and the open shop environment. In the case of intermediate storage costs, we distinguish the cases of a due date d=0 (which leads to a regular optimization criterion) and a non-restrictive due date. We obtain the following results. The two-machine flow shop problem with intermediate storage costs defined in this paper is NP-hard in the strong sense for d=0 as well as for a non-restrictive due date. We prove the similar results for the two-machine open shop problem. In absence of intermediate storage costs, the open shop and the job shop problem are polynomially solvable for a non-restrictive due date. Scope and purpose The just-in-time production philosophy has lead to a growing interest in scheduling problems considering both earliness and tardiness penalties. Most publications considering these so-called non-regular objective functions are devoted to single-stage problems. This paper describes the two main approaches to extend the objective function to multi-stage environments and investigates the computational complexity of the problems obtained. The investigations in this paper may serve as a starting point for the development of appropriate algorithms for the type of problem considered.

The complexity of two group scheduling problems

The problems of scheduling groups of jobs under the group technology assumption are studied. The two remaining open questions posed in the literature a decade ago about the computational complexity of these problems (J. Oper. Res. Soc., 1992; 43:395–406), are answered. The parallel machine problem to minimize the total job completion time is proved to be NP-hard in the strong sense, even if group set-up times are equal to zero. A dynamic programming algorithm is presented to solve this problem, which is polynomial if the number of machines is fixed. The two-machine open-shop problem to minimize the makespan is proved to be NP-hard in the ordinary sense, even if there are zero group set-up times and equal job processing times on both machines. It is shown that the latter problem under the condition that any group can be split into batches does not reduce to the problem where the splittings are not allowed, i.e. the group technology assumption is satisfied. Copyright © 2002 John Wiley & Sons, Ltd.

NP-hard cases in scheduling deteriorating jobs on dedicated machines

In this paper problems of time-dependent scheduling on dedicated machines are considered. The processing time of each job is described by a function which is dependent on the starting time of the job. The objective is to minimise the maximum completion time (makespan). We prove that under linear deterioration the two-machine flow shop problem is strongly NP-hard and the two-machine open shop problem is ordinarily NP-hard. We show that for the three-machine flow shop and simple linear deterioration there does not exist a polynomial-time approximation algorithm with the worst case ratio bounded by a constant, unless P=NP. We also prove that the three-machine open shop problem with simple linear deterioration is ordinarily NP-hard, even if the jobs have got equal deterioration rates on the third machine.

Minimizing the weighted number of late jobs in UET open shops

We consider a two-machine open shop problem where the jobs have release dates and due dates, and where all single operations have unit processing times. The goal is to minimize the weighted number of late jobs. We derive a polynomial time algorithm for this problem, thereby answering an open question posed in a recent paper by Brucker et al.