Series-parallel Precedence Constraints Research Articles

Optimal Algorithm for the General Quay Crane Double-Cycling Problem

Quay crane efficiency is the key bottleneck for container port productivity. An important issue of container terminal optimization is the quay crane double-cycling problem (QCDCP). For the simple scenario without hatch covers, a two-machine flow shop scheduled model can be formulated that can be solved by Johnson’s rule. For the general QCDCP with hatch covers, the state-of-the-art solution approaches are only heuristics. The computational complexity of the problem, however, remains an open question. This paper focuses on the general QCDCP. We investigate the computational complexity of the problem, by showing that it can be formulated as a flow shop scheduling problem with series-parallel precedence constraints, thus allowing it to be solved polynomially. For ease of implementation, we present an optimal algorithm for the general QCDCP, which is a special and simplified version of Sidney’s algorithm.

Single machine scheduling with precedence constraints and positionally dependent processing times

In many real-life situations the processing conditions in scheduling models cannot be viewed as given constants since they vary over time thereby affecting actual durations of jobs. We consider single machine scheduling problems of minimizing the makespan in which the processing time of a job depends on its position (with either cumulative deterioration or exponential learning). It is often found in practice that some products are manufactured in a certain order implied, for example, by technological, marketing or assembly requirements. This can be modeled by imposing precedence constraints on the set of jobs. We consider scheduling models with positional deterioration or learning under precedence constraints that are built up iteratively from the prime partially ordered sets of a bounded width (this class of precedence constraints includes, in particular, series–parallel precedence constraints). We show that objective functions of the considered problems satisfy the job module property and possess the recursion property. As a result, the problems under consideration are solvable in polynomial time.

Single machine scheduling models with deterioration and learning: handling precedence constraints via priority generation

We consider various single machine scheduling problems in which the processing time of a job depends either on its position in a processing sequence or on its start time. We focus on problems of minimizing the makespan or the sum of (weighted) completion times of the jobs. In many situations we show that the objective function is priority-generating, and therefore the corresponding scheduling problem under series-parallel precedence constraints is polynomially solvable. In other situations we provide counter-examples that show that the objective function is not priority-generating.

Algorithms with performance guarantees for flow shops with regular objective functions

We consider flow-shop scheduling problems with regular (nondecreasing) objective functions such as the minimization of makespan in the presence of arbitrary precedence constraints, the weighted sum of job completion times in the presence of series-parallel precedence constraints, the discounted total weighted completion time, and the sum of the quadratic job completion times. We present algorithms with tight worst-case performance bounds for all of these problems by utilizing the optimal permutations for the corresponding single-machine problems. We also investigate the asymptotic optimality of our algorithms.

Single-Machine Scheduling with Precedence Constraints

We discuss the problem of sequencing precedence-constrained jobs on a single machine to minimize the average weighted completion time. This problem has attracted much attention in the mathematical programming community since Sidney’s pioneering work in 1975 (Sidney, J. B. 1975. Decomposition algorithms for single machine scheduling with precedence relations and deferral costs. Operations Research 23 283–298). We look at the problem from a polyhedral perspective and uncover a relation between Sidney’s decomposition theorem and different linear programming relaxations. More specifically, we present a generalization of Sidney’s result, which particularly allows us to reason that virtually all known 2-approximation algorithms are consistent with his decomposition. Moreover, we establish a connection between the single-machine scheduling problem and the vertex cover problem. Indeed, in the special case of series-parallel precedence constraints, we prove that the sequencing problem can be seen as a special case of the vertex cover problem. We also argue that this result is true for general precedence constraints if one can show that a certain integer program represents a valid formulation of the sequencing problem. Finally, we give a 3/2-approximation algorithm for two-dimensional partial orders, and we also provide a characterization of the active inequalities of a linear programming relaxation in completion time variables.

Single Machine Scheduling with Precedence Constraints

We discuss the problem of sequencing precedence-constrained jobs on a single machine to minimize the average weighted completion time. This problem has attracted much attention in the mathematical programming community since Sidney's pioneering work in 1975. We look at the problem from a polyhedral perspective and uncover a relation between Sidney's decomposition theorem and different linear programming relaxations. More specifically, we present a generalization of Sidney's result, which particularly allows us to reason that virtually all known 2-approximation algorithms comply with his decomposition. Moreover, we establish a connection between the single-machine scheduling problem and the vertex cover problem. Indeed, in the special case of series-parallel precedence constraints, we prove that the sequencing problem can be seen as a special case of the vertex cover problem. We also argue that this result is true for general precedence constraints if one can show that a certain integer program represents a valid formulation of the sequencing problem. Finally, we give a 3/2-approximation algorithm for two-dimensional partial orders, and we also provide a characterization of the active inequalities of a linear programming relaxation in completion time variables.

Bounds for Assembly Line Balancing Heuristics

We analyze the asymptotic worst-case performance ratio of polynomial time heuristics for the assembly line balancing problem. Assuming that P ≠ NP, we show that no polynomial heuristic has worst-case ratio less than 1.5. (This ratio is known to be not worse than 2 for any “reasonable” heuristic.) Tighter results are established for problems with only “short” tasks, i.e., when all processing times do not exceed a given fraction of the cycle time. These results apply even to planar, series-parallel precedence constraints, and contrast with known results for situations with an empty precedence relation, i.e., the bin packing problem. In particular, if P ≠ NP, there are no fully polynomial approximation schemes for assembly line balancing, even with “short” tasks and planar, series-parallel precedence constraints.

A compact labeling scheme for series-parallel graphs

A linear time labeling algorithm is presented for series-parallel graphs. The labels enable us to efficiently implement dynamic programming algorithms for sequencing problems with series-parallel precedence constraints. The labeling scheme can also be used to efficiently count and generate the initial sets, terminal sets and independent sets in transitive series-parallel digraphs and to provide a characterization of the maximal independent sets in transitive digraphs.

Scheduling parallel operations in automation for minimum execution time based on pert

The use of parallel operations in automation, such as part fabrication and assembly, computation and control of industrial robots, etc., may yield a minimum production time and thereby increase productivity. However, the coupling between consecutive phases of operations results in series-parallel precedence constraints that may create unavoidable idle time intervals during the operations. To solve the problem, idle time intervals must be broken down and reduced. An algorithm that determines a minimum time-ordered schedule for the parallel operaitons is developed based on the Program Evaluation and Review Technique using the method of “variable” branch and bound.

Scheduling of Parallel Computation for a Computer-Controlled Mechanical Manipulator

The physical compactness of the microcomputer has made it feasible to mount the controller and the mechanical manipulator together as a single unit. By using a computer with multiple central processing units (CPU's), parallel computations may be executed to achieve a minimum computing time so that a real-time control is possible. The parallel processing system utilizes one CPU for each link of the manipulator. Because of the dynamic coupling between adjacent links, precedence relations appear among the subtasks to be executed in CPU's. Under the series-parallel precedence constraints a method of "variable" branch-and-bound has been developed which determines an optimum ordered schedule for each of the CPU's. It consists of, alternatively, forward and backward search procedures with an aid of pushdown-stacks. In each forward search procedure, it seeks the currently feasible schedule with shorter computing time which updates the upper bound of the optimum schedule, while in each backward search procedure it discards those schedule-branches that will not provide improvements. A Fortran program has been written for a manipulator based on the Newton-Euler formulation of dynamic equations and is applied to the Stanford manipulator as an illustration.

Single Machine Scheduling with Series-Parallel Precedence Constraints

This paper considers a set of tasks to be sequenced for processing on a single machine. The possible sequences may be restricted by given precedence constraints. For each feasible sequence we have an additive cost function (e.g., tardiness or weighted tardiness) and the objective is to find a feasible sequence with minimal total cost. An efficient algorithm is presented for the case when the set of precedence constraints can be represented by a series-parallel graph. The algorithm is based on the earlier known dynamic programming approach, its main new achievement is the use of a compact labeling scheme for series-parallel graphs which is the best possible in a certain sense.

A Decomposition Algorithm for Sequencing with General Precedence Constraints

Many important unconstrained job sequencing problems for which optimal algorithms exist satisfy the adjacent job interchange property. In recent years, a more general property, the adjacent sequence interchange property, has been identified and shown to be a sufficient condition for the existence of efficient algorithms for sequencing problems with series-parallel precedence constraints. In this paper, additional properties are defined which are sufficient to prove the existence of decomposition algorithms for general precedence structures. These results are applicable to several problems, including the two-machine maximum flow time problem, the maximum cumulative cost problem, the least cost fault detection problem, and the total weighted exponential completion time problem, and represent an extension of Sidney's results on the weighted completion time problem.

Scheduling of Distributed Computer Control Systems for Industrial Robots

By using distributed computers, parallel computations may be executed to achieve a minimum computing time so that a real time control of industrial robots is possible. With multiple CPU's, the parallel processing system utilizes one CPU for each link of the manipulator. Because of the dynamic coupling between adjacent links, precedence relations appear among the subtasks to be executed in CPU's. Under the series-parallel precedence constraints, a method of “ variable” branch-and-bound has been developed which determines an optimum, ordered schedule for each of the CPU's. It consists of, alternatively, forward and backward search procedures with an aid of pushdownstacks. In each forward search procedure, it seeks the currently feasible schedule with shorter computing time which updates the upper bound of the optimum schedule; while in each backward search procedure, it discards those schedule-branches that will not provide improvements. A FORTRAN program has been written for a manipulator based on the Newton-Euler formulation of dynamic equations, and is applied to the Stanford manipulator as an illustration.

The Two-Machine Maximum Flow Time Problem with Series-Parallel Precedence Constraints: An Algorithm and Extensions

This note contains an 0(n log n) time-bounded implementation and extentions for a procedure developed by Sidney for the two-machine maximum flow time problem with series-parallel precedence constraints.

Sequencing with Series-Parallel Precedence Constraints

One of the most important ideas in the theory of sequencing and scheduling is the method of adjacent pairwise job interchange. This method compares the costs of two sequences which differ only by interchanging a pair of adjacent jobs. In 1956, W. E. Smith defined a class of problems for which a total preference ordering of the jobs exists with the property that in any sequence, whenever two adjacent jobs are not in preference order, they may be interchanged with no resultant cost increase. In such a case the unconstrained sequencing problem is easily solved by sequencing the jobs in preference order. In this paper, a natural subclass of these problems is considered for which such a total preference ordering exists for all subsequences of jobs. The main result is an efficient general algorithm for these sequencing problems with series-parallel precedence constraints. These problems include the least cost fault detection problem, the one-machine total weighted completion time problem, the two-machine maximum completion time flow-shop problem and the maximum cumulative cost problem.

The Two-Machine Maximum Flow Time Problem with Series Parallel Precedence Relations

The n-job 2-machine flow shop problem with series-parallel precedence constraints is considered with the objective to minimize makespan. Recent results of Kurisu are utilized in the development of a polynomial bounded optimal algorithm.

Scheduling to Minimize Maximum Cumulative Cost Subject to Series-Parallel Precedence Constraints

Consider a set of events that are constrained by a certain precedence relation. Associated with each event is a cost (an integer), which may be interpreted as an additional number of resource units necessary for the event to occur (units are released if the cost is negative). It is desired to order the events into a single sequence in such a way that the maximum cumulative cost encountered (largest number of resource units used at one time) is minimized. It is known that this problem is in general NP-complete. For the special case where the precedence constraints can be represented by a series-parallel graph, we present an algorithm for finding an optimal schedule whose running time does not grow faster than the square of the number of events.

On the Complexity of Mean Flow Time Scheduling

There are n tasks lo be scheduled for processing on a set of identical parallel machines. We are interested in minimizing the mean flow time, which is related to the sum of the finishing times of all tasks. When tasks can be processed in any order, optimal schedules can be constructed in O(n log n) time on any number of identical machines. With arbitrary precedence constraints the problem becomes NP-complete even on one machine. However, for series-parallel precedence constraints an O(n log n) algorithm is known for one machine. We show that on two or more machines, the problem is NP-complete even if the precedence constraints are tree-like. We prove the result both for in-trees in which the root is the last task to be processed, and out-trees in which the root is the first task to be processed.