A branch and bound algorithm for the two-stage assembly scheduling problem

This paper develops a branch and bound algorithm for the two-stage assembly scheduling problem. In this problem, there are m machines at the first stage, each of which produces a component of a job. When all m components are available, a single assembly machine at the second stage completes the job. The objective is to schedule the jobs on the machines so that the maximum completion time, or makespan, is minimized. A lower bound based on solving an artificial two-machine flow shop problem is derived. Also, several dominance theorems are established and incorporated into the branch and bound algorithm. Computational experience with the algorithm is reported for problems with up to 8000 jobs and 10 first-stage machines.     

A note on scheduling identical coupled tasks in logarithmic time

The coupled tasks problem consists in scheduling n jobs on a single machine. Each job i is made of two operations with processing times a_i and b_i and a fixed required delay L_i between them. Operations cannot overlap in time but operations of different jobs can be interleaved. The objective is to minimize the makespan of the schedule. In this note we show that the problem with identical jobs (∀i,a_i=a,b_i=b,L_i=L) can be solved in O(logn) time when a,b,L are fixed. This problem is motivated by radar scheduling applications where tasks corresponding to transmitting radiowaves and listening to potential echoes are coupled.     

A column generation based decomposition algorithm for a parallel machine just-in-time scheduling problem

We propose a column generation based exact decomposition algorithm for the problem of scheduling n jobs with an unrestrictively large common due date on m identical parallel machines to minimize total weighted earliness and tardiness. We first formulate the problem as an integer program, then reformulate it, using Dantzig–Wolfe decomposition, as a set partitioning problem with side constraints. Based on this set partitioning formulation, a branch and bound exact solution algorithm is developed for the problem. In the branch and bound tree, each node is the linear relaxation problem of a set partitioning problem with side constraints. This linear relaxation problem is solved by column generation approach where columns represent partial schedules on single machines and are generated by solving two single machine subproblems. Our computational results show that this decomposition algorithm is capable of solving problems with up to 60 jobs in reasonable cpu time.     

A probability model for computer system overhead

Two models for computer system overhead are developed by considering the number of jobs in the system as an immigration-death process. The models developed relate the death rates to the state of the process. The first model uses the total numver of jobs in the system as the state of the processe. The second model classifies the jobs in the system according to the priority classes unsed in the computer system.In the model based on the total number of jobs in the system, the death rate when the system is in the state i, μ_i, is μ_i = μ min(i, x₀) where μ and x₀ are parameters to be estimated by maximum likelihood. In the second model, the death rate for jobs in the k^th priority class when the state of the system is i = (i₁…,i_p), μ_i^(k) is given by $\text{μ}{}_{\mathrm{i}}{}^{\mathrm{(k)}}\text{=μ}{}^{\mathrm{(k)}}\text{i}{}_{\mathrm{k}}\text{min}\text{(1,}\text{x}{}_0\text{i·1}\text{)}$. Computational difficulties in finding the maximum likelihood estimates of the parameters for this model are noted.     

Flow shop scheduling algorithms for minimizing the completion time variance and the sum of squares of completion time deviations from a common due date

We consider two problems of m-machine flow shop scheduling in this paper: one, with the objective of minimizing the variance of completion times of jobs, and the other with the objective of minimizing the sum of squares of deviations of job completion times from a common due date. Lower bounds on the sum of squares of deviations of job completion times from the mean completion time of jobs for a given partial sequence are first presented. Using these lower bounds, a branch and bound algorithm based on breadth-first search procedure for scheduling n jobs on m-machines with the objective of minimizing completion time variance (CTV) is developed to obtain the best permutation sequence. We also present two lower bounds and thereafter, a branch and bound algorithm with the objective of minimizing the sum of squares of deviations of job completion times from a given common due date (called the MSD problem). The computational experience with the working of the two proposed branch and bound algorithms is also reported. Two heuristics, one for each of the two problems, are developed. The computational experience on the evaluation of the heuristics is discussed.     

Preemptive multiprocessor order scheduling to minimize total weighted flowtime

Consider m identical machines in parallel, each of which can produce k different product types. There is no setup cost when the machines switch from producing one product type to another. There are n orders each of which requests various quantities of the different product types. All orders are available for processing at time t = 0, and preemption is allowed. Order i has a weight w_i and its completion time is the time when its last requested product type finishes. Our goal is to find a preemptive schedule such that the total weighted completion time ∑_wiCi$\sum w_i{C}_i$ is minimized. We show that this problem is NP-hard even when all jobs have identical weights and there are only two machines. Motivated by the computational complexity of the problem, we propose a simple heuristic and show that it obeys a worst-case bound of 2 − 1/m. Finally, empirical studies show that our heuristic performs very well when compared with a lower bound of the optimal cost.     

A Branch and Bound Algorithm to Minimize the Total Weighed Number of Tardy Jobs and Delivery Costs

This paper addresses the production and delivery scheduling integration problem; a manufacturer receives ₋ orders from one customer while the orders need to be processed on one or two machines and be sent to the customer in batches. Sending several jobs in batches will reduce the transportation cost but it may increase the number of tardy jobs. The objective is to minimize the sum of the total weighted number of tardy jobs and the delivery costs. The structural properties of the problem for a single machine and special cases of the two-machine flow shop problem are investigated and used to set up a new branch and bound algorithm. A heuristic algorithm for upper bound calculation and two approaches for lower bound calculation are also introduced. Results of computational tests show significant improvement over an existing dynamic programming method.     

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.     

An algorithm for single machine sequencing with deadlines to minimize total weighted completion time

Each of n jobs is to be processed without interruption on a single machine. Each job becomes available for processing at time zero, has a deadline by which it must be completed and has a positive weight. The objective is to find a processing order of the jobs which minimizes the sum of weighted completion times. In this paper a branch and bound algorithm for the problem is presented which incorporates lower bounds that are obtained using a new technique called the multiplier adjustment method. Firstly several dominance conditions are derived. Then a heuristic is described and sufficient conditions for its optimality are given. The lower bound is obtained by performing a Lagrangean relaxation of the deadline constraints; the Lagrange multipliers are chosen so that the sequence generated by the heuristic is an optimal solution of the relaxed problem, thus yielding a lower bound. The algorithm is tested on problems with up to fifty jobs.     

Minimizing total tardiness in an unrelated parallel-machine scheduling problem

We consider a problem of scheduling n independent jobs on m unrelated parallel machines with the objective of minimizing total tardiness. Processing times of a job on different machines may be different on unrelated parallel-machine scheduling problems. We develop several dominance properties and lower bounds for the problem, and suggest a branch and bound algorithm using them. Results of computational experiments show that the suggested algorithm gives optimal solutions for problems with up to five machines and 20 jobs in a reasonable amount of CPU time.     

A graph theoretic upper bound on the permanent of a nonnegative integer matrix. I

Let A be a fully indecomposable n×n matrix with nonnegative integer entries. Then the permanent of A is bounded above by 1+min{Π(c_i?1), Π(r_i?1)}, where c_i and r_i are the column and row sums of A. The inequality results from a bound on the number of disjoint cycle unions in an associated multigraph. This bound can improve via contractions.     

Optimal schedulings with gaps for independent jobs in a service system withN servers

One considers the problem of forming the optimal schedulings with gaps for a service system withN identical parallel processors. In the service one performsK jobs, each of which consists of V_i homogeneous independent operations and has lower and upper directive times d_i and D_i. For the operations which constitute the jobs, one considers linear penalty functions outside the interval [d_i,D_i]. One solves the problem of finding the schedulings with a minimal total penalty and having the origin in a given interval [t₁,t₂]. It is proved that for an arbitrary set Z of jobs, the penalty function F_Z(t), where t is the origin of the scheduling, has a unique minimum for t∈(?∞,+∞). We present an algorithm for the construction of the optimal scheduling requiring \(C \cdot K\left( {\mathop {\max }\limits_i \left\{ {D_i } \right\} - \mathop {\min }\limits_i \left\{ {d_i } \right\} + \sum\limits_1^\kappa {V_i } } \right)\) operations on an electronic computer.     

An algorithm for single machine sequencing with release dates to minimize total weighted completion time

Each of n jobs is to be processed without interruption on a single machine which can handle only one job at a time. Each job becomes available for processing at its release date, requires a processing time and has a positive weight. Given a processing order of the jobs, the earliest completion time for each job can be computed. The objective is to find a processing order of the jobs which minimizes the sum of weighted completion times. In this paper a branch and bound algorithm for the problem is derived. Firstly a heuristic is presented which is used in calculating the lower bound. Then the lower bound is obtained by performing a Lagrangean relaxation of the release date constraints; the Lagrange multipliers are chosen so that the sequence generated by the heuristic is an optimum solution of the relaxed problem thus yielding a lower bound. A method to increase the lower bound by deriving improved constraints to replace the original release date constraints is given. The algorithm, which includes several dominance rules, is tested on problems with up to fifty jobs. The computational results indicate that the version of the lower bound using improved constraints is superior to the original version.     

On the time to first failure in multicomponent exponential reliability systems

Consider an n-component reliability system having the property that at any time each of its components is either up (i.e., working) or down (i.e., being repaired). Each component acts independently and we suppose that each time the i^th component goes up it remains up for an exponentially distributed time having mean μ_i, and each time it goes down it remains down for an exponentially distributed time having mean υ_i. We further suppose that whether or not the system itself is up at any time depends only on which components are up at that time. We are interested in the distribution of the time of first system failure when all components are initially up at time zero. In section 2 we show that this distribution has the NBU (i.e., new better than used) property, and in Section 3 we make use of this and other results to obtain a lower bound to the mean time until first system failure.     

Approximation schemes for parallel machine scheduling with availability constraints

We investigate the problems of scheduling n weighted jobs to m parallel machines with availability constraints. We consider two different models of availability constraints: the preventive model, in which the unavailability is due to preventive machine maintenance, and the fixed job model, in which the unavailability is due to a priori assignment of some of the n jobs to certain machines at certain times. Both models have applications such as turnaround scheduling or overlay computing. In both models, the objective is to minimize the total weighted completion time. We assume that m is a constant, and that the jobs are non-resumable.For the preventive model, it has been shown that there is no approximation algorithm if all machines have unavailable intervals even if w_i=p_i for all jobs. In this paper, we assume that there is one machine that is permanently available and that the processing time of each job is equal to its weight for all jobs. We develop the first polynomial-time approximation scheme (PTAS) when there is a constant number of unavailable intervals. One main feature of our algorithm is that the classification of large and small jobs is with respect to each individual interval, and thus not fixed. This classification allows us (1) to enumerate the assignments of large jobs efficiently; and (2) to move small jobs around without increasing the objective value too much, and thus derive our PTAS. Next, we show that there is no fully polynomial-time approximation scheme (FPTAS) in this case unless P=NP.For the fixed job model, it has been shown that if job weights are arbitrary then there is no constant approximation for a single machine with 2 fixed jobs or for two machines with one fixed job on each machine, unless P=NP. In this paper, we assume that the weight of a job is the same as its processing time for all jobs. We show that the PTAS for the preventive model can be extended to solve this problem when the number of fixed jobs and the number of machines are both constants.     

Balancing Workloads and Minimizing Set-up Costs in the Parallel Processing Shop

This paper presents an optimal scheduling algorithm for minimizing set-up costs in the parallel processing shop while meeting workload balancing restrictions.There are M independent batch type jobs which have sequence dependent set-up costs and N parallel processing machines. Each of the M jobs must be processed on exactly one of the N available machines. It is desirable to minimize total changeover costs with the restriction that each machine workload assignment T _n be within P units of the average machine assignment. The paper describes a static problem in which all jobs are available at time zero. The sequence dependent change over costs are identical for each machine. An extension of the algorithm handles nonidentical processor problems.A combinatorial programming approach to the problem is used. For the special case of identical processors, the problem can be treated as a multi-salesman travelling salesman problem. A general branch and bound algorithm and numerical results are given.     

Scheduling on parallel identical machines to minimize total tardiness

This paper focuses on the problem of scheduling n independent jobs on m identical parallel machines for the objective of minimizing total tardiness of the jobs. We develop dominance properties and lower bounds, and develop a branch and bound algorithm using these properties and lower bounds as well as upper bounds obtained from a heuristic algorithm. Computational experiments are performed on randomly generated test problems and results show that the algorithm solves problems with moderate sizes in a reasonable amount of computation time.     

On minimizing the weighted number of late jobs in unit execution time open-shops

We study unit execution time open-shops with integer release dates. This paper shows that, in this environment, the minimum weighted number of late jobs can be computed in polynomial time by dynamic programming. The complexity status of the corresponding problem Om|p_ij=1,r_i|∑w_iU_i was unknown before.     

Exact algorithm over an arc-time-indexed formulation for parallel machine scheduling problems

This paper presents an exact algorithm for the identical parallel machine scheduling problem over a formulation where each variable is indexed by a pair of jobs and a completion time. We show that such a formulation can be handled, in spite of its huge number of variables, through a branch cut and price algorithm enhanced by a number of practical techniques, including a dynamic programming procedure to fix variables by Lagrangean bounds and dual stabilization. The resulting method permits the solution of many instances of the P||∑w _j T _j problem with up to 100 jobs, and having 2 or 4 machines. This is the first time that medium-sized instances of the P||∑w _j T _j have been solved to optimality.     

Preemptive scheduling of two uniform parallel machines to minimize total tardiness

We consider the problem of preemptive scheduling n jobs on two uniform parallel machines. All jobs have equal processing requirements. For each job we are given its due date. The objective is to find a schedule minimizing total tardiness ∑T_i. We suggest an O(n log n) algorithm to solve this problem.