Unit Processing Time Jobs Research Articles

Makespan minimization with OR-precedence constraints

We consider a variant of the NP-hard problem of assigning jobs to machines to minimize the completion time of the last job. Usually, precedence constraints are given by a partial order on the set of jobs, and each job requires all its predecessors to be completed before it can start. In this paper, we consider a different type of precedence relation that has not been discussed as extensively and is called OR-precedence. In order for a job to start, we require that at least one of its predecessors is completed—in contrast to all its predecessors. Additionally, we assume that each job has a release date before which it must not start. We prove that a simple List Scheduling algorithm due to Graham (Bell Syst Tech J 45(9):1563–1581, 1966) has an approximation guarantee of 2 and show that obtaining an approximation factor of 4/3 - varepsilon is NP-hard. Further, we present a polynomial-time algorithm that solves the problem to optimality if preemptions are allowed. The latter result is in contrast to classical precedence constraints where the preemptive variant is already NP-hard. Our algorithm generalizes previous results for unit processing time jobs subject to OR-precedence constraints, but without release dates. The running time of our algorithm is O(n^2) for arbitrary processing times and it can be reduced to O(n) for unit processing times, where n is the number of jobs. The performance guarantees presented here match the best-known ones for special cases where classical precedence constraints and OR-precedence constraints coincide.

Scheduling problems with a weight-modifying-activity

We study single machine scheduling problems with an additional option of performing a weight-modifying-activity. If such an activity is performed, the cost of subsequent jobs is reduced, as reflected by smaller job-weights. We focus first on minimizing total weighted completion time. A pseudo-polynomial dynamic programming algorithm is introduced for this problem. Several special cases of unit processing time jobs are solved in polynomial time. We also solve in polynomial time (an extension of) the minmax version of the problem, by adapting the well-known Lawler’s Algorithm for minimizing maximum cost on a single machine.

Two-agent scheduling of unit processing time jobs to minimize total weighted completion time and total weighted number of tardy jobs

In this paper, we revisit a two-agent scheduling problem on a single machine with jobs of unit processing times. In this problem, we have two agents: agent A and agent B. Each agent has his/her own disjoint job set. The objective of agent A is to minimize the total weighted completion time, and the objective of agent B is to minimize the total weighted number of tardy jobs. The complexity of the decision version of the problem was proposed as open in Oron et al. (European Journal of Operational Research 244:86–99, 2015). We construct a reduction from a variant of Even-Odd Partition to show that this problem is NP-complete. Finally, we also propose a pseudo-polynomial algorithm and a dual FPTAS for the problem.

An improved algorithm for due-window assignment on parallel identical machines with unit-time jobs

We study a due-window assignment problem on parallel identical machines, with unit processing time jobs. The objective function is minimum total cost, consisting of earliness, tardiness, due-window starting time and due-window size. A recent paper (Janiak et al., 2012) introduced a solution algorithm requiring O(n5/m2) time, where n is the number of jobs, and m is the number of machines. We propose a significantly faster procedure, requiring O(n3) only.

The equal allocation policy in open shop batch scheduling

We study the optimality of the very practical policy of equal allocation of jobs to batches in batch scheduling problems on an m-machine open shop. The objective is minimum makespan. We assume unit processing time jobs, machine-dependent setup times and batch availability. We show that equal allocation is optimal for a two-machine and a three-machine open shop. Although, this policy is not necessarily optimal for larger size open shops, it is shown numerically to produce very close-to-optimal schedules.

Scheduling with a common due-window: Polynomially solvable cases

The single machine scheduling problem to minimize maximum weighted absolute deviations of job completion times from a common due-date, is known to be NP-hard. However, two special cases have been shown to have polynomial time solutions: the case of unit processing time jobs, and the case of due-date assignment for a given job sequence. We extend both cases to a setting of a common due-window. We show that the unit-job problem includes 12 different sub-cases, depending on the size and location of the (given) due-window. Scheduling and due-window assignment for a given job sequence is solved for a single machine, for parallel identical machines and for flow-shops. For each of the above cases, an appropriate special-structured linear program is presented.

Batch Scheduling on Two-Machine Flowshop with Machine-Dependent Setup Times

We study a batch scheduling problem on a 2-machine flowshop. We assume unit processing time jobs, batch availability, and machine-dependent setup times. The objective is to find a job allocation to batches of integer size and a batch schedule that minimize makespan. We introduce a very efficient closed form solution for the problem.

Due‐window assignment with unit processing‐time jobs

AbstractIn due‐window assignment problems, jobs completed within a designated time interval are regarded as being on time, whereas early and tardy jobs are penalized. The objective is to determine the location and size of the due‐window, as well as the job schedule. We address a common due‐window assignment problem on parallel identical machines with unit processing time jobs. We show that the number of candidate values for the optimal due‐window starting time and for the optimal due‐window completion time are bounded by 2. We also prove that the starting time of the first job on each of the machines is either 0 or 1, thus introducing a fairly simple, constant‐time solution for the problem. © 2004 Wiley Periodicals, Inc. Naval Research Logistics, 2004

Scheduling unit processing time jobs on an m-machine flow-shop

The sequential production of identical jobs and the flow-shop machine setting are extremely common in real-life applications. We study a scheduling problem that combines these two elements: jobs of identical processing time, with job-dependent weights, and a given common due date processed on an m-machine flow-shop. The (just-in-time) objective is to minimize the maximum earliness/tardiness cost. We introduce a polynomial time solution in both cases of (i) a non-restrictive (ie, sufficiently large) due date, and (ii) a restrictive due date (which restricts the number of early jobs).

On preemption redundancy in scheduling unit processing time jobs on two parallel machines

McNaughton's theorem (1959) states that preemptions in scheduling arbitrary processing time jobs on identical parallel machines to minimize the total weighted completion time are redundant. Du et al. (1991) proved that this remains true even though the jobs have precedence constraints in the form of chains. There are known simple counterexamples showing that other extensions of McNaughton's theorem to other criteria or more general precedence constraints such as intrees or outtrees, or different release dates of jobs, or different speeds of machines, are not true even for equal weights of jobs. In this paper we show that in the case of two machines and unit processing times, preemptions are still advantageous for intrees or machines with different speeds even for equal weights, or outtrees for different weights, but become redundant for outtrees and equal weights even for different release dates. We also conjecture that the latter statement is actually true for any number of machines.

Minmax earliness–tardiness costs with unit processing time jobs

The problem addressed in this paper is defined by M parallel identical machines, N jobs with identical (unit) processing time, job-dependent weights, and a common due-date for all jobs. The objective is of a minmax type, i.e. we are interested in minimizing the cost of the worst scheduled job. In the case of a non-restrictive (i.e., sufficiently large) common due-date, the problem is shown to have a solution that is polynomial in the number of jobs. The solution in the case of a restrictive due-date remains polynomial in the number of jobs, but is exponential in the number of machines. We introduce a lower bound on the optimal cost and an efficient heuristic. We show that the worst case relative error of the heuristic is bounded by 2 and that this bound is tight. We also prove that the heuristic is asymptotically optimal under very general assumptions. Finally, we provide an extensive numerical study demonstrating that in most cases the heuristic performs extremely well.

Scheduling unit processing time jobs on a single machine with multiple criteria

We examine single machine scheduling problems when all jobs have identical processing times and there are two measures of performance. The measures of performance considered are flow-time, tardiness, number of tardy jobs, the weighted counterparts for these three measures and maximum tardiness. Using the assignment model as a basis, we provide efficient algorithms for the problem when a utility function is given, when one criterion is considered to be primary and the other one secondary. We also develop algorithms that arc polynomial in the number of nondominatcd schedules to generate all nondominated schedules. Finally, we show that the methods can easily be extended to handle more than two criteria, as well as nonzero release dales.