Single-machine batch delivery scheduling with an assignable common due window

This paper addresses a batch delivery single-machine scheduling problem in which jobs have an assignable common due window. Each job will incur an early (tardy) penalty if it is early (tardy) with respect to the common due window under a given schedule. There is no capacity limit on each delivery batch, and the cost per batch delivery is fixed and independent of the number of jobs in the batch. The objective is to find the optimal size and location of the window, the optimal dispatch date for each job, as well as an optimal job sequence to minimize a cost function based on earliness, tardiness, holding time, window location, window size, and batch delivery. We show that the problem can be optimally solved in O(n⁸)$O(n^8)$ time by a dynamic programming algorithm under a reasonable assumption on the relationships among the cost parameters. A computational experiment is also conducted to evaluate the performance of the proposed algorithm. We also show that some special cases of the problem can be optimally solved by lower order algorithms.     

Optimization models for the tool change scheduling problem

Traditional machine scheduling literature generally assumes that a machine is available at all times. Yet this assumption may not be accurate in real manufacturing systems. In many cases, a machine's tool must be changed after it has continuously worked for a period of time. This paper deals with a single machine scheduling problem subject to tool wear, given the allowed maximum continuous working time of the machine is _TL$T_{\mathrm{L}}$ (tool life) and the tool change time is _TC$T_{\mathrm{C}}$. Job processing and tool changes are scheduled simultaneously. In this paper, we examine this problem to minimize the total tardiness of jobs. Two mixed binary integer programming models are developed to optimally solve this problem. Computational experiments are performed to evaluate the models’ efficiency.     

Just-in-time scheduling with controllable processing times on parallel machines

We study scheduling problems with controllable processing times on parallel machines. Our objectives are to maximize the weighted number of jobs that are completed exactly at their due date and to minimize the total resource allocation cost. We consider four different models for treating the two criteria. We prove that three of these problems are NP\mathcal{NP} -hard even on a single machine, but somewhat surprisingly, the problem of maximizing an integrated objective function can be solved in polynomial time even for the general case of a fixed number of unrelated parallel machines. For the three NP\mathcal{NP} -hard versions of the problem, with a fixed number of machines and a discrete resource type, we provide a pseudo-polynomial time optimization algorithm, which is converted to a fully polynomial time approximation scheme.     

Single machine scheduling problems with subcontracting options

In this paper, we study a scheduling model as follows: there are n jobs which can be processed in house on a single machine or subcontracted to a subcontractor. If a job is subcontracted, its processing cost is different from the in-house cost and its delivery lead time is a stepwise function of the total processing time of outsourced jobs. Two objective functions are studied (1) to minimize the weighted sum of the maximal completion time and the total processing cost and (2) to minimize the weighted sum of the number of tardy jobs and the total processing cost. For the first problem, we prove that it is NP-hard and get a pseudo-polynomial time algorithm. For the second problem, we prove that it is NP-hard and get a pseudo-polynomial time algorithm for a special case.     

Two-agent scheduling problems on a single-machine to minimize the total weighted late work

In this paper, two-agent scheduling problems are presented. The different agents share a common processing resource, and each agent wants to minimize a cost function depending on its jobs only. The objective functions we consider are the total weighted late work and the maximum cost. The problem is to find a schedule that minimizes the objective function of agent A, while keeping the objective function of agent B cannot exceed a given bound U. Some different scenarios are presented by depending on the objective function of each agent. We address the complexity of those problems, and present the optimal polynomial time algorithms or pseudo-polynomial time algorithm to solve the scheduling problems, respectively.     

A note on the complexity of the problem of two-agent scheduling on a single machine

We consider a two-agent scheduling problem on a single machine, where the objective is to minimize the total completion time of the first agent with the restriction that the number of tardy jobs of the second agent cannot exceed a given number. It is reported in the literature that the complexity of this problem is still open. We show in this paper that this problem is NP-hard under high multiplicity encoding and can be solved in pseudo-polynomial time under binary encoding. When the first agent's objective is to minimize the total weighted completion time, we show that the problem is strongly NP-hard even when the number of tardy jobs of the second agent is restricted to be zero.     

Two-stage time minimizing assignment problem

This paper deals with the optimal selection of m out of n facilities to first perform m   given primary jobs in Stage-I followed by the remaining (n-m)$(n-m)$ facilities performing optimally the (n-m)$(n-m)$ secondary jobs in Stage-II. It is assumed that in both the stages facilities perform in parallel. The aim of the proposed study is to find that set of m   facilities performing the primary jobs in Stage-I for which the sum of the overall completion times of jobs in Stage-I and the corresponding optimal completion time of the secondary jobs in Stage-II by the remaining (n-m)$(n-m)$ facilities is the minimum. The developed solution methodology involves solving the standard time minimizing and cost minimizing assignment problems alternately after forbidding some facility-job pairings and suggests a polynomially bound algorithm. This proposed algorithm has been implemented and tested on a variety of test problems and its performance is found to be quite satisfactory.     

A column generation heuristic for dynamic capacitated lot sizing with random demand under a fill rate constraint

This paper deals with the dynamic multi-item capacitated lot-sizing problem under random period demands (SCLSP). Unfilled demands are backordered and a fill rate constraint is in effect. It is assumed that, according to the static-uncertainty strategy of Bookbinder and Tan [1], all decisions concerning the time and the production quantities are made in advance for the entire planning horizon regardless of the realization of the demands. The problem is approximated with the set partitioning model and a heuristic solution procedure that combines column generation and the recently developed _ABCβ${\mathit{ABC}}_{\beta }$ heuristic is proposed.     

Minmax common flow-allowance problems with convex resource allocation and position-dependent workloads

We study minmax due-date based on common flow-allowance assignment and scheduling problems on a single machine, and extend known results in scheduling theory by considering convex resource allocation. The total cost function of a given job consists of its earliness, tardiness and flow-allowance cost components. Thus, the common flow-allowance and the actual jobs’ processing times are decision variables, implying that the due-dates and actual processing times can be controlled by allocating additional resource to the job operations. Consequently, our goal is to optimize a cost function by seeking the optimal job sequence, the optimal job-dependent due-dates along with the actual processing times. In all addressed problems we aim to minimize the maximal cost among all the jobs subject to a constraint on the resource consumption. We start by analyzing and solving the problem with position-independent workloads and then proceed to position-dependent workloads. Finally, the results are generalized to the method of common due-window. For all studied problems closed form solutions are provided, leading to polynomial time solutions.

     

Single cycle policies for the one-warehouse N-retailer inventory/distribution system

We address a multi-echelon inventory system with one-warehouse and N  -retailers. The demand at each retailer is assumed to be known and satisfied by the warehouse. Shortages are not allowed and lead times are negligible. Costs at each facility consist of a fixed charge per order and a holding cost. The goal is to determine single-cycle policies which minimize the average cost per unit time, that is, the sum of the average holding and setup costs per unit time at the retailers and at the warehouse. We propose a O(NlogN)$\mathrm{O}(N\log N)$ heuristic procedure to compute efficient single-cycle policies. This heuristic is compared with other approaches proposed by Schwarz, Graves and Schwarz and Muckstadt and Roundy. We carry out a computational study to test the effectiveness of the heuristic and to compare the performance of the different procedures. From the computational results, it is shown that the new heuristic provides, on average, better single-cycle policies than those given by the Muckstadt and Roundy method.     

A bicriteria approach to scheduling a single machine with job rejection and positional penalties

Single machine scheduling problems have been extensively studied in the literature under the assumption that all jobs have to be processed. However, in many practical cases, one may wish to reject the processing of some jobs in the shop, which results in a rejection cost. A solution for a scheduling problem with rejection is given by partitioning the jobs into a set of accepted and a set of rejected jobs, and by scheduling the set of accepted jobs among the machines. The quality of a solution is measured by two criteria: a scheduling criterion, F1, which is dependent on the completion times of the accepted jobs, and the total rejection cost, F2. Problems of scheduling with rejection have been previously studied, but usually within a narrow framework—focusing on one scheduling criterion at a time. This paper provides a robust unified bicriteria analysis of a large set of single machine problems sharing a common property, namely, all problems can be represented by or reduced to a scheduling problem with a scheduling criterion which includes positional penalties. Among these problems are the minimization of the makespan, the sum of completion times, the sum and variation of completion times, and the total earliness plus tardiness costs where the due dates are assignable. Four different problem variations for dealing with the two criteria are studied. The variation of minimizing F1+F2 is shown to be solvable in polynomial time, while all other three variations are shown to be $\mathcal{NP}$ -hard. For those hard problems we provide a pseudo polynomial time algorithm. An FPTAS for obtaining an approximate efficient schedule is provided as well. In addition, we present some interesting special cases which are solvable in polynomial time.     

Batch-Processing Scheduling with Setup Times

The problem is to minimize the total weighted completion time on a single batch-processing machine with setup times. The machine can process a batch of at most B jobs at one time, and the processing time of a batch is given by the longest processing time among the jobs in the batch. The setup time of a batch is given by the largest setup time among the jobs in the batch. This batch-processing problem reduces to the ordinary uni-processor scheduling problem when B = 1. In this paper we focus on the extreme case of B = +, i.e. a batch can contain any number of jobs. We present in this paper a polynomial-time approximation algorithm for the problem with a performance guarantee of 2. We further show that a special case of the problem can be solved in polynomial time.