Unit-time Operations Research Articles

Mixed Graph Colouring as Scheduling a Partially Ordered Set of Interruptible Multi-Processor Tasks with Integer Due Dates

We investigate relationships between scheduling problems with the bottleneck objective functions (minimising makespan or maximal lateness) and problems of optimal colourings of the mixed graphs. The investigated scheduling problems have integer durations of the multi-processor tasks (operations), integer release dates and integer due dates of the given jobs. In the studied scheduling problems, it is required to find an optimal schedule for processing the partially ordered operations, given that operation interruptions are allowed and indicated subsets of the unit-time operations must be processed simultaneously. First, we show that the input data for any considered scheduling problem can be completely determined by the corresponding mixed graph. Second, we prove that solvable scheduling problems can be reduced to problems of finding optimal colourings of corresponding mixed graphs. Third, finding an optimal colouring of the mixed graph is equivalent to the considered scheduling problem determined by the same mixed graph. Finally, due to the proven equivalence of the considered optimisation problems, most of the results that were proven for the optimal colourings of mixed graphs generate similar results for considered scheduling problems, and vice versa.

On the complexity of open shop scheduling with time lags

The minimization of makespan in open shop with time lags has been to be shown NP-hard in the strong sense even for the case of two machines and unit-time operations. The minimization of total completion time, however, has remained open for that case though it has been it be shown NP-hard in the strong sense for weighted total completion time or for jobs with release dates. This note shows that the minimization of total completion time for two machines and unit-time operations is NP-hard in the strong sense which answers the long standing open question.

Mixed graph colouring for unit-time scheduling

We consider the job shop scheduling problem with unit-time operations and the makespan criterion. This problem is reduced to finding an optimal colouring of a special class of mixed graph, where its partial graph without edges represents the union of maximal directed paths and its partial graph without arcs represents the union of maximal cliques. As the problem is known to be NP-hard, both exact and heuristic methods are proposed to solve it. This study is carried out in three steps. First, a new lower and upper bounds for the mixed chromatic number are proposed. Afterwards, a colour-indexed mathematical model using the proposed bounds is developed. Then, a tabu search using a dynamic neighbourhood structure is adapted for solving large instances. Computational experiments conducted on several modified benchmarks show the efficiency and effectiveness of the proposed resolution methods.

Two-machine flow shop problem with unit-time operations and conflict graph

This paper addresses the problem of scheduling, on a two-machine flow shop, a set of unit-time operations subject to the constraints that some conflicting jobs cannot be scheduled simultaneously on different machines. In the context of our study, these conflicts are modelled by general graphs. The problem of minimising the maximum completion time (makespan) is known to be NP-hard in the strong sense. We propose a mixed-integer linear programming (MILP) model. Then, we develop a branch and bound algorithm based on new lower and upper bound procedures. We further provide a computer simulation to measure the performance of the proposed approaches. The computational results show that the branch and bound algorithm outperforms the MILP model and can solve instances of size up to 20,000 jobs.

Extensible sparse functional arrays with circuit parallelism

A longstanding open question in algorithms and data structures is the time and space complexity of pure functional arrays. Imperative arrays provide update and lookup operations that require constant time in the Random Access Machine (RAM) theoretical model, but it is conjectured that there does not exist a RAM algorithm that achieves the same complexity for functional arrays, unless restrictions are placed on the operations. The main result of this paper is an algorithm that does achieve optimal unit time and space complexity for update and lookup on functional arrays. This algorithm does not run on a RAM, but instead it exploits the massive parallelism inherent in digital circuits. The algorithm also provides unit time operations that support storage management, as well as sparse and extensible arrays. The main idea behind the algorithm is to replace a RAM memory by a tree circuit that is more powerful than the RAM yet has the same asymptotic complexity in time (gate delays) and size (number of components). The algorithm uses an array representation that allows elements to be shared between many arrays with only a small constant factor penalty in space and time. This system exemplifies circuit parallelism, which exploits large numbers of transistors per chip in order to speed up key algorithms. Extensible Sparse Functional Arrays (ESFA) can be used with both functional and imperative programming languages. The system comprises a set of algorithms and a circuit specification, and it has been implemented on a GPGPU.

A branch and bound algorithm for the two-machine flowshop problem with unit-time operations and time delays

In this paper we consider the problem of scheduling, on a two-machine flowshop, a set of unit-time operations subject to time delays with respect to the makespan. This problem is known to be \hbox{${\cal NP}$}-hard in the strong sense. We propose an algorithm based on a branch and bound enumeration scheme. This algorithm includes the implementation of new lower and upper bound procedures, and dominance rules. A computer simulation to measure the performance of the algorithm is provided for a wide range of test problems.

The coupled unit-time operations problem on identical parallel machines with respect to the makespan

This paper addresses the problem of scheduling n unit-time coupled operations on m identical parallel machines with minimum time delay considerations so as to minimize the overall completion time, known as the makespan. Two approximation algorithms, along with their worst-case analysis, are presented.

Scheduling of a Job Shop with Two Machine Centers Having Parallel Machines

A job-shop with two machine centers with the second one consisting of k parallel machines is considered. An approximate algorithm for minimizing schedule length in the job shop with unit time operations in the first machine center and k time-units operations in the second is proposed. The algorithm has the absolute worst case error bound of k-1. Thus, the algorithm is optimal for k=1. Moreover, the algorithm can be modified to give optimal schedules for k=2. The paper extends considerably the earlier works on two machine job shops with unit time operations.

Scheduling flexible flowshops with unit-time operations and minimum time delays

In this paper, we consider the flexible flowshop problem with unit-time operations and minimum time delays. We present two simple heuristic algorithms to solve this problem along with their worst-case analyses.

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.

Open shop unit-time scheduling problems with symmetric objective functions

The paper addresses the open-shop scheduling problem with unit-time operations and nondecreasing symmetric objective function depending on job completion times. We construct two schedules, one being optimal for any symmetric convex function, the other one for any symmetric concave function. Both schedules are given by analytically defined formulas that determine in O(1) time for each operation the unit-length time slot for its processing.

The [formula omitted]-machine flowshop problem with unit-time operations and intree precedence constraints

We consider the flowshop problem with unit-time operations and intree precedence constraints, with the objective to minimize the total completion time. We present a polynomial-time algorithm assuming that the number of machines is fixed. This proves a recently stated conjecture.

Minimizing Makespan in a Two-Machine Flow Shop with Delays and Unit-Time Operations is NP-Hard

One of the first problems to be studied in scheduling theory was the problem of minimizing the makespan in a two-machine flow shop. Johnson showed that this problem can be solved in O(n log n) time. A crucial assumption here is that the time needed to move a job from the first to the second machine is negligible. If this is not the case and if this ‘delay’ is not equal for all jobs, then the problem becomes NP-hard in the strong sense. We show that this is even the case if all processing times are equal to one. As a consequence, we show strong NP-hardness of a number of similar problems, including a severely restricted version of the Numerical 3-Dimensional Matching problem.

Minimizing the number of late jobs for the two-machine unit-time job-shop scheduling problem

This paper considers the problem of minimizing the weighted number of late jobs in the two-machine job-shop with unit time operations. We show its NP-hardness and propose an O( n 5∑ w i ) time algorithm, which is based on solving optimally a related problem where a maximal set of early jobs is to be determined.

A polynomial-time algorithm for the two-machine unit-time release-date job-shop schedule-length problem

We consider a polynomial-time algorithm for the following scheduling problem: Given two machines, where each machine can process at most one job at a time; a set of jobs, where each job can start on or after its release date and consists of a chain of unit-time operations such that the machines have to process them by turn begining with a given machine; find a schedule minimizing the maximum job completion time. Formerly, only pseudopolynomial-time algorithms have been proposed for this problem.

On complexity of minimizing weighted number of late jobs in unit time open shops

We show that the problem of minimizing the weighted number of late jobs in open shop with given release dates and unit time operations is strongly NP -hard. The complexity status of this problem was unknown.

Total completion time minimization in two-machine job shops with unit-time operations

We study the problem of minimizing total completion time in two-machine job shop with unit-time operations. We propose an efficient algorithm for the problem. The algorithm is polynomial with respect to a succinct encoding of the problem instances, where the number of bits necessary to encode a job with k operations is O(log( k + 1)). This result answers a long standing open question about the complexity of the problem.

Scheduling unit time open shops to minimize the weighted number of late jobs

We present a polynomial algorithm for the problem of scheduling an open shop with unit time operations for a fixed number of machines such that the weighted number of late jobs is minimized. The algorithm is based on dynamic programming. The complexity of this problem was unknown for open shops with more than two machines.

Open shop problems with unit time operations

We show that them-machine open shop problem in which all operations have unit processing times can be polynomially transformed to a special preemptive scheduling problem onm identical parallel machines. Many results published recently as well as some new results are derived by using this transformation. The new results include solutions of open problems mentioned in a recent paper by Kubiak et al. p]A similar relationship is derived between no-wait open shop problems with unit time operations andm-machine problems with jobs having unit processing times.

Job shop scheduling with unit time operations under resource constraints and release dates

We consider the problem of job shop scheduling with m machines and n jobs J i , each consisting of l i unit time operations. There are s distinct resources R h and a quantity q h available of each one. The execution of the j-th operation of J i requires the presence of u ijh units of R h , 1 ≤ i≤ n, 1 ≤ j≤ l i , and 1 ≤ h≤ s. In addition, each J i has a release date r i , that is J i cannot start before time r i . We describe algorithms for finding schedules having minimum length or sum of completion times of the jobs. Let l=max{ l i } and u=|{ u ijh }|. If m, u and l are fixed, then both algorithms terminate within polynomial time.