Two-Agent Pareto-Scheduling of Minimizing Total Weighted Completion Time and Total Weighted Late Work

We investigate the Pareto-scheduling problem with two competing agents on a single machine to minimize the total weighted completion time of agent A’s jobs and the total weighted late work of agent B’s jobs, the B-jobs having a common due date. Since this problem is known to be NP-hard, we present two pseudo-polynomial-time exact algorithms to generate the Pareto frontier and an approximation algorithm to generate a (1 + e)-approximate Pareto frontier. In addition, some numerical tests are undertaken to evaluate the effectiveness of our algorithms.


Introduction
Problem description and motivation: Multi-agent scheduling has attracted an ever-increasing research interest due to its extensive applications (see the book of Agnetis et al. [1]). Among the common four problem-versions (including lexical-, positive-combination-, constrained-, and Pareto-scheduling, as shown in Li and Yuan [2]) for a given group of criteria for multiple agents, Pareto-scheduling has the most important practical value, since it reflects the effective tradeoff between the actual and (usually) conflicting requirements of different agents.
Our considered problem is formally stated as follows. Assume that two agents (A and B) compete to process their own sets of independent and non-preemptive jobs on a single machine. The set of the n X jobs from agent X ∈ {A, B} is J X = {J X 1 , J X 2 , · · · , J X n X } with J A ∩ J B = φ. For convenience, we call a job from agent X an X-job. All jobs are available at time zero, and are scheduled consecutively without idle time due to the regularity of the objective functions as shown later. Each job J X j has a processing time p X j and a weight w X j . In addition, each B-job J B j has also a common due date d. We assume that all parameters p X j , w X j and d are known integers. Let σ be a schedule. We use C X j (σ) to denote the completion time of job J X j in σ. The objective function of agent A is the total weighted completion time, denoted by ∑ w A j C A j (σ), while the objective function of agent B is the total weighted late work, denoted by ∑ w B j Y B j (σ). Here, the late work Y B j (σ) of job J B j indicates the amount processed after the due date d, specifically, Following Hariri et al. (1995) [3], job J B j is said to be early, partially early, and late in σ, if Y B j (σ) = 0, 0 < Y B j (σ) < p B j , and Y B j (σ) = p B j , respectively. Falling into the category of Pareto-scheduling, the problem studied in this paper aims at generating all Pareto-optimal points (PoPs) and the corresponding Pareto-optimal schedules (PoSs) (the definitions of PoPs and PoSs will be given in Section 2) of all jobs with regard to ∑ w A j C A j and ∑ w B j Y B j ). Using the notations in Agnetis et al. [1], our studied scheduling problem can be denoted by . For this problem, we will devise some efficient approximate algorithms. Our considered scheduling model arises from many practical scenarios. For example, in a factory, two'concurrent projects (A and B), each containing a certain amount of activities with distinct importance, have to share a limited resource. The former focuses on the mean completion time of its activities. In contrast, the latter requires its activities to be completed before the due date as much as possible, since, otherwise, the shortcomings of some key technical forces after the due date will occur and result in irretrievable loss. It is necessary to model the goal of project B as the weighted late work, that is, minimizing the parts left unprocessed before the due date. In addition, two projects naturally have to negotiate to seek a trade-off method of utilizing the common resource.
For another example, in a distribution center, two categories (A-and B-) goods are stored in a warehouse, in which the former comprises common goods and the latter comprises fresh goods with a shelf life. It is hoped that the shipping preparations for the A-goods will be completed as soon as possible. However, due to their limited shelf life, if they are transported after a certain time, the B-goods will not be fresh enough when they reach the customers. Therefore, it is reasonable to respectively model the goals of A-goods and B-goods by minimizing the total weighted completion time and the total weighted late work, and seek an efficient transportation method.
Related works and our contribution: Numerous works have addressed multi-agent scheduling problems in the literature. With the aim of this paper, we only summarize briefly some related results. Wan et al. [4] provided a strongly polynomial-time algorithm for the two-agent Pareto-scheduling problem on a single machine to minimize the number of the tardy A-jobs and the maximum cost of the B-jobs. Later, Wan et al. [5] investigated two Pareto-scheduling problems on a single machine with two competing agents and a linear-deterioration processing time: where ∑ E A j is the total earliness of the A-jobs and E X max is the maximum earliness of the X-jobs. For these two problems, they respectively proposed a polynomial-time algorithm. Gao and Yuan [6] showed that the following two Pareto-scheduling problems with a positional due index and precedence constraints are both polynomially solvable: where f X max indicates the maximum cost of the X-jobs. He et al. [7] extensively considered the versions of the problems in Gao and Yuan [6] with deteriorating or shortening processing times and without positional due indices and precedence constraints, and devised polynomial-time algorithms. Yuan et al. [8] showed the single-machine preemptive problem 1|r j , pmtn| # (L a max : L b max ) can be solved in a polynomial time, where L X max indicates the maximum lateness of the X-jobs. Wan [9] investigated the single-machine two-agent scheduling problem to minimize the maximum costs with position-dependent jobs, and developed a polynomial-time algorithm.
While most results on Pareto-scheduling concentrate on devising exact algorithms to obtain the Pareto frontier, there are also some methods (such as [10][11][12][13][14]) of developing approximate algorithms to generate the approximate Pareto frontier. Dabia et al. [10] adopted the trimming technique to derive the approximate Pareto frontier for some multi-objective scheduling problems. Yin et al. [15] considered two just-in-time (JIT) scheduling problems with two competing agents on unrelated parallel machines, in which the one agent's criterion is to maximize the weighted number of its JIT jobs, and another agent's criterion is either to maximize its maximum gains from its JIT jobs or to maximize the weighted number of its JIT jobs. They showed that the two problems are both unary NP-hard when the machine number is not fixed, and proposed either a polynomial-time algorithm or a fully polynomial-time approximation scheme (FPTAS) when the machine number is a constant. Yin et al. [16] also considered similar problems in the setting of a two-machine flow shop, and provided two pseudo-polynomial-time exact algorithms to find the Pareto frontier. Chen et al. [17] studied a multi-agent Pareto-scheduling problem in a no-wait flow shop setting, in which each agent's criterion is to maximize its own weighted number of JIT jobs. They showed that it is unary NP-hard when the number of agents is arbitrary, and presented pseudo-polynomial time algorithms and an (1, 1 − , . . . , 1 − )-approximation algorithm when the number of agents is fixed.
From the perspective of methodology, as a type of optimization problem, the multi-agent scheduling problem's solution algorithms potentially allow for exploiting the optimal robot path planning by a gravitational search algorithm (Purcaru et al. [18]) and optimization based on phylogram analysis (Soares et al. [19]).
In the prophase work (Zhang and Yuan [20]), we proved that the constrained scheduling problem of minimizing the total late work of agent A's jobs with equal due dates subject to the makespan of agent B's jobs not exceeding a given upper bound, is NP-hard even if agent B has only one job. It implies the NP-hardness of our considered problem in this paper. Thus we limit the investigation to devising pseudo-polynomial-time exact algorithms and an approximation algorithm to generate the approximate Pareto frontier.
In addition, in our recent work (Zhang et al. [21]), we considered several three-agent scheduling problems under different constraints on a single machine, in which the three agents' criteria are to minimize the total weighted completion time, the weighted number of tardy jobs, and the total weighted late work. Among those problems, there are two questions related to this paper: , which is solved in O(n A n B U A U B ). The notation p A j ↑↓ w A j represents that the jobs of the first agent have inversely agreeable processing times and weights, i.e., the smaller the processing time for a job, the greater its weight, and the notation d B j ↑↓ w B j represents that the jobs of agent B have inversely agreeable due dates and weights. U A and U B are the upper bounds on the criteria Σw A j C A j and Σw B j Y B j , respectively. In contrast to Zhang et al. [21], in this article we remove the constraint p A j ↑↓ w A j and turn to the optimization problem of B-jobs having a common due date.
The remainder of the paper is organized as follows. In Section 2, some preliminaries are provided. In Sections 3 and 4, we present two dynamic programming algorithms and an FPTAS. In Section 5, some numeral tests are undertaken to show the algorithms' efficiency. Section 6 concludes the paper and suggests the future research direction.

Preliminaries
For self-consistency, in this section we describe some notions and properties related to Pareto-scheduling, and we present other useful notations in the description of the algorithms in the following sections.  Definition 2. Given two agents' criteria γ A (σ) and γ B (σ), a feasible schedule σ is called Pareto-optimal and the corresponding objective vector (γ A (σ), γ B (σ)) is called a Pareto-optimal point, if no other feasible schedule π satisfies (γ A (π), γ B (π)) ≺ (γ A (σ), γ B (σ)). All the Pareto-optimal points form the Pareto frontier, denoted by P.
Let R be the set of the objective vectors of all feasible schedules, and Q be a subset of R.
It is not difficult to see that, for the above definitions, the latter is an extension of the former, and especially when Q is exactly equal to R, all the non-dominated vectors in Q compose the Pareto-optimal frontier. The following lemma establishes the relationship between sets P and a subset Q ⊆ R. Lemma 1. For any set Q with P ⊆ Q ⊆ R, if O is the set including all the non-dominated vectors in Q, then O = P.
Proof. By Definition 2, for each Pareto-optimal point u ∈ P, there is no other vector v ∈ R such that v ≺ u, and naturally, such a fact also holds for the set Q, since Q ⊆ R. Then, it follows that P ⊆ O by the definition of the set O. Next we show that O ⊆ P. If not, we pick up one vector w from O \ P. Again by Definition 2, there is some vector w ∈ P such that w ≺ u. Nevertheless, this is impossible, since w ∈ P ⊆ Q leads to no existence of such a vector w in Q by the assumption of w and Definition 3. Thus O = P.
From Lemma 1, to generate the Pareto frontier P, an alternative is to first determine a set Q with P ⊆ Q ⊆ R, and then delete the dominated vectors in Q. Throughout the reminder of this paper, such a subset Q is called an intermediate set. Obviously, R is also an intermediate set.

Definition 4. For a given constant
> 0, a (1 + )-approximate Pareto frontier, denoted by P , is a set of the objective vectors satisfying, for any (γ A (σ), γ B (σ)) ∈ P, there exists at least one objective vector Besides those already mentioned in Section 1, the following notations will also be used later: j=1 p X j indicates the total processing time of all X-jobs. • P sum indicates the total processing time of all jobs, and P sum = P A sum + P B sum .
j=1 w X j indicates the total weight of all X-jobs.
• W sum indicates the total weight of all jobs, and W sum = W A sum + W B sum . • p X max indicates the maximum processing time of the X-jobs, namely, p X max = max{p X j : 1 ≤ j ≤ n X }. • w X max indicates the maximum weight of the X-jobs, namely, w X max = max{w X j : 1 ≤ j ≤ n X }.

An Exact Algorithm
In this section a dynamic programming algorithm for problem 1|d For description convenience, for a given schedule σ, the job set J is divided into the following four subsets: Obviously, such a partition of the job set is well defined for a given schedule.
The following lemma establishes the structural properties of the Pareto-optimal schedule.
(ii) the jobs in J B 1 (σ) are sequenced in the non-increasing order of their weights and the jobs in J B 2 (σ) are sequenced arbitrarily. (iii) the jobs in J A 1 (σ) and J A 2 (σ) are sequenced according to the weighted shortest processing time (WSPT) rule.
Proof. In Lemma 2, statement (i) can easily be observed, since the jobs in J B 2 (σ) are late and this will not result in any increase in their total late work when moving them to the end of the schedule, and as many A-jobs as possible can be positioned before the B-jobs in J B 1 (σ), provided that the last job in J B 1 (σ) is not late. The left two statements in Lemma 2 can easily be proved by an interchange argument and the detail is omitted here.
Lemma 2 allows us only to consider the feasible schedules simultaneously satisfying the conditions (i)-(iii). To this end, we re-number the n A jobs in J A in the WSPT order and the n B B-jobs in the maximum weight first (MW) order so that Such a sorting takes O(n log n) time.
According to Lemma 1, the algorithm to be described adopts the strategy of first finding the intermediate set dynamically and then deleting the dominated points in it. It is necessary to mention that in the proposed algorithm we appropriately relax the conditions to find a modestly larger intermediate set.
For briefly describing the dynamic programming algorithm, we introduce the following terminologies and notations. • an ABAB-schedule is defined to be a schedule π for I ⊆ J satisfying (i) π = π 1 ≺ π 2 ≺ π 3 ≺ π 4 , where among the four mutually disjointed subschedules π 1 , π 2 , π 3 , andπ 4 , the A-jobs are included in π 1 and π 3 , and the B-jobs are included in π 2 and π 4 ; (ii) no idle time exists between the jobs in each subschedule, but this is not necessarily so between two subschedules. Moreover, the idle time between π 3 and π 4 is supposed to be long enough; (iii) the jobs in each subschedule are sequenced in the increasing order of their indices. • an ( − → x , ← − y )-schedule is defined to be an ABAB-schedule π for J A x ∪ (J B \ J B y−1 ) with no idle time existing between subschedules π 2 and π 3 , where x ∈ {1, 2, . . . , n A } and y ∈ {1, 2, . . . , n B }.
• a vector (t 1 , t 2 , t 3 , C, Y) is introduced to denote a state of ( − → x , ← − y ), in which t 1 , t 2 , t 3 , C, and Y, respectively, stand for the end point of π 1 , the start point of π 2 , the end point of π 3 , the total weighted completion time of the A-jobs of J A x , and the total weighted late work of the B-jobs of }, and letQ 1 be the set of the non-dominated vectors in Q 1 .
and then obtain the Pareto-frontierQ 1 . This can be realized by dynamically computing the sets Γ( − → x , ← − y ) for all the possible choices of the tuple (x, y). Note that each ( − → x , ← − y )-schedule can be obtained either by adding job Therefore, we can informally describe our dynamic programming algorithm as follows. Initially These two states respectively correspond to the newly obtained ( − → x , ← − y )-schedules by scheduling job J A x immediately following the subschedule π 1 and immediately following the subschedule π 3 , in some ( −−→ x − 1, ← − y ) schedule π that corresponds to the state (t 1 , t 2 , t 3 , C, Y). Note that the first case occurs only when These two states respectively correspond to the newly obtained ( − → x , ← − y )-schedules by scheduling job J B y immediately preceding the subschedule π 2 and immediately following the subschedule π 4 , in some ( − → x , ←−− y + 1) schedule π that corresponds to the state (t 1 , t 2 , t 3 , C, Y). Note that the first case occurs only when t 1 ≤ t 2 − p B y < d B is satisfied. Note that, if in the above state-generation procedures we replace sets Γ( , then the resulting set of new states, denoted by Γ ( − → x , ← − y ), may be different from Γ( − → x , ← − y ). Recall that, when deleting those dominated vectors in the sets Γ( − → x , ← − y ) and Γ ( − → x , ← − y ), the newly obtained sets are respectively denoted byΓ( − → x , ← − y ) andΓ ( − → x , ← − y ), which will be shown to be identical in the following lemma.
by the generation procedure of the new states as described previously.
Proof. The correctness of Algorithm 1 is guaranteed by Lemma 2, Lemma 1, and Lemma 3. Here we only analyze its time complexity. The initialization step takes O(P sum + n A n B ) time, which is dominated by the final time complexity of Algorithm 1. In the implementation of Algorithm 1, we guarantee that

In this section, for problem 1|d
, we first give another dynamic programming algorithm, and then turn it into an FPTAS by the trimming technique. As for Algorithm 1, we first introduce the following terminologies and notations.

•
An (x, y)-schedule is defined to be an ABAB-schedule π for J A x ∪ J B y with no idle time existing between subschedules π 1 , π 2 and π 3 , where x ∈ {1, 2, . . . , n A } and y ∈ {1, 2, . . . , n B }. • A vector (t 1 , t 2 , t 3 , W, k(π), C, Y) is introduced to denote a state of (x, y), in which t 1 , t 2 , t 3 , W, k, C and Y, respectively, stand for the end point of π 1 , the end point of π 2 , the end point of π 3 , the total weight of the jobs in π 3 , the index of the last B-job in π 2 , the total weighted completion time of the A-jobs of J A x , and the total weighted late work of the B-jobs of J B y . Note that a state of (x, y) at least corresponds to some (x, y)-schedule.
• Γ(x, y) denotes the set of all the states of (x, y). •Γ(x, y) denotes the set obtained from Γ(x, y) by deleting the vectors (t 1 , t 2 , t 3 , W, k, C, Y), for which there is another vector (t 1 , , n B )}, and letQ 2 be the set of the non-dominated vectors in Q 2 .
Clearly, Q 2 is an intermediate set.
Similarly to the discussion for Algorithm 1, we can generate all the Γ(x, y) for all the possible choices of the tuple (x, y) dynamically in the following way.
These two states respectively correspond to the newly obtained (x, y)-schedules by scheduling job J B y immediately after π 2 and immediately following the subschedule π 4 , in some (x, y − 1) schedule π that corresponds to the state (t 1 , t 2 , t 3 , W, k, C, Y). Note that the first case occurs only when t 2 < d B is satisfied. Note that, if in the above state-generation procedures we replace sets Γ(x − 1, y) and Γ(x, y − 1) with setsΓ(x − 1, y) andΓ(x, y − 1), then the resulting set of new states, denoted by Γ (x, y), may be different from Γ(x, y). Recall that, when deleting those dominated vectors in the sets Γ(x, y) and Γ (x, y), the newly obtained sets are respectively denoted byΓ(x, y) andΓ (x, y), which will be shown to be identical in the following lemma, and its proof is similar to that of Lemma 3.
Next we analyze its time complexity. The initialization step takes O(n A n B ) time, which is dominated by the final time complexity of Algorithm 3. In the implementation of Algorithm 3, we guarantee that Γ(x, y) = Γ(x, y). Note that there are O(L 1 L 3 L W L A L B ) distinct boxes and 0 ≤ k ≤ n B , then there are at most O(n B L 1 L 3 L W L A L B ) different states (t 1 , t 2 , t 3 , W, k, C, Y) in Γ(x, y). Moreover, Γ(x, y) is obtained by performing at most two (constant) operations on the states in Γ(x − 1, y) Γ(x, y − 1) for x = 0, 1, . . . , n A , y = 0, 1, . . . , n B . Thus, the overall running time of Algorithm 3 is O(n A n 2 B L 1 L 3 L W L A L B ).

Numerical Results
In this section some numerical results are provided to show the efficiency of our proposed algorithms. For running our optimization algorithms, we need to input the following parameters relative with the job instances: the numbers of A-jobs and B-jobs, the processing times and weights of all the jobs, and the common due date of B-jobs. By running Algorithms 1 and 2, we get the Pareto frontier. To use Algorithm 3, we need to choose the value of (>0) to get a (1 + )-approximate Pareto frontier. Note that for the same instance, the Pareto frontiers obtained by Algorithms 1 and 2 are the same, except that the running time of Algorithm 1 is theoretically faster than that of Algorithm 2. The closer the (1 + )-approximate Pareto frontier obtained by Algorithm 3 is to the curve obtained by Algorithms 1 and 2, the closer it is to the optimal solution.
We randomly generate some job instances, in which the numbers of the jobs are set to be n = 4 (n A = n B = 2), n = 6 (n A = n B = 3), and n = 10 (n A = n B = 5). The processing times and the weights of the jobs are randomly generated between 1 and 2. The common due date of B-jobs is set to be 5. What is more, we set = 1. We ran our algorithms on these instances in a Matlab R2016b environment on an Intel(R) Core(TM) CPU, 2.50 GHz, 4 GB of RAM computer. In fact, when the number of the jobs is small, the Pareto frontier or the approximate Pareto frontier can be found relatively quickly, but when the number of the jobs increases, the running time will increase hugely. The following three Figures 1-3 present the Pareto frontier and (1 + )-approximate Pareto frontier generated by Algorithms 1-3. As can be seen from the three figures, the results obtained by Algorithms 1 and 2 are exactly the same. The results of Algorithm 3 are consistent with those of Algorithms 1 and 2, which may be due to the coincidence caused by the small size of the instance we chose and the few choices in the sizes of the jobs. In fact, considering that the problem we studied is NP-hard, our algorithm can only reach pseudo-polynomial-time theoretically. Therefore, our algorithm is theoretically more suitable for small-scale instances, where the sizes of the jobs are relatively uniform, which fits with the nature of such problems in real life, such as in logistics distribution centers where we use boxes of fixed sizes.   Figure 3. The black stars are the points generated by Algorithms 1 and 2, the red circles are points generated by Algorithm 3.

Conclusions
In this paper we investigated a Pareto-optimal problem of scheduling two agents' jobs on a single machine to minimize one agent's total weighted completion time and the other's total weighted late work. For this problem, we devised two dynamic programming algorithms to obtain the Pareto frontier, and an FPTAS to generate an approximate Pareto frontier. Some numerical results were also provided. Compared with the two problems 1|p A j ↑↓ w A j | # (Σw A j C A j , Σw B j Y B j ) and 1|p A j ↑↓ w A j , d B j ↑↓ w B j | # (Σw A j C A j , Σw B j Y B j ) studied in Zhang et al. [20], the constraint p A j ↑↓ w A j was removed from the problem considered in this paper and we turned to the optimization problem under the condition that B-jobs had a common due date. Table 1 lists the computational complexity of the above three problems. As we can see from Table 1, the condition p A j ↑↓ w A j seems to have a greater impact on the complexity result of the problem. In future research, we can try to devise more efficient approximation algorithms for our considered problem with a constant performance-ratio, and we can also study two-agent problems with other combinations of objective functions.