Pseudo-polynomial Dynamic Programming 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.

Exact and Approximation Algorithms for Minimizing Energy in Wireless Sensor Data Gathering Network with Data Compression

This article studies the problem of minimizing the total energy consumed in a heterogeneous wireless sensor data gathering network with data compression. In a wireless sensor data gathering network, a set of sensors is used to collect data and all the data are required to be transmitted to a single base station. Whether the base station is working in data receiving or idle mode, it consumes energy. To reduce the data transmission time, each sensor has the option to compress its collected data to decrease the original size before sending the data to the base station. However, compressing data takes some time delaying the data transmission starting time and also consuming energy. The task is to choose which sensors should compress their data and determine the data transmission order between the sensors and the base station with the goal of minimizing the total energy consumed. We prove that the studied problem is NP-hard, and propose a pseudo-polynomial dynamic programming exact algorithm. Furthermore, we present an approximation algorithm with the performance ratio that depends on the given energy consuming parameters for each unit time in different energy consuming activities.

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.

Scheduling problems on a new setting of flexible flowshops: ℓ-Machine proportionate flowshops

The classical flexible flowshop () environment consists of -stages in series with -machines in parallel at each stage, where each job has to undergo a particular series of actions. In this paper we consider a similar, yet different, and still a challenging real-life setting, that, to the best of our knowledge, has not been studied to date. We assume that there are -sets in parallel in which each of the sets is an -machine proportionate flowshop. In this new setting, each job can be processed on each one of the sets, but once a set is chosen, the job must be processed on all of its machines, in first-in-first-out method. We study several fundamental scheduling measures such as makespan, maximum tardiness with common due-date, total tardiness with common due-date, and total load. Moreover, we consider optional job-rejection and focus on minimising the total completion time. All problems are shown to be NP-hard, and pseudo-polynomial dynamic programming (DP) solution algorithms and Simulated Annealing (SA) metaheuristics are provided. The efficiency of all our proposed algorithms is validated through an extensive numerical study.

Time-critical testing and search problems

This paper introduces a problem in which the state of a system needs to be determined through costly tests of its components by a limited number of testing units and before a given deadline. We also consider a closely related search problem in which there are multiple searchers to find a target before a given deadline. These natural generalizations of the classical sequential testing problem and search problem are applicable in a wide range of time-critical operations such as machine maintenance, diagnosing a patient, and new product development. We show that both problems are NP-hard, develop a pseudo-polynomial dynamic program for the special case of two time slots, and describe a partial-order-based as well as an assignment-based mixed integer program for the general case. Based on extensive computational experiments, we find that the assignment-based formulation performs better than the partial-order-based formulation for the testing variant, but that this is the other way round for the search variant. Finally, we propose a pairwise-interchange-based local search procedure and show that, empirically, it performs very well in finding near-optimal solutions.

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.

Minimizing total late work on a single machine with generalized due-dates

We study single machine scheduling problems with generalized due-dates. The scheduling measure is minimum total late work. We show that unlike the classical version (assuming job-specific due-dates), this problem has a polynomial time solution. Then, the problem is extended to allow job rejection. First, an upper bound on the total permitted rejection cost is assumed. Then we study the setting whereby the rejection cost is part of the objective function, which becomes minimizing the sum of total late work and rejection cost. We prove that both versions are NP-hard, and introduce pseudo-polynomial dynamic programming solution algorithms. We then consider a setting in which the machine is not available for some period (e.g., due to maintenance). Again, a pseudo-polynomial dynamic programming is introduced for the (NP-hard) problem of minimizing total late work with generalized due-dates and unavailability period. These dynamic programming algorithms are tested numerically, and proved to perform well on problems of various input parameters. Then, the extension to the weighted case, i.e., the problem of minimizing total weighted late work with generalized due-dates is proved to be NP-hard. Finally, we study a slightly different setting, in which the given due-dates are assigned to jobs, but there is no restriction on their order, i.e., the j-th due-date is not necessarily assigned to the j-th job in the sequence. We show that this problem (known as scheduling assignable due-dates) to minimize total late work is NP-hard as well.

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.