In this note, we revisit two types of scheduling problem with weighted early/late work criteria and a common due date. For parallel identical machines environment, we present a dynamic programming approach running in pseudopolynomial time, to classify the considered problem into the set of binary NP-hard. We also propose an enumeration algorithm for comparison. For two-machine flow shop systems, we focus on a previous dynamic programming method, but with a more precise analysis, to improve the practical performance during its execution. For each model, we verify our studies through computational experiments, in which we show the advantages of our techniques, respectively.

1. Introduction

Scheduling with due date constraint [1, 2] has been widely studied in the field of combinatorial optimization, such as minimizing tardiness [3], lateness [4], or the number of late jobs [5]. Among all the criteria related to the due date, late work [6] and early work [7] are a pair of symmetrical objectives, in which the former one indicates the loss once a job is finished after its due date, while the latter one implies the profit when a job starts execution before this time.

The concept of late work was first proposed in 1984 by Błażewicz [8], who was motivated from the scene of data collection in a control system, and, therefore, he called this parameter “information loss” at that time. Then, in 1992, Potts and Van Wassenhove [9] claimed that this criterion can model not only information collection but also other situations where a perishable commodity is involved, so they suggested using the term “late work.” After these pioneers, scheduling with late work minimization has attracted much attention from different research groups, for example, [1014].

Although the formal investigation on the early work maximization problem was started from 2017 [7], this parameter has already appeared frequently in the literature since 2004, which was used as auxiliary metrics when analysing the optimal schedules for late work problems, for example, [10, 11]. Due to the symmetry of these two criteria, scheduling with late work minimization and early work maximization shares the same essence when the offline optimal solutions are constructed. However, since the difference when an approximation solution is evaluated [12], scheduling with early work criterion gradually became a new subject, and several studies were devoted to it [13, 14].

In this note, we revisit two types of scheduling problem with a common due date to maximize total weighted early work of all jobs or, equivalently, to minimize total weighted late work (in sense of complexity and optimal offline solution analysis). We focus on the identical machines and two-machine flow shop environments, respectively, and, therefore, the problems considered in this paper could be presented as (or equally, ) and (or equally, ), using the classical three-field notation in the scheduling field [15].

The rest of this paper is organized as follows. In Section 2, we give the formal definitions of the studies problems, i.e., and , respectively. Section 3 is devoted to the former problem, where we propose a dynamic programming approach running in pseudopolynomial time and an enumeration algorithm in exponential time, on the basis of a property of an optimal schedule. In Section 4, we focus on a previous dynamic programming method in [16], by introducing some improvement techniques. Finally, the whole paper is concluded in Section 5.

2. Problem Formulation

The early work of a job (denoted as ) is defined as the early part (if any) executed before its due date . That is, let and be the processing and completion time of , respectively; we have

Correspondingly, the late work of (denoted as ) is the late part processing after , i.e.,

Based on the definitions of these two parameters, we have .

Thus, the problems we considered in this paper can be described as follows:(1). Input: there are identical machines and jobs, and each job is accompanied by its processing time , weight , as well as a common due date ().Output: assign the jobs to the machines without preemption, with the goal of maximizing total weighted early work of all jobs (denoted as ), in which .As we mentioned before, the above problem could be presented as by the three-field notation, in which we use in the field to emphasize that it is a maximization problem. Moreover, since the symmetry of early work maximization and late work minimization, we have (so does ), which implies that the results on the complexities and the constructions of the optimal offline solutions could be directly transferred from to .(2). In this model, we are given a two-machine flow shop, and each job (also accompanied with -the processing time of on for , a weight , and a common due date ) has to be processed firstly on and then on . Same as in the previous one, we are aimed to schedule these jobs into the system so that to maximize total weighted early work, i.e., (here we define , in which is the early work of on , for ). It is worth to be mentioned that, when analysing complexity and designing optimal offline algorithms, the problem could be treated as the same as , which is the original representation in [16].

3. Exact Approaches for

In this section, we first introduce a property of an optimal schedule for problem , based on which we propose two exact approaches. Among them, the former one is a dynamic programming method running in pseudopolynomial time, so that we can decide that problem belongs to the set of binary NP-hard, while the latter is an enumeration one, which can help us to verify the correctness and efficiency of the dynamic programming by computational experiments.

3.1. Property of an Optimal Schedule

We now introduce a property of an optimal schedule in Lemma 1, which could help us to design the exact methods for problem latter.

Lemma 1. There exists an optimal schedule for problem such that on each machine, jobs are sequenced in nonincreasing order of their weights.

Proof. Suppose that there exists one of the optimal schedules , in which on machine (), there are two jobs and such that while , where means that precedes (close to) on . Then, we can construct a new schedule by exchanging the positions of the two jobs and show that the criterion value cannot decrease after this modification.
We prove the above declaration based on the possible values of the common due date, i.e., . Denote and as the start and completion time of the job in , respectively ().

Case 1. , which means that both jobs are late in (also in ). Then, the total weighted early work of these two jobs is equal to 0, in both and .

Case 2. , where both jobs are early in (also in ). Then, the criterion value of these two jobs is equal to , in both and .

Case 3. . Then, the total weighted early work of these two jobs in is equal to . We claim that the criterion value would be increased in , since the length of the early parts of the two jobs remains the same (as in ), while the weight becomes higher after the exchanging.
Therefore, in any optimal schedule, by adjusting the positions of the two adjacent jobs which do not follow this order, we can finally get another optimal schedule, which concludes this lemma.

3.2. Dynamic Programming Approach

Based on Lemma 1, we could construct an optimal solution with the following process: (1) we first reorder the job sequence in nondecreasing order of jobs’ weights, i.e., ; (2) then, we assign the jobs in the ordered sequence one by one to a suitable machine, using a dynamic programming approach defined as follows.

Let denote the maximal total weighted early work of the first jobs scheduled on machines, where the early parts are executed for at most units on , respectively. The initial condition should be set as for all the , and the optimal criterion value is output as .

The recurrence procedure runs according to the following formula:

We give the complete procedure in Algorithm 1, denoted as .

(1)Reorder the jobs by nondecreasing order of their weights, i.e., ;
(2)Assign to ;
(3)for ()
(4 )do Calculate to find a suitable machine for with the
(current) maximal criterion value, say ;
(5)Schedule on the first position of , and move the already
scheduled jobs on (if any) backward;

The sorting process requires time, and the dynamic programming approach runs in . Summing up, the time consumption of is , which is pseudopolynomial when is fixed. Then, we have the following theorem.

Theorem 2. Problem belongs the set of binary NP-hard.

Proof (Proof of Theorem 2). This theorem holds since the existence of .

3.3. Enumeration Algorithm

To further reveal the correctness and efficiency of , we also propose an enumeration algorithm for comparison. We first sort the jobs in nonincreasing order of their weights and then enumerate all the possible partitions to find the optimal solution. The procedure is presented in Algorithm 2 denoted as .

(1)Reorder the jobs by nonincreasing order of their weights, i.e., ;
(2)Enumerate all the possible partitions of the job set;
(3)for each partition
(4)do Keep the nonincreasing order of the jobs on each machine;
(5)Calculate the criterion value for this schedule;
(6)Output the best solution with the maximal criterion value;

Since there are machines and jobs, it takes time to check all the possible schedules. Therefore, runs in time.

3.4. Computational Experiments

To compare the two algorithms proposed in Sections 3.2 and 3.3, we design a set of numerical experiments in this part. Since both of them return the optimal solutions, we focus on the efficiencies of these approaches, i.e., their time consumption.

Motivated by [7], we set the experiment data by the following process. The job processing time was randomly taken with a discrete uniform distribution from , and the weight was taken also from this range. The common due date is set to be . Moreover, due to the memory limitation, we set when , and when .

Both of the two algorithms were implemented in C++ with the IDE of Microsoft Visual Studio 2017 and executed on a PC with Intel Core i7-8550U 1.8 GHz CPU and 8 GB DDR4 RAM. For each pair of , we generate 25 random instances and show the results in Table 1, in which the running time of and is reported in milliseconds ().

From Table 1, we can find that works much more efficiently than . Basically, the time consumption of is ( for most of the case) while takes time, which results in the fact that the latter one needs more time when processing the same setting of than the former. More precisely, for a fixed , the time consumption of increases slowly while increases drastically, along with the increment of . This is mainly because that could be considered as a linear function of while is an exponential one, when is fixed. Finally, has to stop at when is 2, and when is 3, due to the limitation of memory. However, could solve all the test sequences, mostly within 1 second in our experiments.

4. Precise Analysis on

In this section, we focus on a previous dynamic programming approach proposed in [16] (denoted as in this paper) for problem and introduce several improvement techniques by carefully analysing the characteristics of some parameters. Through computational experiments, we show that these skills are effective to help us to obtain the optimal solutions faster than the original version.

4.1. Brief Introduction on

In [16], the authors considered problem (which is the same as since they focused on the complexity and the construction of the offline optimal solutions) and proposed a dynamic programming approach running in . The result is very important since it can solve the problem optimally and clarify the problem complexity clearly (binary NP-hard).

For a job set , adopts an enumeration with a recurrence process to find the first partially late job (denoted as ) and divides the remaining jobs into three subsets, which are (all the totally early jobs), (all the partially late jobs except for ), and (all the totally late jobs). Then, returns an optimal schedule as , in which(1)Jobs in are sequenced by Johnson’s order [17](2)A special job in should take the last position in this set if it exists, while the others are sequenced arbitrarily(3)Jobs in are scheduled arbitrarily

enumerates each job one time as the potential . For each selection (say ), it uses a recurrence process to obtain the maximal total weighted early work, under the assumption that is the “first partially late job.” The recurrence process runs based on a state function , which denotes the maximum weighted early work among jobs ( is actually in the current case), when these jobs start exactly at time on and not earlier than at time on . Moreover, parameter means that there are exactly time units remained on after and before the common due date , while  = 0 (or 1) means that there is no job (or only one job) among partially executed on after and before . For each selection of , the initial state is set to be for all , and based on several different conditions, while the optimal weighted early work under this assumption ( is the first partially late job) is output by . The above recurrence process needs time, and, therefore, considering the enumeration of every job as , the whole procedure of requires time. For further details of this approach, refer to [16] or [18].

4.2. Several Improvement Techniques

is a very important result for (so does for ) since it declared problem complexity more precisely. However, from the implementation point of view, we found that some details could be analysed, which can result in the fact that some unnecessary calculations could be avoided.

Based on the characteristic of flow shop scheduling, we claim the relationship of and in each state , in Property 1.

Property 1. For each state in , , where means the processing time of on .

Moreover, due to the definitions of , , and in the state function, we declare Property 2.

Property 2. For each state in , .

Therefore, for the states that violate the above properties, we set their values directly as “−” without further calculations. Consequently, we denote the procedure introducing these two properties as .

4.3. Computational Experiments

The same as in section 3.4, we introduce a series of numerical experiments to show the advantages of the properties in 4.2, i.e., we compare with .

We adopt the data set from [18] for our experiments, in which , an enumeration algorithm, and several heuristics for problem (also available for ) were compared. According to this literature, the job number was selected from , while the processing time and the job weight were randomly taken from and , respectively. Finally, the common due date was set to be 30% of the mean machine load, i.e., .

We use the same language and platform as in Section 3.4, i.e., C++ and a PC with Intel Core i7-8550U 1.8 GHz CPU and 8 GB DDR4 RAM. For each value of , we generate 25 random instances and report the experiment results in Table 2. For each procedure, its average running time (in milliseconds, ) is shown in the columns of “time ()”. Moreover, the improvement ratio from to , calculated as (where and are the running time of and , respectively), is displayed in column “Imp (%)”.

Now, we see the power of the two properties in Section 4.2, at least from the implementation point of view. For all the settings of value , beats , and, on average, the former procedure saves 21.17% of the execution time of the latter one. The reason is that can avoid several unnecessary calculations if the two properties are violated.

5. Conclusions

In this paper, we considered two problems of scheduling on multimachine with weighted early work maximization (or equivalently, late work minimization):(1)For identical machines version, i.e., problem , we proposed a dynamic programming approach () running in pseudopolynomial time and, therefore, showed that the problem is NP-hard in the weak sense. We also designed an enumeration algorithm (), to reveal the correctness and efficiency of through computational experiments.(2)For two-machine flow shop setting (), we studied a previous dynamic programming approach by precise analyses. By introducing two properties in the state function, some unnecessary calculations could be avoided during processing. Finally, we again used the computational experiments to show that these improvements are efficient at least from the implementation point of view.

For the future work, one can consider the more general cases, e.g., the individual due date models, and design exact or heuristic algorithms to solve them. Moreover, the approximation analyses for some special cases, especially for the flow or job shop setting, could be considered as another research direction.

Data Availability

The authors use the benchmarks from their references.

Conflicts of Interest

The authors declare that there are no conflicts of interest in this paper.


This research was funded by the Korea-China Young Researchers Exchange Program (2020), the Science Foundation of Shenyang University of Chemical Technology (no. LQ2020020), the Program for Liaoning Innovation Talents in University (no. LR2019034), and the Key Lab for OCME (School of Mathematical Sciences in Chongqing Normal University).