A Combinatorial 2-Approximation Algorithm for the Parallel-Machine Scheduling with Release Times and Submodular Penalties

Abstract

In this paper, we consider parallel-machine scheduling with release times and submodular penalties ($P|r_j,reject|C_{max}+\pi \left(R\right)$), in which each job can be accepted and processed on one of m identical parallel machines or rejected, but a penalty must paid if a job is rejected. Each job has a release time and a processing time, and the job can not be processed before its release time. The objective of $P|r_j,reject|C_{max}+\pi \left(R\right)$ is to minimize the makespan of the accepted jobs plus the penalty of the rejected jobs, where the penalty is determined by a submodular function. This problem generalizes a multiprocessor scheduling problem with rejection, the parallel-machine scheduling with submodular penalties, and the single machine scheduling problem with release dates and submodular rejection penalties. In this paper, inspired by the primal-dual method, we present a combinatorial 2-approximation algorithm to $P|r_j,reject|C_{max}+\pi \left(R\right)$. This ratio coincides with the best known ratio for the parallel-machine scheduling with submodular penalties and the single machine scheduling problem with release dates and submodular rejection penalties.

1. Introduction

All jobs must be accepted and processed in classical scheduling problems [1,2,3,4]. However, to gain more profit, we can reject some jobs that have a larger processing time and result in smaller profits. Bartal et al. [5] first addressed the multiprocessor scheduling problem with rejection (MSR), in which the jobs can be rejected and a penalty must paid for each rejected job. The objective is to minimize the makespan of the accepted jobs plus the total penalty of the rejected jobs. For the MSR, Bartal et al. [5] proposed a 2-approximation algorithm in time $O(nlogn)$ and a polynomial-time approximation scheme (PTAS). Later, Ou et al. [6] improved a (3/2+$\epsilon$)-approximation algorithm in time $O(nlogn+\frac{n}{\epsilon })$, where $\epsilon >0$ can be any small given constant.

Variants of the MSR have been studied extensively [7,8,9]. Zhang et al. [7] considered single machine scheduling with release dates and rejection, where jobs cannot be processed before their corresponding release dates. The objective is to minimize the makespan of the accepted jobs plus the total penalty of the rejected jobs. They proved that this problem is $NP$-hard, and presented a 2-approximation algorithm and a fully polynomial-time approximation scheme (FPTAS). Zhong et al. [10] considered two parallel-machine scheduling with release dates and rejection, and presented a (3/2+$\epsilon$)-approximation algorithm with time complexity $O\left({\left(\frac{n}{\epsilon }\right)}^2\right)$, where $\epsilon$ is any given small positive constant. Zhang and Lu [8] considered parallel-machine scheduling with release dates and rejection, and presented a 2-approximation algorithm. In particular, when m is a fixed constant, Zhang and Lu [8] designed an FPTAS.

A set function $f(·)$ of J is a mapping from all subsets of J to real numbers, i.e., $f(·):2^J\to R$. A set function $f(·)$ is submodular if it satisfies $f(X\cup Y)+f(X\cap Y)\le f\left(X\right)+f\left(Y\right),\forall X,Y\subseteq J$, which has the property of decreasing marginal return. Recently, submodular functions have played a key role in the field of combinatorial optimization [9,11,12,13]. Liu and Li [14] considered parallel-machine scheduling with submodular penalties and proposed a $(2-\frac{1}{m})$-approximation algorithm based on the greedy method and list scheduling algorithm. Zhang et al. [15] considered precedence-constrained scheduling with submodular rejection on parallel machines, and proposed a 3-approximation algorithms. Based on the primal-dual method, Liu and Li presented a 2-approximation algorithm for [16] single machine scheduling with release dates and submodular rejection penalty. More related results can be found in the surveys [17,18,19,20,21,22,23].

Motivated by the optimization problems mentioned-above, we consider parallel-machine scheduling with release times and submodular penalties ($P|r_j,reject|$ $C_{max}+\pi \left(R\right)$), which is defined as follows.

Given a set $J=\{J_1,J_2,\dots ,$$J_n\}$ of n jobs and a set $M=\{M_1,M_2,\dots ,$$M_m\}$ of m parallel machines, each job $J_j\in J$ has a processing time $p_j(\ge 0)$ and a release time $r_j(\ge 0)$, where the job can be processed at or after its release time, without loss of generality, we assume that ${min}_{j:J_j\in J}{r}_j=0$. For the penalty submodular function $\pi (·):2^J\to$${\mathbb{R}}_{\ge 0}$, without loss of generality, we assume that $\pi (\varnothing )=0$. The $P|r_j,reject|C_{max}+\pi \left(R\right)$ is to find a rejected set R, The objective is to minimize the makespan of the accepted jobs $J\backslash R$ plus the penalty of R, where the penalty is determined by penalty submodular function $\pi (·)$.

Clearly, if $r_j=0$ for $J_j\in J$, the $P|r_j,reject|C_{max}+\pi \left(R\right)$ problem is exactly the parallel-machine scheduling with submodular penalties considered in [14]; If the rejection cost function is linear, the $P|r_j,reject|C_{max}+\pi \left(R\right)$ problem is exactly the parallel-machine scheduling with penalties considered in [9]; If $m=1$, the $P|r_j,reject|C_{max}+\pi \left(R\right)$ problem is exactly the single machine scheduling problem with release dates and submodular rejection penalty considered in [16].

A difficulty of implementing the algorithm presented in [9] on the $P|r_j,reject|C_{max}+\pi \left(R\right)$ problem is that the release time of the jobs is different and the jobs cannot be processed immediately in the given order. In order to overcome this problem, using the traversal method, we determine the set of jobs with designated release time and unify the releasing time of the other jobs. Then, in this paper, we present a combinatorial 2-approximation algorithm for $P|r_j,reject|$ $C_{max}+\pi \left(R\right)$. This ratio coincides with the best known ratio for the parallel-machine scheduling with submodular penalties and the single machine scheduling problem with release dates and submodular rejection penalties.

The structure of this paper is organized as follows. In Section 2, we present some terminologies and fundamental lemmas. In Section 3, we provide the 2- approximation algorithm for the $P|r_j,reject|C_{max}+\pi \left(R\right)$. In Section 4, we present our conclusions.

2. Terminologies and Key Lemmas

Zhang and Lu [8] showed that the $P|r_j|C_{max}$ problem can be solved by the earliest release date (ERD)-rule. That is, whenever some machine is idle and some job is available, process the unscheduled job with the ERD-rule. Thus, we have the following lemma.

Lemma 1.

For, $P|r_j,reject|C_{max}+\pi \left(R\right)$, there exists an optimal schedule such that the accepted jobs are processed in the ERD-rule on each machine.

For convenience, for any $j\in \{1,2,\dots ,n\}$, write $u_j=r_j+p_j$ and let

$$\begin{array}{c}\hfill U_j=\{J_i\in J|u_i>u_j\}\end{array}$$

be the set of jobs with release time plus processing time larger than $u_j$. Correspondingly, let $B_j$ be the set of jobs such that

$$\begin{array}{c}\hfill B_j\supseteq U_j,\mathrm{and}\pi \left(B_j\right)\mathrm{is}\mathrm{minimized}.\end{array}$$

Then, the following lemma is obtained.

Lemma 2.

For any $j\in \{1,2,\dots ,n\}$, $B_j$ can be computed in polynomial time.

Proof. 

For each $j\in \{1,2,\dots ,n\}$, we can find the set $U_j$ in polynomial time. Obviously, if $\pi (·)$ is monotonically nondecreasing, then $B_j=U_j$ and the lemma holds.

Otherwise, we construct an auxiliary set function $w(·)$ defined on all subsets of $J\backslash U_j$ as follows:

$$\begin{array}{c}\hfill w\left(X\right)=\pi (X\cup U_j)-\pi \left(U_j\right),X\subseteq J\backslash U_j.\end{array}$$

(1)

By the submodularity of $\pi (·)$, for any two subsets $X_1,X_2\subseteq J\backslash U_j$, we have

$$\begin{array}{ccc}& & w\left(X_1\right)+w\left(X_2\right)\hfill \\ & =& \pi (X_1\cup U_j)-\pi \left(U_j\right)+\pi (X_2\cup U_j)-\pi \left(U_j\right)\hfill \\ & \ge & \pi ((X_1\cup U_j)\cup (X_2\cup U_j))+\pi ((X_1\cup U_j)\cap (X_2\cup U_j))-2\pi \left(U_j\right)\hfill \\ & =& \pi ((X_1\cup X_2)\cup U_j)-\pi \left(U_j\right)+\pi ((X_1\cap X_2)\cup U_j)-\pi \left(U_j\right)\hfill \\ & =& w(X_1\cup X_2)+w(X_1\cap X_2).\hfill \end{array}$$

This implies that $w(·)$ is a submodular function. Thus, $X^{\prime }=arg{min}_{X:X\subseteq J\backslash U_j}\left\{w\left(X\right)\right\}$ can be computed within polynomial time using the method in [24].Therefore, for any $X\in J\backslash U_j$, we have

$$\begin{array}{ccc}\hfill w\left(X^{\prime }\right)& \le & w\left(X\right)\hfill \\ \hfill \pi (X^{\prime }\cup U_j)-\pi \left(U_j\right)& \le & \pi (X\cup U_j)-\pi \left(U_j\right)\hfill \\ \hfill \pi \left(B_j\right)& \le & \pi (X\cup U_j),\hfill \end{array}$$

where $B_j=X^{\prime }\cup U_j$. Thus, this lemma holds.    □

Let ${\sigma }^{*}$ be the optimal schedule and let $R^{*}$ be the rejected job set of ${\sigma }^{*}$. Write $A^{*}=J\backslash R^{*}$, $u_{j^{*}}=max\left\{u_j\right|J_j\in A^{*}\}$ and $Z^{*}=C_{max}\left({\sigma }^{*}\right)+\pi \left(R^{*}\right)$, where $C_{max}\left({\sigma }^{*}\right)$ is the makespan of ${\sigma }^{*}$. Then, we have the following.

Lemma 3.

There exists an optimal schedule ${\sigma }^{*}$ that satisfies $B_{j^{*}}\subseteq R^{*}$.

Proof. 

Let $u_{j^{*}}=max\left\{u_j\right|J_j\in J\backslash R^{*}\}$ and $U_{j^{*}}=\{J_i\in J|u_i>u_{j^{*}}\}$, then we have

$$U_{j^{*}}\subseteq R^{*}.$$

By Lemma 2, $B_{j^{*}}$ can be found in polynomial time, where $B_{j^{*}}$ is the set with minimum penalty satisfied $U_{j^{*}}\subseteq B_{j^{*}}$. This implies that

$$\pi \left(B_{j^{*}}\right)\le \pi (R^{*}\cap B_{j^{*}})$$

by $U_{j^{*}}\subseteq R^{*}\cap B_{j^{*}}$. Since $\pi (·)$ is a submodular function, we have $\pi \left(R^{*}\right)+\pi \left(B_{j^{*}}\right)\ge \pi (R^{*}\cup B_{j^{*}})+\pi (R^{*}\cap B_{j^{*}})$, i.e.,

$$\pi \left(R^{*}\right)\ge \pi (R^{*}\cup B_{j^{*}}).$$

Notably, assuming $B_{j^{*}}\backslash R^{*}\ne \varnothing$, we prove that there exists an optimal schedule ${\sigma }^{\prime }$, in which all the jobs in $R^{*}\cup B_{j^{*}}$ are rejected.

Because the process time of any job is nonnegative, it follows that we can schedule all the jobs in $A^{*}\backslash B_{j^{*}}$ by schedule ${\sigma }^{*}$. This implies that the makespan $C_{max}\left({\sigma }^{\prime }\right)$ of the jobs in $A^{*}\backslash B_{j^{*}}$ is no more than $C_{max}\left({\sigma }^{*}\right)$. Thus, we have

$$\begin{array}{c}\hfill Z^{*}=C_{max}\left({\sigma }^{*}\right)+\pi \left(R^{*}\right)\ge C_{max}\left({\sigma }^{\prime }\right)+\pi (R^{*}\cup B_{j^{*}}).\end{array}$$

Therefore, ${\sigma }^{\prime }$ is an optimal schedule and this lemma holds.   □

3. Approximation Algorithm

In this section, we consider the problem $P|r_j,reject|C_{max}+\pi \left(R\right)$ and propose a 2-approximation algorithm.

For each $j\in \{1,2,\dots ,n\}$, we introduce an auxiliary variable ${\alpha }_j$, which is similar to the dual variable in the primal-dual method.

Lemma 4.

Algorithm 1 can be implemented in polynomial time.

Algorithm 1: $\mathcal{A}$

Proof. 

Clearly, $B_k$ can be found in polynomial time by Lemma 2 for any $k\in \{1,2,\dots ,n\}$. Then, we consider the implementation of the while loops of Algorithm 1. Let ${\alpha }_j\left(t\right)$ and $F\left(t\right)$ be the value of dual variable of job $J_j$ and the set of frozen jobs after the t-$th$ execution of while loops of Algorithm 1, respectively. For convenience, we define ${\alpha }_j\left(0\right)=0,J_j\in J$ and $F\left(0\right)=B_k,R_k\left(0\right)=B_k$. Note that the while loops of Algorithm 1 need to execute at most n times for any $k\in \{1,2,\dots .n\}$.

For any t-$th$ ($t\ge 1$) execution of the while loops of Algorithm 1, it is obvious that ${\Delta }_1\left(t\right)={min}_{j:J_j\in J\backslash F(t-1)}\left\{\frac{p_j}{m}\right\}$ can be found in polynomial time for $t\in \{1,2,\cdots ,n\}$.

Write

$$\begin{array}{ccc}\hfill {\Delta }_2\left(t\right)& =& \underset{S\subseteq J:S\backslash F(t-1)\ne \varnothing }{min}\frac{\pi (S\cup B_k)-\pi \left(B_k\right)-{\sum }_{j:J_j\in S\cap F(t-1)}{\alpha }_j(t-1)}{{\sum }_{j:J_j\in S\backslash F(t-1)}1}\hfill \\ & =& \underset{S\subseteq J:S\backslash F(t-1)\ne \varnothing }{min}\frac{w\left(S\right)+\alpha \left(S\right)}{k\left(S\right)},\hfill \end{array}$$

where we define $w\left(S\right)=\pi (S\cup B_k)$-$\pi \left(B_k\right)$, $\alpha \left(S\right)={\sum }_{j:J_j\in S\cap F(t-1)}(-{\alpha }_j(t-1))$ and $k\left(S\right)$$={\sum }_{j:J_j\in S\backslash F(t-1)}1$ for any subset $S\subseteq J$. Similar to the proof of Lemma 2, we have that $w(·)$ is a submodular function. In particular, we can obtain that $w(·)+\alpha (·)$ is a submodular function because $\alpha (·)$ and $k(·)$ are linear functions. Then, using the combinatorial algorithm for the ratio of two submodular functions minimization problem considered in [25], the value of ${\Delta }_2\left(t\right)$ can be found in polynomial time. Thus, $S^{\prime }\left(t\right)=arg{min}_{S:S\subseteq J,S\backslash F(t-1)\ne \varnothing }\left\{\frac{\pi (S\cup B_k)-\pi \left(B_k\right)-{\sum }_{j:J_j\in S\cap F\left(t\right)}{\alpha }_j(t-1)}{{\sum }_{j:J_j\in S\backslash F(t-1)}1}\right\}$ can be found in polynomial time.

Therefore, the lemma holds. □

For any $k\in \{1,2,\dots ,n\}$, let ${\sigma }_k$ be a feasible schedule in Algorithm 1 and let $R_k$ be the rejected set of ${\sigma }_k$. In addition, let ${\alpha }_j$ be the value of dual variables when job $J_j$ is frozen. Then, we have the following results because ${\alpha }_j=0,\forall J_j\in B_k$ and the other ${\alpha }_j(J_j\in J\backslash B_k)$ can be obtained by the value $min\{{\Delta }_1,{\Delta }_2\}$.

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}& {\alpha }_j=\frac{p_j}{m}\mathrm{for}\mathrm{each}\mathrm{job}{J}_j\in J\backslash R_k;\hfill \\ & {\alpha }_j\le \frac{p_j}{m}\mathrm{for}\mathrm{each}\mathrm{job}{J}_j\in J;\hfill \end{array}\right.\end{array}$$

(2)

Additionally, we suppose that $J_j$ is frozen at the $\overline{t}$-$th$ execution of the while loops of Algorithm 1. Then, during the t-$th$ implementation of the while loops of Algorithm 1, we have

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}& {\alpha }_j=0,\mathrm{if}\mathrm{t}<\overline{\mathrm{t}}\hfill \\ & {\alpha }_j\left(t\right)={\alpha }_j,\mathrm{if}\mathrm{t}\ge \overline{\mathrm{t}}.\hfill \end{array}\right.\end{array}$$

(3)

Moreover, we have the following results.

Lemma 5.

For any $k\in \{1,2,\dots ,n\}$ and any $S\subseteq J$, we have

$$\begin{array}{c}\hfill \sum _{j:J_j\in S}{\alpha }_j+\pi \left(B_k\right)\le \pi (S\cup B_k).\end{array}$$

(4)

Proof. 

For any $k\in \{1,2,\dots ,n\}$, we consider the t-$th$ implementation of the while loops of Algorithm 1. We suppose that the number of the while loops of Algorithm 1 is $T_k$, i.e., $F\left(T_k\right)=J$.

For any $t\in \{1,2,\dots ,T_k\}$, assume that $J_j$ is added to $F\left(t\right)$, we have

$$\begin{array}{c}\hfill {\alpha }_j\left(t\right)=min\{{\Delta }_1\left(t\right),{\Delta }_2\left(t\right)\}\le {\Delta }_2\left(t\right),\end{array}$$

(5)

and, for each subset $S\subseteq J$ with $S\backslash F(t-1)\ne \varnothing$, we have the following

$$\begin{array}{ccc}\hfill \sum _{j:J_j\in S}{\alpha }_j\left(t\right)+\pi \left(B_k\right)& =& \sum _{j:J_j\in S\backslash F(t-1)}{\alpha }_j\left(t\right)+\sum _{j:J_j\in S\cap F(t-1)}{\alpha }_j\left(t\right)+\pi \left(B_k\right)\hfill \\ \hfill & \le & \sum _{j:J_j\in S\backslash F(t-1)}{\Delta }_2\left(t\right)+\sum _{j:J_j\in S\cap F(t-1)}{\alpha }_j\left(t\right)+\pi \left(B_k\right)\hfill \\ \hfill & =& {\Delta }_2\left(t\right)\sum _{j:J_j\in S\backslash F(t-1)}1+\sum _{j:J_j\in S\cap F(t-1)}{\alpha }_j\left(t\right)+\pi \left(B_k\right)\hfill \\ \hfill & \le & \frac{\pi (S\cup B_k)-\pi \left(B_k\right)-{\sum }_{j:J_j\in S\cap F(t-1)}{\alpha }_j\left(t\right)}{{\sum }_{j:J_j\in S\backslash F(t-1)}1}\sum _{j:J_j\in S\backslash F(t-1)}1\hfill \\ \hfill & & +\sum _{j:J_j\in S\cap F(t-1)}{\alpha }_j\left(t\right)+\pi \left(B_k\right)\hfill \\ \hfill & =& \pi (S\cup B_k),\hfill \end{array}$$

(6)

where the first inequality follows from relation (3) and inequality (5), i.e., ${\alpha }_j\left(t\right)=0$ for $J_j\in S\backslash F\left(t\right)$ and ${\alpha }_j\left(t\right)={\Delta }_2\left(t\right)$ for $J_j\in F\left(t\right)\backslash F(t-1)$, and the second inequality follows from the definition of ${\Delta }_2\left(t\right)$. We reach the conclusion of this lemma. □

Lemma 6.

For any $k\in \{1,2,\dots ,n\}$, the rejected job set $R_k$ satisfies

$$\begin{array}{c}\hfill \pi \left(R_k\right)=\sum _{j:J_j\in R_k}{\alpha }_j+\pi \left(B_k\right).\end{array}$$

(7)

Proof. 

For any $k\in \{1,2,\dots ,n\}$, we consider the t-$th$ implementation of the loops of Algorithm 1. Then, during the $t^{\prime }$-$th$ and $t^{″}$-$th$ $(t^{\prime }\le t^{″})$ implementation of the loops of Algorithm 1, we assume that ${\Delta }_2\left(t^{\prime }\right)<{\Delta }_1\left(t^{\prime }\right),{\Delta }_2\left(t^{″}\right)<{\Delta }_1\left(t^{″}\right)$,let $S\left(t^{\prime }\right)$ and $S\left(t^{″}\right)$ be the selected job sets in J at time $t^{\prime }$ and $t^{″}$, respectively. Thus, we have

$$\begin{array}{ccc}\hfill \sum _{j:J_j\in S\left(t^{\prime }\right)}{\alpha }_j\left(t^{\prime }\right)+\pi \left(B_k\right)& =& \sum _{j:J_j\in S\left(t^{\prime }\right)\backslash F\left(t^{\prime }\right)}{\alpha }_j\left(t^{\prime }\right)+\sum _{j:J_j\in S\left(t^{\prime }\right)\cap F\left(t^{\prime }\right)}{\alpha }_j\left(t^{\prime }\right)+\pi \left(B_k\right);\hfill \\ \hfill & =& \sum _{j:J_j\in S\left(t^{\prime }\right)\backslash F\left(t^{\prime }\right)}{\Delta }_2\left(t^{\prime }\right)+\sum _{j:J_j\in S\left(t^{\prime }\right)\cap F\left(t^{\prime }\right)}{\alpha }_j\left(t^{\prime }\right)+\pi \left(B_k\right);\hfill \\ \hfill & =& \frac{\pi (S\left(t^{\prime }\right)\cup B_k)-\pi \left(B_k\right)-{\sum }_{j:J_j\in S\cap F\left(t^{\prime }\right)}{\alpha }_j\left(t^{\prime }\right)}{{\sum }_{j:J_j\in S\backslash F\left(t^{\prime }\right)}1}\sum _{j:J_j\in S\left(t^{\prime }\right)\backslash F\left(t^{\prime }\right)}1\hfill \\ \hfill & & +\sum _{j:J_j\in S\left(t^{\prime }\right)\cap F\left(t^{\prime }\right)}{\alpha }_j\left(t^{\prime }\right)+\pi \left(B_k\right);\hfill \\ \hfill & =& \pi (S\left(t^{\prime }\right)\cup B_k),\hfill \end{array}$$

where $B_k$ can be found by Algorithm 1, and then $\pi \left(B_k\right)$ is a constant. Similarly, we have

$$\sum _{j:J_j\in S\left(t^{″}\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right)=\pi (S\left(t^{″}\right)\cup B_k).$$

For any job $J_j\in S\left(t^{\prime }\right)$, since $J_j\in S\left(t^{\prime }\right)$ is frozen at $t^{\prime }$ (or even earlier), we have ${\alpha }_j\left(t^{\prime }\right)={\alpha }_j\left(t^{″}\right)$ by relation (3), and

$$\begin{array}{ccc}& & \sum _{j:J_j\in S\left(t^{\prime }\right)\cup S\left(t^{″}\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right)+\sum _{j:J_j\in S\left(t^{\prime }\right)\cap S\left(t^{″}\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right)\hfill \\ & =& \sum _{j:J_j\in S\left(t^{\prime }\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right)+\sum _{j:J_j\in S\left(t^{″}\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right)\hfill \\ & =& \pi (S\left(t^{\prime }\right)\cup B_k)+\pi (S\left(t^{″}\right)\cup B_k)\hfill \\ & \ge & \pi ((S\left(t^{\prime }\right)\cup S\left(t^{″}\right))\cup B_k)+\pi ((S\left(t^{\prime }\right)\cap S\left(t^{″}\right))\cup B_k)\hfill \\ & \ge & \pi ((S\left(t^{\prime }\right)\cup S\left(t^{″}\right))\cup B_k)+\sum _{j:J_j\in S\left(t^{\prime }\right)\cap S\left(t^{″}\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right),\hfill \end{array}$$

where the first inequality comes from the submodularity of $\pi (·)$, and the second inequality follows by inequality (6).

This implies that

$$\begin{array}{c}\hfill \sum _{j:J_j\in S\left(t^{\prime }\right)\cup S\left(t^{″}\right)}{\alpha }_j\left(t^{″}\right)+\pi \left(B_k\right)\ge \pi ((S\left(t^{\prime }\right)\cup S\left(t^{″}\right))\cup B_k).\end{array}$$

Inequality (6) and relation (3) indicate that

$$\sum _{j:J_j\in S\left(t^{\prime }\right)\cup S\left(t^{″}\right)}{\alpha }_j+\pi \left(B_k\right)=\pi ((S\left(t^{\prime }\right)\cup S\left(t^{″}\right))\cup B_k).$$

Therefore, we have $\pi \left(R_k\right)={\sum }_{j:J_j\in R_k}{\alpha }_j+\pi \left(B_k\right)$ because $R_k$ is equal to merging all subsets selected by this similar case, and then the lemma holds. □

Let $\sigma$ be the schedule obtained from Algorithm 1. Let Z and $Z^{*}$ be the objective value of schedule $\sigma$ and optimal schedule ${\sigma }^{*}$, respectively. Then, we have the following.

Theorem 1.

$Z\le 2Z^{*}$ and this bound is tight.

Proof. 

Let $C_{max}\left({\sigma }^{*}\right)$ be the makespan of ${\sigma }^{*}$ and let $R^{*}$ be the rejected job of ${\sigma }^{*}$; then, the objective value of ${\sigma }^{*}$ is

$$Z^{*}=C_{max}\left({\sigma }^{*}\right)+\pi \left(R^{*}\right).$$

Let $u_{j^{*}}=max\left\{u_j\right|J_j\in J\backslash R^{*}\}$, by the pigeonhole principle, we have

$$\begin{array}{c}\hfill C_{max}\left({\sigma }^{*}\right)\ge \sum _{J_j\in A^{*}}\frac{p_j}{m},\end{array}$$

(8)

where $A^{*}=J\backslash R^{*}$. By Lemma 3, without loss of generality, we assume that

$$B_{j^{*}}\subseteq R^{*}.$$

Consider $k=j^{*}$ during the implementation of Algorithm 1. We define ${\sigma }_{j^{*}}$ and $C_{max}\left({\sigma }_{j^{*}}\right)$ as the output schedule and the makespan of this schedule. Let $R_{j^{*}}$ be the rejected job set of ${\sigma }_{j^{*}}$ and let ${\left\{{\alpha }_j\right\}}_{J_j\in J}$ be the value of dual variables when all jobs in J are frozen. Then, we have

$$\begin{array}{ccc}\hfill Z^{*}& =& C_{max}\left({\sigma }^{*}\right)+\pi \left(R^{*}\right)\ge \sum _{J_j\in A^{*}}\frac{p_j}{m}+\pi \left(R^{*}\right)\hfill \\ & =& \sum _{J_j\in A^{*}}\frac{p_j}{m}+\pi (R^{*}\cup B_{j^{*}})\ge \sum _{J_j\in A^{*}}\frac{p_j}{m}+\sum _{j:J_j\in R^{*}}{\alpha }_j+\pi \left(B_{j^{*}}\right)\hfill \\ & =& \sum _{J_j\in A^{*}\cap A_{j^{*}}}\frac{p_j}{m}+\sum _{J_j\in A^{*}\cap R_{j^{*}}}\frac{p_j}{m}+\sum _{j:J_j\in R^{*}\cap A_{j^{*}}}{\alpha }_j+\sum _{j:J_j\in R^{*}\cap R_{j^{*}}}{\alpha }_j+\pi \left(B_{j^{*}}\right)\hfill \\ & \ge & \sum _{J_j\in A^{*}\cap A_{j^{*}}}\frac{p_j}{m}+\sum _{J_j\in A^{*}\cap R_{j^{*}}}{\alpha }_j+\sum _{j:J_j\in R^{*}\cap A_{j^{*}}}\frac{p_j}{m}+\sum _{j:J_j\in R^{*}\cap R_{j^{*}}}{\alpha }_j+\pi \left(B_{j^{*}}\right)\hfill \\ & =& \sum _{j:J_j\in A_{j^{*}}}\frac{p_j}{m}+\pi \left(R_{j^{*}}\right),\hfill \end{array}$$

(9)

where $A_{j^{*}}=J\backslash R_{j^{*}}$, the first inequality follows from inequality (8), the second inequality follows from Lemma 5, the third inequality follows from inequality (2), and the last equality follows from Lemma 6.

Let $J_q\in A_{j^{*}}$ be the last completion job, i.e., the completion processed time of $J_q$ is $C_{max}\left({\sigma }_{j^{*}}\right)$. Furthermore, let $S_q$ be the starting processing time of $J_q$ in ${\sigma }_{j^{*}}$. Thus, we have $s_q\ge r_q$ and $C_{max}\left({\sigma }_{j^{*}}\right)=s_q+p_q$.

By the ERD-rule, if $s_q>r_q$, all machines are busy in the time interval $[r_q,s_q)$. Then, we have

$$m·(s_q-r_q)\le \sum _{j:J_j\in A_{j^{*}}}{p}_j\Rightarrow s_q-r_q\le \sum _{j:J_j\in A_{j^{*}}}\frac{p_j}{m}.$$

Otherwise, for $s_q=r_q$, we have $s_q-r_q=0\le {\sum }_{J_j\in J_j\in A_{j^{*}}}\frac{p_j}{m}$ by $p_j\ge 0$ for each $J_j\in J$. Therefore, we have

$$\begin{array}{c}\hfill s_q-r_q\le \sum _{J_j\in J_j\in A_{j^{*}}}\frac{p_j}{m}.\end{array}$$

(10)

Furthermore, we have $r_q+p_q\le u_{j^{*}}\le C_{max}\left({\sigma }^{*}\right)$ because $J_q\in A_{j^{*}}$ and the definition of $u_{j^{*}}$. Then, summing up the inequalities (9) and (10), we can obtain the following

$$\begin{array}{ccc}\hfill Z& \le & Z_{j^{*}}=C_{max}\left({\sigma }_{j^{*}}\right)+\pi \left(R_{j^{*}}\right)\hfill \\ & =& s_q+p_q+\pi \left(R_{j^{*}}\right)\hfill \\ & =& r_q+p_q+(s_q-r_q)+\pi \left(R_{j^{*}}\right)\hfill \\ & \le & C_{max}\left({\sigma }^{*}\right)+\sum _{J_j\in J_j\in A_{j^{*}}}\frac{p_j}{m}+\pi \left(R_{j^{*}}\right)\hfill \\ & \le & 2Z^{*}.\hfill \end{array}$$

To show that the bound is tight, we present an instance with four jobs and two parallel machines:

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}& J_1=(r_1,p_1)=(0,2);\hfill \\ & J_2=(r_2,p_2)=(2,1);\hfill \\ & J_3=(r_3,p_3)=(2,2);\hfill \\ & J_4=(r_4,p_4)=(4,0).\hfill \end{array}\right.\end{array}$$

and the submodular function is

$$\begin{array}{c}\hfill \pi \left(S\right)=\left\{\begin{array}{cc}& 0,|S=\varnothing |=0;\hfill \\ & 6,\left|S\right|=1;\hfill \\ & 9,\left|S\right|=2;\hfill \\ & 11,\left|S\right|=3;\hfill \\ & 12,|S=J|=4.\hfill \end{array}\right.\end{array}$$

By Algorithm 1, when $k=1$, the resulting schedule ${\sigma }_1$ is to reject all the jobs, and $Z_1=\pi \left(J\right)=12$; when $k=2$ or $k=3$, both the resulting schedule ${\sigma }_2$ and ${\sigma }_3$ are to reject $J_4$ and to process $J_1$ and $J_2$ on machine $M_1$ and process $J_3$ on machine $M_2$, and $Z_1=r_{2\left(or3\right)}+C_{max}\left({\sigma }_{2\left(or3\right)}\right)+\pi \left(\left\{J_4\right\}\right)=2+4+6=12$; when $k=4$, the resulting schedule ${\sigma }_4$ is to process $J_1$, $J_2$ and $J_4$ on machine $M_1$ and process $J_3$ on machine $M_2$, and $Z_1=r_4+C_{max}\left({\sigma }_4\right)=4+4=8$. The optimal schedule is to process $J_1$, $J_2$ and $J_4$ on machine $M_1$ and process $J_3$ on machine $M_2$, and $Z^{*}=4$. Thus, we have $Z+min\{Z_1,Z_2,Z_3,Z_4\}=8=2Z^{*}$.

Hence, we reach the conclusion of this theorem. □

4. Conclusions

In this paper, we investigate parallel-machine scheduling with release times and submodular penalties ($P|r_j,reject|C_{max}+\pi \left(R\right)$), which is a generalization of parallel-machine scheduling with release times and rejection penalties and single machine scheduling with release dates and submodular penalties. For $P|r_j,reject|C_{max}+\pi \left(R\right)$, we propose a 2-approximation algorithm.

For parallel-machine scheduling with release times and rejection penalties, there exists a PTAS. For $P|r_j,reject|C_{max}+\pi \left(R\right)$, there is a question of whether it is possible to design a PTAS or a further improved algorithm. Furthermore, establishing a better algorithm is an interesting direction for future work.

The vector scheduling problem [19,22,23] is a generalization of parallel machine scheduling, where each job $J_j$ is associated with a d-dimensional vector. Thus, the vector parallel-machine scheduling with release times and rejection penalties, which can be viewed as one generalization of the $P|r_j,reject|C_{max}+\pi \left(R\right)$, deserves to be explored. It is possible to design a 2-approximation algorithm, but it is a challenge.

In [26], Liu et al considered a k-prize-collecting cover problem, in which at least k points are covered. The k-prize-collecting scheduling problem with release times and rejection penalties, which can be viewed as another generalization of the $P|r_j,reject|C_{max}+\pi \left(R\right)$, deserves to be explored.