Minimizing maximum lateness in a two-machine unit-time job shop

AnO (nlogn)-algorithm is given for the two-machine, job-shop scheduling problem withn unit-time tasks in which maximum lateness is to be minimized. This algorithm generalizes recent results by Hefetz and Adiri for the corresponding makespan problem.     

Single-machine batch delivery scheduling with an assignable common due date and controllable processing times

We consider single-machine batch delivery scheduling with an assignable common due date and controllable processing times, which vary as a convex function of the amounts of a continuously divisible common resource allocated to individual jobs. Finished jobs are delivered in batches and there is no capacity limit on each delivery batch. We first provide an O(n⁵) dynamic programming algorithm to find the optimal job sequence, the partition of the job sequence into batches, the assigned common due date, and the resource allocation that minimize a cost function based on earliness, tardiness, job holding, due date assignment, batch delivery, and resource consumption. We show that a special case of the problem can be solved by a lower-order polynomial algorithm. We then study the problem of finding the optimal solution to minimize the total cost of earliness, tardiness, job holding, and due date assignment, subject to limited resource availability, and develop an O(nlog n) algorithm to solve it.     

A minimum-cost network flow approach to preemptive parallel-machine scheduling

We model and solve the problems of preemptive scheduling of n independent jobs with release dates on m parallel machines with machine availability and eligibility constraints to minimize the makespan and maximum lateness as the minimum-cost network flow problem. We show that the approach can be extended to solve the corresponding scheduling problems on two uniform parallel machines.     

A bicriteria approach to minimize maximal lateness and resource consumption for scheduling a single machine

We extend the classical single-machine maximal lateness scheduling problem to the case where the job processing times are controllable by allocating a continuous and nonrenewable resource to the processing operations. Our aim is to construct an efficient trade-off curve between maximal lateness and total resource consumption using a bicriteria approach. We present a polynomial time algorithm that constructs this trade-off curve assuming a specified general type of convex decreasing resource consumption function. We illustrate the algorithm with a numerical example.     

Coupled-task scheduling on a single machine subject to a fixed-job-sequence

This paper investigates single-machine coupled-task scheduling where each job has two tasks separated by an exact delay. The objective of this study is to schedule the tasks to minimize the makespan subject to a given job sequence. We introduce several intriguing properties of the fixed-job-sequence problem under study. While the complexity status of the studied problem remains open, an O(n²) algorithm is proposed to construct a feasible schedule attaining the minimum makespan for a given permutation of 2n tasks abiding by the fixed-job-sequence constraint. We investigate several polynomially solvable cases of the fixed-job-sequence problem and present a complexity graph of the problem.     

A note on the scheduling with two families of jobs

Baker and Smith [J. Scheduling, 6, 7–16, 2003] introduced a new model of scheduling in which there are two or more distinct families of jobs pursuing different objectives. Their contributions include two polynomial-time dynamic programming recursions, respectively, for the single machine scheduling with two families of jobs to minimize a positive combination of total weighted completion time, or maximum lateness, of the first family of jobs and maximum lateness of the second family of jobs. Unfortunately, these dynamic programming recursions are incorrect. In this paper, we solve the same problems by an O(n₁ n₂(n₁ + n₂)) time algorithm. Project supported by NNSFC (Grant 10371112) and NSFHN (Grant 0411011200)     

On the equivalence of single machine earliness/tardiness problems with job rejection

We present optimal algorithms for single-machine scheduling problems with earliness criteria and job rejection and compare them with the algorithms for the corresponding problems with tardiness objectives. We present an optimal O(n log n) algorithm for minimizing the maximum earliness on a single machine with job rejection. Our algorithm also solves the bi-criteria scheduling problem is which the objective is to simultaneously minimize the maximum earliness of the scheduled jobs and the total rejection cost of the rejected jobs. We also show that the optimal pseudo-polynomial time algorithm for the total tardiness problem with job rejection can be used to solve the corresponding total earliness problem with job rejection.     

Unrelated parallel-machine scheduling with rate-modifying activities to minimize the total completion time

Zhao et al. (2009) [24] study the m identical parallel-machine scheduling problem with rate-modifying activities to minimize the total completion time. They show that the problem can be solved in O(n^2m+3) time. In this study we extend the scheduling environment to the unrelated parallel-machine setting and present a more efficient algorithm to solve the extended problem. For the cases where the rate-modifying rate is (i) larger than 0 and not larger than 1, and (ii) larger than 0, we show that the problem can be solved in O(n^m+3) and O(n^2m+2) time, respectively.     

A DP algorithm for minimizing makespan and total completion time on a series-batching machine

This paper studies a bicriteria scheduling problem on a series-batching machine with objective of minimizing makespan and total completion time simultaneously. A series-batching machine is a machine that can handle up to b jobs in a batch and the completion time of all jobs in a batch is equal to the finishing time of the last job in the batch and the processing time of a batch is the sum of the processing times of jobs in the batch. In addition, there is a constant setup time s for each batch. For the problem we can find all Pareto optimal solutions in O(n²) time by a dynamic programming algorithm, where n denotes the number of jobs.     

Two-directional traffic scheduling problem solution for a single-track railway with siding

The paper is concerned with scheduling trains moving in both directions between two stations connected by a single-track railway with a siding. The paper presents dynamic programming based algorithms which minimizes two objective functions: maximum lateness and total weighted completion time. The complexity of these algorithms is O(n ²).     

Note on a unified approach to the single-machine scheduling problem with a deterioration effect and convex resource allocation

In many resource allocation problems in physical or economic systems, a linear resource consumption function is commonly considered, and job processing times are assumed to be fixed parameters. However, the former assumption fails to reflect the law of diminishing returns, and the latter may be controlled by changing the allocation of resources to jobs. Motivated by these observations, we provide a unified model for solving single-machine scheduling problems in which each job's processing time is a function of its starting time and convex resource allocation. The objective is to find the optimal sequence of jobs subject to a limited resource consumption. We first show how this unified model can be useful in solving scheduling problems under due date assignment considerations. We analyze the problem with four different due date assignment methods, and our objective function includes costs for earliness, tardiness and due date assignments. We also consider scheduling problems without involving due date assignment decisions. The objective function is to minimize the makespan, total completion time, total absolute variation in completion times, and total absolute variation in waiting times. We show that several existing well-known problems can be reduced to a special case of our unified model and solved in O(nlogn) time.     

Routing equal-size messages on a slotted ring

We deal with the problem of routing messages on a slotted ring network in this paper. We study the computational complexity and algorithms for this routing by means of the results known in the literature for the multi-slot just-in-time scheduling problem. We consider two criteria for the routing problem: makespan, or minimum routing time, and diagonal makespan. A?diagonal is simply a schedule of ring links i=0,??,q?1 in q consecutive time slots, respectively. The number of diagonals between the earliest and the latest diagonals with non-empty packets is referred to as the diagonal makespan. For the former, we show that the optimal routing of messages of size k, is NP-hard in the strong sense, while an optimal routing when k=q can be computed in O(n ²log² n) time. We also give an O(nlogn)-time constant factor approximation algorithm for unit size messages. For the latter, we prove that the optimal routing of messages of size k, where k divides the size of the ring q, is NP-hard in the strong sense even for any fixed k??1, while an optimal routing when k=q can be computed in O(nlogn) time. We also give an O(nlogn)-time approximation algorithm with an absolute error 2q?k.     

A Parallel Algorithm for Partitioning a Point Set to Minimize the Maximum of Diameters

Given a set S of n points in the plane, we consider the problem of partitioning S into two subsets such that the maximum of their diameters is minimized. We present a parallel algorithm to solve this problem that runs in time O(log n) using the CREW PRAM with 0(n²) processors.     

Covering a set of points in a plane using two parallel rectangles

In this paper we consider the problem of finding two parallel rectangles in arbitrary orientation for covering a given set of n points in a plane, such that the area of the larger rectangle is minimized. We propose an algorithm that solves the problem in O(n³) time using O(n²) space. Without altering the complexity, our approach can be used to solve another optimization problem namely, minimize the sum of the areas of two arbitrarily oriented parallel rectangles covering a given set of points in a plane.     

Scheduling a Single Server in a Two-machine Flow Shop

We study the problem of scheduling a single server that processes n jobs in a two-machine flow shop environment. A machine dependent setup time is needed whenever the server switches from one machine to the other. The problem with a given job sequence is shown to be reducible to a single machine batching problem. This result enables several cases of the server scheduling problem to be solved in O(n log n) by known algorithms, namely, finding a schedule feasible with respect to a given set of deadlines, minimizing the maximum lateness and, if the job processing times are agreeable, minimizing the total completion time. Minimizing the total weighted completion time is shown to be NP-hard in the strong sense. Two pseudopolynomial dynamic programming algorithms are presented for minimizing the weighted number of late jobs. Minimizing the number of late jobs is proved to be NP-hard even if setup times are equal and there are two distinct due dates. This problem is solved in O(n ³) time when all job processing times on the first machine are equal, and it is solved in O(n ⁴) time when all processing times on the second machine are equal. Received November 20, 2001; revised October 18, 2002 Published online: January 16, 2003     

Parallel batch scheduling of equal-length jobs with release and due dates

In this paper we study parallel batch scheduling problems with bounded batch capacity and equal-length jobs in a single and parallel machine environment. It is shown that the feasibility problem 1|p-batch,b<n,r _j ,p _j =p,C _j ≤d _j |− can be solved in O(n ²) time and that the problem of minimizing the maximum lateness can be solved in O(n ²log n) time. For the parallel machine problem P|p-batch,b<n,r _j ,p _j =p,C _j ≤d _j |− an O(n ³log n)-time algorithm is provided, which can also be used to solve the problem of minimizing the maximum lateness in O(n ³log ² n) time.     

An efficient certifying algorithm for the Hamiltonian cycle problem on circular-arc graphs

A certifying algorithm for a problem is an algorithm that provides a certificate with each answer that it produces. The certificate is an evidence that can be used to authenticate the correctness of the answer. A Hamiltonian cycle in a graph is a simple cycle in which each vertex of the graph appears exactly once. The Hamiltonian cycle problem is to determine whether or not a graph contains a Hamiltonian cycle. The best result for the Hamiltonian cycle problem on circular-arc graphs is an O(n²logn)-time algorithm, where n is the number of vertices of the input graph. In fact, the O(n²logn)-time algorithm can be modified as a certifying algorithm although it was published before the term certifying algorithms appeared in the literature. However, whether there exists an algorithm whose time complexity is better than O(n²logn) for solving the Hamiltonian cycle problem on circular-arc graphs has been opened for two decades. In this paper, we present an O(Δn)-time certifying algorithm to solve this problem, where Δ represents the maximum degree of the input graph. The certificates provided by our algorithm can be authenticated in O(n) time.     

An O(n 2 ) algorithm for scheduling equal-length preemptive jobs on a single machine to minimize total tardiness

In this paper, we study the problem of scheduling n equal-length preemptive jobs on a single machine to minimize total tardiness, subject to release dates. The complexity status of this problem has remained open to date. We provide an O(n²) time algorithm to solve the problem.     

On scheduling a single machine with resource dependent release times

We consider a single machine scheduling problem with resource dependent release times that can be controlled by a non-increasing convex resource consumption function. The objective is to minimize the weighted total resource consumption and sum of job completion times with an initial release time greater than the total processing times. It is known that the problem is polynomially solvable in O(n⁴) with n the number of jobs.