Pseudo-polynomial Dynamic Programming Algorithm Research Articles

Scheduling on parallel dedicated machines with job rejection

We study scheduling problems on parallel dedicated machines. Thus, each job can be processed on one specific machine only. The option of job-rejection is considered, and the total permitted rejection cost of all the jobs is bounded. Six scheduling problems are solved: ( i ) minimising makespan, ( ii ) minimising makespan with release-dates, ( iii ) minimising total completion time, ( iv ) minimising total weighted completion time, ( v ) minimising total load, and ( vi ) minimising maximum tardiness. Pseudo-polynomial dynamic programming algorithms are introduced for all these NP-hard problems.

A branch-and-price algorithm for unrelated parallel machine scheduling with machine usage costs

This paper considers unrelated parallel machine scheduling involving machine usage costs, in addition to classic job completion time-related costs. The usage cost of each machine is made up of a fixed usage cost and a variable usage cost proportional to the total processing time of the jobs assigned to it. These features model many practical situations where machine usage costs include, for example, rental fees when the machines are not owned but rented. To tackle this problem, four mathematical models based on the Shortest Weighted Processing Time (SWPT) rule are introduced. Additionally, the problem is formulated into a set-partitioning model, for which a branch-and-price algorithm is proposed with an appropriate branching strategy. This facilitates the development of an efficient pseudo-polynomial dynamic programming algorithm and a polynomial-time heuristic to solve the pricing problem. Extensive numerical experiments demonstrate the superior performance of the proposed branch-and-price algorithm over the four SWPT-based mathematical formulations and an existing branch-and-price algorithm designed for a special case. Notably, it can optimally solve instances involving up to 225 jobs and 15 machines within one hour. Moreover, statistical analyses reveal that the proposed polynomial-time heuristic significantly reduces the computation time, and the mathematical model based on the contribution of every job to the total weighted completion time exhibits the best overall performance.

Due-Date assignment with acceptable lead-times on parallel machines

The paper studies scheduling and due-date assignment problems on parallel machines. We consider the DIF (different due date) model, which assumes job-dependent acceptable lead-times. Thus, in addition to the classical job-earliness and job-tardiness costs, the scheduler is penalized if an assigned due-date exceeds its lead-time. First, the case of a common lead-time is studied. Then we focus on the setting of job-dependent lead-times and identical (earliness, tardiness, and lead-time) costs. Both models are examined for parallel identical, uniform, and unrelated machines. The case in which the option of job-rejection is allowed is also considered. For all these NP-hard problems, efficient pseudo-polynomial dynamic programming algorithms are introduced and tested. Our numerical tests indicate that problems containing 500 jobs are solved in less than 0.3 s.

Common due-date assignment problems with fixed-plus-linear earliness and tardiness costs

We study single machine scheduling and common due-date assignment problems. The cost considered is fixed plus linear, i.e., jobs are penalized by two cost components: (i) a variable cost which is proportional to their earliness/tardiness values, (ii) a fixed cost which is independent of their actual earliness/tardiness values. For the general version of this problem, three heuristics are introduced and tested. We also study a number of modifications and special cases. We focus first on the special case of identical job processing times. Both versions of minsum and minmax are shown to have a polynomial time solution, even with the additional option of job rejection. Another special case of variable earliness cost and fixed tardiness cost is also studied. For this NP-hard problem, a pseudo-polynomial dynamic programming algorithm is introduced and tested. An extension to the case of bounded rejection cost, and a modified version with an additional bound on the total tardiness cost, are also studied. The solution algorithms for these problems are tested numerically as well. The last studied problem is that of job-independent cost components. This version, which generalizes the first and most cited due-date assignment model, is shown to have a polynomial time solution.

Two-agent single-machine scheduling with a rate-modifying activity

We study single-machine scheduling problems involving a rate-modifying activity and two competing agents with due-date-related functions. Classical scheduling models assume that job processing times remain constant over time; however, in real-world settings, processing times may change due to factors such as technological upgrades or machine maintenance. We complement this with the notion of multiple independent agents competing over the use of a shared resource, each with their own motives. These considerations allow us to model the upcoming trend of the sharing economy, where resources are shared amongst independent competitors in the market. We aim to model these scenarios by considering a variety of scheduling criteria for each agent, including the makespan, the number of late jobs, and the total late work. To account for the change in processing times, we consider an optional rate-modifying activity that once completed, results in a reduction in subsequent job processing times. We show that problems involving the total late work are binary NP-hard and propose efficient pseudo-polynomial dynamic programming algorithms for solving these problems. We also show that the remaining problems are solvable in polynomial time.

A novel two-stage approach for energy-efficient timetabling for an urban rail transit network

Urban rail transit (URT) is the backbone transport mode in metropolitan areas to accommodate large travel demands. The high energy consumption of URT becomes a hotspot problem due to the ever-increasing operation mileages and pressing agendas of carbon neutralization. The high model complexity and inconsistency in the objectives of minimizing passenger travel time and operational energy consumption are the main challenges for energy-efficient timetabling for a URT network with multiple interlinked lines. This study proposes a general model framework of timetabling and passenger path choice in a URT network to minimize energy consumption under passenger travel time constraints. To obtain satisfactory energy-efficient nonuniform timetables, we suggest a novel model reformulation as a tree knapsack problem to determine train running times by a pseudo-polynomial dynamic programming algorithm in the first stage. Furthermore, a heuristic sequencing method is developed to determine nonuniform headways and dwell times in the second stage. The suggested model framework and solution algorithm are tested using a real-world URT network, and the results show that energy consumption can be considerably reduced given certain travel time increments.

Single machine scheduling with assignable due dates to minimize maximum and total late work

A single machine scheduling problem with assignable job due dates to minimize total late work has recently been introduced by Mosheiov, Oron, and Shabtay (2021). The problem was proved NP-hard in the ordinary sense, and no solution algorithm was proposed. In this note, we present two pseudo-polynomial dynamic programming algorithms and an FPTAS for this problem. Besides, we introduce a new single machine scheduling problem to minimize maximum late work of jobs with assignable due dates. We develop an O(nlogn) time algorithm for it, where n is the number of jobs. An optimal solution value of this new problem is a lower bound for the optimal value of the total late work minimization problem, and it is used in the FPTAS.

Algorithms for rescheduling jobs with a LIFO buffer to minimize the weighted number of late jobs

Rescheduling can help to improve the quality of a schedule with respect to an initially given sequence. In this paper, we consider the possibility of rescheduling jobs arriving for processing at a single machine under the following limitations: (a) jobs can only be moved toward the end of the schedule and not toward the front, and (b) when a job is taken out of the sequence, it is put on a buffer of limited capacity before being reinserted in its new position closer to the end of the sequence. The buffer is organized as a stack with a last-in/first-out policy. As an objective function, we consider the minimization of the weighted number of late jobs. For this NP-hard problem, we first provide two different integer linear programming (ILP) formulations. Furthermore, we develop a branch-and-bound algorithm with a branching rule based on the movement of jobs. Then a new pseudo-polynomial dynamic programming algorithm is presented which utilizes dominance criteria and an efficient handling of states. Our computational experiments with up to 100 jobs show that this algorithm performs remarkably well and can be seen as the current method of choice.

A Greedy heuristic for solving scheduling problems with bounded rejection cost

We study single machine scheduling problems with the option of job rejection. The scheduling measures considered are: makespan, total completion time, total tardiness and number of tardy jobs. Following many real-life settings, the total permitted rejection cost is assumed to be bounded. All the problems are known to be NP-hard. The paper focuses on the introduction of an efficient greedy-type heuristic, and performing an extensive numerical study. For makespan minimization, the heuristic is proved to be asymptotically optimal under very general conditions. For each of the problems, a pseudo-polynomial dynamic programming algorithm is introduced, and consequently, the results obtained by the greedy heuristic are compared to the optimum. We show that the greedy heuristic leads to very small optimality gaps in all our tests, and that the dynamic programming algorithms can solve medium and large size instances in reasonable times.

Scheduling with competing agents, total late work and job rejection

We study a single-machine scheduling problem with two competing agents. The objective function of one agent is minimizing total late work, whereas the maximum cost of the jobs of the second agent cannot exceed a given upper bound. We introduce and test a pseudo-polynomial dynamic programming algorithm for this NP-hard problem. Our tests indicate that the algorithm can handle large-size instances (containing hundreds of jobs) fairly quickly. We then extend the setting to that of job rejection, where the scheduler may decide to process only a subset of the jobs. The dynamic programming algorithm is modified accordingly, and our numerical tests verify that medium-size instances (containing less than 100 jobs) are solved in reasonable time.

Single machine scheduling to maximize the weighted number of on-time jobs with job-rejection

We study a single machine scheduling problem, where the goal is to maximize the weighted number of jobs completed exactly at their due-dates. The option of job-rejection is considered, i.e., the scheduler may perform only a subset of the jobs. An upper bound on the total permitted rejection cost is assumed. The problem is proved to be NP-hard, and a pseudo-polynomial dynamic programming algorithm is introduced. Our numerical tests indicate that the proposed algorithm performs well: medium size instances (of up to 100 jobs) are solved in less than 1 s.

A note on scheduling a rate modifying activity to minimize total late work

We study a single machine scheduling problem with a rate modifying activity. In most cases, performing such an activity (e.g., a maintenance procedure) improves the system performance, as reflected by shorter processing times of the jobs processed after it. The scheduling measure assumed is total late work: each job is considered as a collection of unit-time jobs, and the late work is defined as the number of tardy units. The problem is NP-hard, and we introduce and test numerically a pseudo-polynomial dynamic programming algorithm. Our results indicate that the algorithm solves large problem instances efficiently.

Single machine lot scheduling with optional job-rejection

We consider single machine lot scheduling problems. A number of customer orders of different sizes may be processed in the same lot. Splitting orders between consecutive lots is allowed. Three scheduling measures are considered: makespan, total completion time and total weighted completion time. In all cases, the goal is minimizing the relevant scheduling measure, subject to an upper bound on the total permitted rejection cost. All three problems studied here are NP-hard. We introduce efficient pseudo-polynomial dynamic programming algorithms for all cases. Our numerical tests indicate that the proposed algorithms can solve efficiently large-size problems.

Minimizing maximum delivery completion time for order scheduling with rejection

We study an order scheduling problem with rejection, in which each order consists of multiple product types and each product type should be manufactured on a dedicated machine. The aim is to find a solution to minimize a linear sum of the maximum delivery completion time of the accepted orders and the total penalty of the rejected orders. Even if the delivery times of all orders are zero, the problem is shown to be binary $$\mathcal{NP}$$ -hard in the two-machine case and it is shown to be unary $$\mathcal{NP}$$ -hard when the number of machines is arbitrary. Three approximation algorithms are proposed and their worst-case performance ratios are analyzed. For the scenario where the number of machines is fixed, a pseudo-polynomial dynamic programming algorithm and a fully polynomial time approximation scheme are devised for it.

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 problems under rejection budget constraints

We study two single machine scheduling problems with two competing agents and the option of rejecting jobs. We seek to minimize the scheduling criterion of one agent under the condition that the maximum completion time of the second agent does not exceed a given upper-bound. Moreover, we assume that jobs are either scheduled or rejected (incurring job-dependent penalties) subject to an upper bound on the total rejection cost. The scheduling objective for the first agent is either the makespan or the total completion time, while that of the second agent is the makespan. As both problems are known to be NP-hard, we develop efficient pseudo-polynomial dynamic programming algorithms to obtain optimal solutions. The algorithms are shown to efficiently solve medium to large size problems through an extensive numerical study.

A note: flowshop scheduling with linear deterioration and job-rejection

We study a scheduling problem on an $$m$$ -machine flowshop with linear deterioration of job processing times and job rejection. The objectives are minimum makespan and minimum total load, subject to an upper bound on the total permitted rejection cost. The problems are NP-hard (since the single machine makespan minimization version was shown to be hard), and we introduce pseudo-polynomial dynamic programming algorithms, thus proving that both problems are NP-hard in the ordinary sense.

Single-machine scheduling with multi-agents to minimize total weighted late work

We consider the competitive multi-agent scheduling problem on a single machine, where each agent’s cost function is to minimize its total weighted late work. The aim is to find the Pareto-optimal frontier, i.e., the set of all Pareto-optimal points. When the number of agents is arbitrary, the decision problem is shown to be unary $$\mathcal {NP}$$ -complete even if all jobs have the unit weights. When the number of agents is two, the decision problems are shown to be binary $$\mathcal {NP}$$ -complete for the case in which all jobs have the common due date and the case in which all jobs have the unit processing times. When the number of agents is a fixed constant, a pseudo-polynomial dynamic programming algorithm and a $$(1+\epsilon )$$ -approximate Pareto-optimal frontier are designed to solve it.

The proportionate flow shop total tardiness problem

We consider the proportionate flow shop total tardiness problem and show how to implement Lawler's (1977) pseudo-polynomial dynamic programming (DP) algorithm for the single-machine total tardiness problem to the multi-machine environment of proportionate flow shop. We also present solvable special cases including one with small/big jobs that has not been considered for the corresponding single-machine problem. We then convert the DP algorithm for the proportionate flow shop to a fully polynomial time approximation scheme (FPTAS). Finally, we show by a counterexample that Pinedo's (2002, p. 140) statement that “the elimination criteria for the single-machine total weighted tardiness problem also apply to the proportionate flow shop total weighted tardiness problem” does not always hold and present an appropriately revised statement.

The single machine CON problem with unavailability period

The classical CON problem focuses on scheduling jobs on a single machine sharing a common due-date. We study the CON problem with a given unavailability period. The basic problem (assuming linear job-independent costs and no idle times prior to or after the unavailability period) is easily shown to be NP-hard, and an efficient pseudo-polynomial dynamic programming algorithm is introduced. Extensions of the algorithm to general monotonic job-independent costs, and to linear job-dependent costs are studied as well. All algorithms are tested numerically, and are shown to produce optimal schedules in reasonable time. Then we allow idle times, verify that this case is NP-hard in the ordinary sense as well, and introduce a greedy-type heuristic. Numerical tests are performed, and the results indicate that the heuristic performs extremely well.