Approximation Algorithm for the Single Machine Scheduling Problem with Release Dates and Submodular Rejection Penalty

Abstract

In this paper, we consider the single machine scheduling problem with release dates and nonmonotone submodular rejection penalty. We are given a single machine and multiple jobs with probably different release dates and processing times. For each job, it is either accepted and processed on the machine or rejected. The objective is to minimize the sum of the makespan of the accepted jobs and the rejection penalty of the rejected jobs which is determined by a nonmonotone submodular function. We design a combinatorial algorithm based on the primal-dual framework to deal with the problem, and study its property under two cases. For the general case where the release dates can be different, the proposed algorithm have an approximation ratio of 2. When all the jobs release at the same time, the proposed algorithm becomes a polynomial-time exact algorithm.

1. Introduction

All jobs must be processed in classical scheduling problems. However, sometimes rejecting some jobs with low cost performance is possible and will bring more profit. This problem is called multiprocessor scheduling with rejection (MSR), which is first proposed by Bartal et al. [1]. In this problem, a job is either accepted and processed on the machine, or rejected and paid a rejection penalty. The objective is to minimize the makespan of accepted jobs plus the overall penalty of rejected jobs. Bartal et al. [1] proposed a 2-approximation algorithm running in $O(nlogn)$ time and a polynomial-time approximation scheme (PTAS) for MSR. Ou et al. [2] proposed a $(3/2+\epsilon )$-approximation algorithm with running time $O(nlogn+n/\epsilon )$ for MSR, where $\epsilon$ is a small given positive constant.

MSR and its variants have become increasingly popular in both academic and industrial community in the last two decades. Zhang and Lu [3] considered parallel-machine scheduling with release dates and rejection, where jobs cannot be processed before their corresponding release dates. The objective of this problem to minimize the sum of makespan of accepted jobs and total penalty of rejected jobs. They developed a 2-approximation algorithm. This result is further improved by Zhong and Ou [4] who designed a PTAS. Li et al. [5] designed a PTAS for a variant of MSR, where the objective is to minimize the makespan when the rejection cost is bounded by a given constant.

Some studies considered the case when the number of machines is bounded. When there are exactly two machines. Zhong et al. [6] developed a $(3/2+\epsilon )$-approximation algorithm for scheduling with release dates and rejection. When the number of machines is one, there are much more related results. Shabtay et al. [7] handled the single machine with job rejection and positional penalties problem with a bicriteria approach. Zhang et al. [8] proved the NP-hardness of single machine scheduling with release dates and rejection, which is a special case of the problem considered in [3]. They presented a 2-approximation algorithm with running time of $O\left(n^2\right)$, which was independently improved by He et al. [9] and Ou et al. [10] with running time of $O(nlogn)$. Zhang et al. [11] developed a FPTAS for a variant of single machine scheduling with release dates and rejection, where the objective is to minimize the makespan when rejection penalty is bounded. Zou et al. [12] considered single-machine scheduling with rejection and an operator non-availability interval where jobs are prohibited to start or complete in the operator non-availability interval, and presented a FPTAS. Shioura et al. [13] studied a problem on a single machine with release dates and deadlines, where the processing can be accelerated by making additional cost. They utilized submodular optimization to achieve the best possible running time. Li and Cui [14] designed a 1.58-approximation algorithm for vector scheduling on a single machine, where vector scheduling imply that multiple resources are needed for each job and the objective is to minimize the maximal cost over all resources plus the rejection cost. More related results can be found in the surveys [15,16].

Since submodular function has the property of decreasing marginal return and occurs in many mathematical models, classical combinatorial optimization problems with submodular rejection penalty receive more and more attentions [17,18,19]. For the MSR problem, rejecting jobs frequently might lead to low prestige for the manufacturer. There is no linear relationship between the number of rejected jobs and the loss of the manufacturer’s prestige, but as the number of rejected jobs increases, it will have less and less impact on the manufacturer’s prestige. Recently, Zhang et al. [20] proposed a 3-approximation algorithm for precedence-constrained scheduling with submodular rejection on parallel machines.

Motivated by the problems in [8,20], we propose a new scheduling problem, called single machine scheduling problem with release dates and submodular rejection penalty, where each job is either rejected or accepted and processed on the machine. The objective is to minimize the sum of the makespan of the accepted jobs and the rejection penalty of the rejected jobs which is determined by a submodular function. In this paper, we design a combinatorial 2-approximation algorithm by using the primal-dual scheme, generalizing the algorithm presented in [8].

The remainder of this paper is structured as follows. In Section 2, we provide a formal problem statement. In Section 3, for single machine scheduling problem with release dates and submodular rejection penalty functions, we present a 2-approximation algorithm, based on a method similarly to the primal-dual algorithm. In addition, when all the jobs have the same release date, we present a polynomial-time exact algorithm. We provide conclusion in Section 4.

2. Preliminaries

In this section, we present a formal description of single machine scheduling problem with release dates and submodular rejection penalty. Given a single machine and n jobs, $J=\{J_1,J_2,\dots ,$$J_n\}$, each job $J_j$ has a processing time $p_j$ and a release date $r_j$, where $p_j$ and $r_j$ are nonnegative real numbers. The rejection cost of a subset of jobs is determined by the nonmonotone submodular function $\pi (·):2^J\to R^{+}\cup \left\{0\right\}$, which means that

$$\begin{array}{c}\hfill \pi (X\cup Y)+\pi (X\cap Y)\le \pi \left(X\right)+\pi \left(Y\right),\forall X,Y\subseteq J,\end{array}$$

without loss of generality, assume that $\pi (\varnothing )=0$. Moreover, we assume that $\pi \left(S\right)$ can be computed within polynomial time for any subset $S\subseteq J$, where the ‘polynomial’ we use regard to the size n.

The single machine scheduling problem with release dates and submodular rejection penalties is to choose a set $R\subseteq J$ of rejected jobs and schedule the remaining jobs in $A=J\backslash R$ on the machine. The objective is to minimize the sum of the makespan of the accepted jobs and the penalty cost $\pi \left(R\right)$ of the rejected jobs. By using the general notation for scheduling problems, the problem is denoted by $1|r_j,reject|C_{max}+\pi \left(R\right)$. Clearly, if $\pi \left(R\right)={\sum }_{J_j:J_j\in R}\pi \left(\left\{J_j\right\}\right)$, the problem $1|r_j,reject|C_{max}+\pi \left(R\right)$ is exactly the problem $1|r_j,reject|C_{max}+{\sum }_{J_j\in R}{w}_j$ considered in [8].

If rejection is not allowed, Lawler [21] shows that the corresponding problem $1|r_j,reject|C_{max}$ can be solved using the earliest release date rule (ERD-rule for short). Thus, we have the following lemma.

Lemma 1

([21]). For the problem $1|r_j,reject|C_{max}+\pi \left(R\right)$, there exists an optimal schedule such that the accepted jobs in $A=J\backslash R$ are processed using the ERD-rule.

For any set $S\subseteq J$, let

$$\begin{array}{c}\hfill p\left(S\right)=\sum _{J_j\in S}{p}_j\end{array}$$

be the total processing time of the jobs in S. Based on Lemma 1, we first re-label the jobs such that $r_1\le \cdots \le r_n$. For convenience, let

$$\begin{array}{c}\hfill r_0=0.\end{array}$$

Assume that $r_1\ge 0$. For each $r\in \{r_0,r_1,r_2,\dots ,r_n\}$, let

$$\begin{array}{c}\hfill B\left(r\right)=\left\{J_j\right|r_j>r\}\end{array}$$

be the set of jobs with release date bigger than r. Correspondingly, let $B_r$ be the set of jobs such that

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

Obviously, if $\pi (·)$ is monotone nondecreasing, $B_r=B\left(r\right)$. Otherwise, we have

Lemma 2.

For every $r\in \{r_0,r_1,r_2,\dots ,r_n\}$, $B_r$ can be computed in polynomial time.

Proof. 

Consider a given $r\in \left\{r_j\right|0\le j\le n\}$. Clearly, $\pi \left(B\right(r\left)\right)$ is a constant. For any subset $X\subseteq J\backslash B\left(r\right)$, construct an auxiliary function $w(·)$ such that

$$\begin{array}{c}\hfill w\left(X\right)=\pi (X\cup B(r\left)\right)-\pi \left(B\right(r\left)\right).\end{array}$$

For any two subsets $X,Y\subseteq J\backslash B\left(r\right)$, we have

$$\begin{array}{cc}& w\left(X\right)+w\left(Y\right)\hfill \\ =& \pi (X\cup B(r\left)\right)-\pi \left(B\right(r\left)\right)+\pi (Y\cup B(r\left)\right)-\pi \left(B\right(r\left)\right)\hfill \\ \ge & \pi \left(\right(X\cup B\left(r\right))\cup (Y\cup B\left(r\right)\left)\right)+\pi \left(\right(X\cup B\left(r\right))\cap (Y\cup B\left(r\right)\left)\right)-2\pi \left(B\right(r\left)\right)\hfill \\ =& \pi \left(\right(X\cup Y)\cup B(r\left)\right)-\pi \left(B\right(r\left)\right)+\pi \left(\right(X\cap Y)\cup B(r\left)\right)-\pi \left(B\right(r\left)\right)\hfill \\ =& w(X\cup Y)+w(X\cap Y),\hfill \end{array}$$

where the inequality follows from that $\pi (·)$ is a submodular function. Therefore, $w(·)$ is a submodular function, which implies that ${min}_{X\subseteq J\backslash B\left(r\right)}w\left(X\right)$ can be computed within polynomial time, using the method in [22]. Since $\pi \left(B\right(r\left)\right)$ is a constant, ${min}_{X\subseteq J\backslash B\left(r\right)}\pi (X\cup B\left(r\right))={min}_{X\subseteq J\backslash B\left(r\right)}w\left(X\right)+\pi \left(B\left(r\right)\right)$ can be computed within polynomial time. It implies that $B_r=(arg{min}_{X\subseteq J\backslash B\left(r\right)}\pi (X\cup B\left(r\right)))\cup B\left(r\right)$ can be computed within polynomial time. □

3. An Approximation Algorithm

In this section, we design a combination 2-approximation algorithm for $1|r_j,reject|C_{max}+\pi \left(R\right)$. In particular, when all the jobs have the same release dates, we prove that $1|r_j,reject|C_{max}+\pi \left(R\right)$ can be solved exactly in polynomial time.

For each $r\in \left\{r_j\right|0\le j\le n\}$, use Process A$\left(r\right)$, which is described later, to find a schedule ${\sigma }_r$, compute the objective value $Z_r$ of schedule ${\sigma }_r$, and choose the best schedule as the output schedule.

In Process A$\left(r\right)$, similarly to the primal-dual algorithm in [23], we introduce an auxiliary “dual” variable ${\alpha }_{r,j}$ for every job $J_j\in J$ and r, where r is an input value of Process A$\left(r\right)$. There is an auxiliary notion of time t associated with Process A$\left(r\right)$.

Process A$\left(r\right)$.

Input: An instance of $1|r_j,reject|C_{max}+\pi \left(R\right)$ and a fixed number r($\in \left\{r_j\right|0\le j\le n\}$).

Output: a schedule ${\sigma }_r$ and its objective value $Z_r$.

Step 1. Initially, set the variable ${\alpha }_{r,j}=0$ for each job $J_j$ in J and the time $t=0$.

Step 2. Compute the job set $B_r$ using the method described in the proof of Lemma 2. Reject every job in $B_r$ by setting $R_r:=B_r$, and freeze every job in $B_r$ by setting $F_r:=B_r$.

Step 3. While $J\backslash F_r\ne \varnothing$, we increase the variables ${\alpha }_{r,j}$ for all unfrozen jobs in $J\backslash F_r$ uniformly at unit rate with time t. As t increases, one of the following two cases may occur:

Case 1. There is a set $S_r\subseteq J$ and $S_r\cap F_r\ne \varnothing$ satisfying that

$$\begin{array}{c}\hfill \sum _{j:J_j\in S_r\backslash F_r}t+\sum _{j:J_j\in S_r\cap F_r}{\alpha }_{r,j}+\pi \left(B_r\right)=\pi (S_r\cup B_r).\end{array}$$

(1)

In this case, set ${\alpha }_{r,j}=t$ for each job $J_j$ in $S_r\backslash F_r$ and freeze those unfrozen jobs in $S_r$, by setting $F_r:=F_r\cup S_r$. Reject all jobs in set $S_r$, by setting $R_r:=R_r\cup S_r$.

Case 2. There is a job $J_j\in J\backslash F_r$ such that $t=p_j$. In this case, set ${\alpha }_{r,j}=t$ and freeze job $J_j$ by setting $F_r:=F_r\cup \left\{J_j\right\}$.

Step 4. Reject the jobs in $R_r$ and schedule all jobs in $A_r(=J\backslash R_r)$ in time interval $[r,r+p\left(A_r\right)]$ on the machine. The resulting schedule is denoted by ${\sigma }_r$, whose objective value is denoted by $Z_r$.

In Process A$\left(r\right)$ for any $r=\{r_1,\dots ,r_n\}$ in the algorithm, at Step 2, we can find the exact set $B_r$ for a given value r, and $B_r$ will not change until Process A$\left(r\right)$ terminates. However, at Step 3 of Process A$\left(r\right)$ for any $r=\{r_1,\dots ,r_n\}$ in the algorithm, the frozen job set $F_r$ and job set $S_r$ are changed as the change as time t. And the auxiliary “dual” variable ${\alpha }_{r,j}$ for any $J_j\in J$ and a given value r will increase with time t until job $J_j$ is frozen. Thus, at any time t in Process A$\left(r\right)$ for any $r=\{r_1,\dots ,r_n\}$, we introduce the following notations:

• $B_r\mathrm{is}\mathrm{the}\mathrm{set}\mathrm{of}\mathrm{jobs}\mathrm{generated}\mathrm{by}\mathrm{Step}2\mathrm{in}\mathrm{Process}\mathrm{A}\left(r\right),$
• $F_r\left(t\right)\mathrm{is}\mathrm{the}\mathrm{set}\mathrm{of}\mathrm{frozen}\mathrm{jobs}\mathrm{at}\mathrm{time}t\mathrm{in}\mathrm{Process}\mathrm{A}\left(r\right),$
• $S_r\left(t\right)\mathrm{is}\mathrm{the}\mathrm{set}\mathrm{of}\mathrm{jobs}\mathrm{generated}\mathrm{by}\mathrm{Case}1\mathrm{at}\mathrm{time}t\mathrm{in}\mathrm{Process}\mathrm{A}\left(r\right).$
• ${\alpha }_{r,j}\left(t\right)\mathrm{is}\mathrm{the}\mathrm{value}\mathrm{of}\mathrm{job}{J}_j\mathrm{at}\mathrm{time}t\mathrm{in}\mathrm{Process}\mathrm{A}\left(r\right),$
• ${\alpha }_{r,j}\mathrm{is}\mathrm{the}\mathrm{value}\mathrm{of}\mathrm{job}{J}_j\mathrm{when}\mathrm{job}{J}_j\mathrm{is}\mathrm{frozen}\mathrm{in}\mathrm{Process}\mathrm{A}\left(r\right).$

Lemma 3.

For any $r\in \{r_0,r_1,\dots ,r_n\}$, Process A$\left(r\right)$ can be implemented in polynomial time.

Proof. 

Consider Step 2 of Process A$\left(r\right)$, by Lemma 2, $B_r$ can be found in polynomial time. Clearly, $\pi \left(B_r\right)$ is a constant.

Consider Step 3 of Process A$\left(r\right)$. For any time $\tilde{t}$, let $F_r\left(\tilde{t}\right)$ be the frozen job set at this time and $\overline{t}$ be the next closest time, which is incurred by either Case 1 or Case 2.

For Case 1, the next closest time $\overline{t}$ is at most

$$\begin{array}{ccc}\hfill {\Delta }_1& =& \underset{S\subseteq J,S\cap F_r\left(\tilde{t}\right)\ne \varnothing }{min}\frac{\pi (S\cup B_r)-\pi \left(B_r\right)-{\sum }_{j:J_j\in S\cap F_r\left(\tilde{t}\right)}{\alpha }_{r,j}}{|S\backslash F_r\left(\tilde{t}\right)|}\hfill \\ & =& \underset{S\subseteq J,S\cap F_r\left(\tilde{t}\right)\ne \varnothing }{min}\frac{w\left(S\right)+\alpha \left(S\right)}{k\left(S\right)},\hfill \end{array}$$

where $w\left(S\right)=\pi (S\cup B_r)-\pi \left(B_r\right)$, $\alpha \left(S\right)={\sum }_{j:J_j\in S\cap F_r\left(\tilde{t}\right)}(-{\alpha }_{r,j})$ and $k\left(S\right)=|S\backslash F_r\left(\tilde{t}\right)|$ for any subset $S\cap F_r\left(\tilde{t}\right)\ne \varnothing$. For any two subsets $S_1,S_2\subseteq J$ satisfying $S_1\cap F_r\left(\tilde{t}\right)\ne \varnothing$ and $S_2\cap F_r\left(\tilde{t}\right)\ne \varnothing$, we have

$$\begin{array}{cc}& \alpha \left(S_1\right)+\alpha \left(S_2\right)\hfill \\ =& \sum _{j:J_j\in S_1\cap F_r\left(\tilde{t}\right)}(-{\alpha }_{r,j})+\sum _{j:J_j\in S_2\cap F_r\left(\tilde{t}\right)}(-{\alpha }_{r,j})\hfill \\ =& \sum _{j:J_j\in (S_1\cap F_r\left(\tilde{t}\right))\cup (S_2\cap F_r\left(\tilde{t}\right))}(-{\alpha }_{r,j})+\sum _{j:J_j\in (S_1\cap F_r\left(\tilde{t}\right))\cap (S_2\cap F_r\left(\tilde{t}\right))}(-{\alpha }_{r,j})\hfill \\ =& \sum _{j:J_j\in (S_1\cup S_2)\cap F_r\left(\tilde{t}\right)}(-{\alpha }_{r,j})+\sum _{j:J_j\in (S_1\cap S_2)\cap F_r\left(\tilde{t}\right)}(-{\alpha }_{r,j})\hfill \\ =& \alpha (S_1\cup S_2)+\alpha (S_1\cap S_2),\hfill \end{array}$$

and

$$\begin{array}{cc}& k\left(S_1\right)+k\left(S_2\right)\hfill \\ =& |S_1\backslash F_r\left(\tilde{t}\right)|+|S_2\backslash F_r\left(\tilde{t}\right)|\hfill \\ =& |(S_1\backslash F_r\left(\tilde{t}\right))\cup (S_2\backslash F_r\left(\tilde{t}\right))|+|(S_1\backslash F_r\left(\tilde{t}\right))\cap (S_2\backslash F_r\left(\tilde{t}\right))|\hfill \\ =& |(S_1\cup S_2)\backslash F_r\left(\tilde{t}\right)|+|(S_1\cap S_2)\backslash F_r\left(\tilde{t}\right)|\hfill \\ =& k(S_1\cup S_2)+k(S_1\cap S_2).\hfill \end{array}$$

Therefore, $\alpha (·)$ and $k(·)$ are modular functions. Similarly to the proof of Lemma 2, we can prove that $w(·)$ is a submodular function. Therefore, $w\left(S\right)+\alpha \left(S\right)$ is a submodular function, which implies that the value of ${\Delta }_1$ can be computed in polynomial time by using the combinatorial algorithm for the ratio of a submodular and a modular function minimization problem [24].

For Case 2, the next closet time $\overline{t}$ is at most

$${\Delta }_2=\underset{j:J_j\in J\backslash F_r\left(\tilde{t}\right)}{min}{p}_j.$$

It is obvious that the value of ${\Delta }_2$ can be found in polynomial time.

Thus, the next time $\overline{t}=min\{{\Delta }_1,{\Delta }_2\}$ can be found in polynomial time. When the time increase from $\tilde{t}$ to $\overline{t}$, the algorithm freezes at least one unfrozen job, which implies that Step 3 of Process A$\left(r\right)$ can be completed in polynomial time. It is easy to verify other Steps can be implemented in polynomial time. Thus, the lemma holds. □

Lemma 4.

For any $r\in \left\{r_j\right|0\le j\le n\}$, the rejected job set $R_r$ produced by Process A$\left(r\right)$ satisfies

$$\begin{array}{c}\hfill \pi \left(R_r\right)=\sum _{j:J_j\in R_r}{\alpha }_{r,j}+\pi \left(B_r\right).\end{array}$$

(2)

Proof. 

For any $r\in \left\{r_j\right|0\le j\le n\}$, let ${\alpha }_{r,j}\left(t\right)$ be the variable of job $J_j$ at time t which will increase with time t until job $J_j$ is frozen. Thus, if $J_j$ is frozen at time $t^{\prime }$, we have

$$\begin{array}{c}\hfill \left\{\begin{array}{c}{\alpha }_{r,j}\left(t_1\right)<{\alpha }_{r,j}\left(t_2\right)\mathrm{for}{t}_1<t_2\le t^{\prime };\hfill \\ {\alpha }_{r,j}\left(t_1\right)={\alpha }_{r,j}\left(t_2\right)\mathrm{for}{t}^{\prime }\le t_1<t_2;\hfill \\ {\alpha }_{r,j}={\alpha }_{r,j}\left(t^{\prime }\right)=t^{\prime }.\hfill \end{array}\right.\end{array}$$

(3)

By Step 2 of Process A$\left(r\right)$, jobs in set $B_r$ are found and are frozen, we have $\pi \left(B_r\right)$ is a constant and

$${\alpha }_{r,j}=0\mathrm{for}\forall J_j\in B_r.$$

By Case 1 of Process A$\left(r\right)$, for any time t and any subset $S\subseteq J$, we have

$$\begin{array}{c}\hfill \sum _{j:J_j\in S}{\alpha }_{r,j}\left(t\right)+\pi \left(B_r\right)=\sum _{j:J_j\in S\backslash F_r\left(t\right)}t+\sum _{j:J_j\in S\cap F_r\left(t\right)}{\alpha }_{r,j}+\pi \left(B_r\right)\le \pi (S\cup B_r),\end{array}$$

(4)

where $F_r\left(t\right)$ is the frozen jobs set at time t. At time points $t_1$ and $t_2$ ($t_1\le t_2$) in Case 1, let $S_r\left(t_1\right)$ and $S_r\left(t_2\right)$ be the selected job sets, respectively. Thus, both $S_r\left(t_1\right)$ and $S_r\left(t_2\right)$ satisfy inequality (1), i.e., we have

$$\begin{array}{ccc}\hfill \pi (S_r\left(t_1\right)\cup B_r)& =& \sum _{j:J_j\in S_r\left(t_1\right)\backslash F_r\left(t_1\right)}{t}_1+\sum _{j:J_j\in S_r\left(t_1\right)\cap F_r\left(t_1\right)}{\alpha }_{r,j}+\pi \left(B_r\right)=\sum _{j:J_j\in S_r\left(t_1\right)}{\alpha }_{r,j}\left(t_1\right)+\pi \left(B_r\right);\hfill \\ \hfill \pi (S_r\left(t_2\right)\cup B_r)& =& \sum _{j:J_j\in S_r\left(t_2\right)\backslash F_r\left(t_2\right)}{t}_2+\sum _{j:J_j\in S_r\left(t_2\right)\cap F_r\left(t_2\right)}{\alpha }_{r,j}+\pi \left(B_r\right)=\sum _{j:J_j\in S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right),\hfill \end{array}$$

where all jobs in $S_r\left(t_1\right)$ (or $S_r\left(t_2\right)$) are frozen at time $t_1$ (or $t_2$) or even earlier.

Therefore, we have

$$\begin{array}{cc}& \sum _{j:J_j\in S_r\left(t_1\right)\cup S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)+\sum _{j:J_j\in S_r\left(t_1\right)\cap S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)\hfill \\ =& \sum _{j:J_j\in S_r\left(t_1\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)+\sum _{j:J_j\in S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)\hfill \\ \ge & \sum _{j:J_j\in S_r\left(t_1\right)}{\alpha }_{r,j}\left(t_1\right)+\pi \left(B_r\right)+\sum _{j:J_j\in S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)\hfill \\ =& \pi (S_r\left(t_1\right)\cup B_r)+\pi (S_r\left(t_2\right)\cup B_r)\hfill \\ \ge & \pi ((S_r\left(t_1\right)\cup S_r\left(t_2\right))\cup B_r)+\pi ((S_r\left(t_1\right)\cap S_r\left(t_2\right))\cup B_r)\hfill \\ \ge & \pi ((S_r\left(t_1\right)\cup S_r\left(t_2\right))\cup B_r)+\sum _{j:J_j\in S_r\left(t_1\right)\cap S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right),\hfill \end{array}$$

where the first inequality follows from $t_1\le t_2$, the second inequality follows from the submodularity of $\pi (·)$, and the third inequality follows from inequality (4).

It implies that

$$\begin{array}{c}\hfill \sum _{j:J_j\in S_r\left(t_1\right)\cup S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)\ge \pi ((S_r\left(t_1\right)\cup S_r\left(t_2\right))\cup B_r).\end{array}$$

Moveover, ${\sum }_{j:J_j\in S_r\left(t_1\right)\cup S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)=\pi ((S_r\left(t_1\right)\cup S_r\left(t_2\right))\cup B_r))$ following from inequality (4). Any job $J_j\in S_r\left(t_1\right)\cup S_r\left(t_2\right)$ is frozen at $t_2$ or even earlier, we have

$$\pi ((S_r\left(t_1\right)\cup S_r\left(t_2\right))\cup B_r))=\sum _{j:J_j\in S_r\left(t_1\right)\cup S_r\left(t_2\right)}{\alpha }_{r,j}\left(t_2\right)+\pi \left(B_r\right)=\sum _{j:J_j\in S_r\left(t_1\right)\cup S_r\left(t_2\right)}{\alpha }_{r,j}+\pi \left(B_r\right).$$

By Process A$\left(r\right)$, $R_r=B_r\cup {\bigcup }_{S\in \mathcal{S}}S$, where $\mathcal{S}$ is the set of subset satisfying inequality (1), so the equality (2) holds. □

Consider the optimal schedule ${\sigma }^{*}$. Let $A^{*}$ and $R^{*}$ be the sets of the accepted jobs and the rejected jobs in ${\sigma }^{*}$, respectively. Let $r^{*}=max\left\{r_j\right|J_j\in A^{*}\}$ be the maximum release date of the jobs in $A^{*}$, where $r^{*}=0$ if $A^{*}=\varnothing$.

Lemma 5.

There is an optimal schedule ${\sigma }^{*}$ satisfying $B_{r^{*}}\subseteq R^{*}$.

Proof. 

For any optimal schedule ${\sigma }^{*}$, If $B_{r^{*}}\backslash R^{*}=\varnothing$, the lemma holds. Otherwise, let ${\sigma }^{\prime }$ be a schedule that the jobs in $R^{\prime }=R^{*}\cup B_{r^{*}}$ are rejected and the jobs in $A^{\prime }=J\backslash (R^{*}\cup B_{r^{*}})$ are accepted and processed in ERD-rule. Clearly, we have $A^{\prime }\subset A^{*}=J\backslash R^{*}$, which implies that ${\sigma }^{\prime }$ is an optimmal schedule to process the jobs in $A^{\prime }$ by Lemma 1. Thus, the makespan of ${\sigma }^{\prime }$ is no more than that of ${\sigma }^{*}$.

By the definition of $B\left(r^{*}\right)$, we have $B\left(r^{*}\right)=\{J_j\in J|r_i>r^{*}\}\subseteq R^{*}$. Since $B\left(r^{*}\right)\subseteq B_{r^{*}}$, we have

$$B\left(r^{*}\right)\subseteq R^{*}\cap B_{r^{*}}.$$

By the definition of $B_{r^{*}}$, we have $\pi \left(B_{r^{*}}\right)\le \pi \left(S\right)$ for any $S\supseteq B\left(r^{*}\right)$. That implies

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

Since function $\pi (·)$ is a submodular function, we have

$$\pi \left(R^{*}\right)+\pi \left(B_{r^{*}}\right)\ge \pi (R^{*}\cup B_{r^{*}})+\pi (R^{*}\cap B_{r^{*}})=\pi \left(R^{\prime }\right)+\pi (R^{*}\cap B_{r^{*}}).$$

Together with $\pi \left(B_{r^{*}}\right)\le \pi (R^{*}\cap B_{r^{*}})$, we have

$$\pi \left(R^{\prime }\right)\le \pi \left(R^{*}\right).$$

Therefore, we have that the objective value of ${\sigma }^{\prime }$ is no more than that of ${\sigma }^{*}$. Thus, ${\sigma }^{\prime }$ is an optimal scheduling that $R^{\prime }=R^{*}\cup B_{r^{*}}$ is the rejected set of ${\sigma }^{\prime }$. The lemma holds. □

Let $\sigma$ be the output schedule. Let Z and $Z^{*}$ be the objective values of the schedule $\sigma$ and the optimal schedule ${\sigma }^{*}$, respectively.

Theorem 1.

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

Proof. 

Let ${\sigma }^{*}$ be an optimal schedule such that $B_{r^{*}}\subseteq R^{*}$. If the optimal schedule ${\sigma }^{*}$ rejects all the jobs, then ${\sigma }^{*}$ is the output schedule of Process A$\left(r_0\right)$ where $r_0=0$, which implies that the theorem holds. Otherwise, let $r^{*}=max\left\{r_j\right|J_j\in A^{*}\}$ be the maximum release date of the jobs in $A^{*}$, we have

$$\begin{array}{c}\hfill Z^{*}\ge r^{*}.\end{array}$$

(5)

By Case 2 of Process A$\left(r^{*}\right)$, we have

$$\begin{array}{c}\hfill \left\{\begin{array}{c}{\alpha }_{r^{*},j}\le p_j\mathrm{for}\mathrm{any}\mathrm{job}{J}_j\in J;\hfill \\ {\alpha }_{r^{*},j}=p_j\mathrm{for}\mathrm{any}\mathrm{job}{J}_j\in A_{r^{*}},\hfill \end{array}\right.\end{array}$$

(6)

where ${\alpha }_{r^{*},j}$ is the frozen variable of job $J_j$ and $A_{r^{*}}$ is the accepted jobs produced by Process A$\left(r^{*}\right)$. Since $A^{*}$ and $R^{*}$ are the sets of the accepted jobs and the rejected jobs in optimal schedule ${\sigma }^{*}$, we have

$$\begin{array}{ccc}\hfill Z^{*}& \ge & p\left(A^{*}\right)+\pi \left(R^{*}\right)\hfill \\ & =& \sum _{j:J_j\in A^{*}}{p}_j+\pi (R^{*}\cup B_{r^{*}})\hfill \\ & \ge & \sum _{j:J_j\in A^{*}}{p}_j+\sum _{j:J_j\in R^{*}}{\alpha }_{r^{*},j}+\pi \left(B_{r^{*}}\right)\hfill \\ & \ge & \sum _{j:J_j\in J}{\alpha }_{r^{*},j}+\pi \left(B_{r^{*}}\right),\hfill \end{array}$$

(7)

where the second inequality follows from inequality (4) and the third inequality follows from inequality (6).

Therefore, we have

$$\begin{array}{ccc}\hfill Z& \le & Z_{r^{*}}=r^{*}+p\left(A_{r^{*}}\right)+\pi \left(R_{r^{*}}\right)\hfill \\ & =& r^{*}+\sum _{j:J_j\in A_{r^{*}}}{\alpha }_{r^{*},j}+\sum _{j:J_j\in R_{r^{*}}}{\alpha }_{r^{*},j}+\pi \left(B_{r^{*}}\right)\hfill \\ & =& r^{*}+\sum _{j:J_j\in J}{\alpha }_{r^{*},j}+\pi \left(B_{r^{*}}\right)\hfill \\ & \le & 2Z^{*},\hfill \end{array}$$

where the second equality follows equality (6) and Lemma 4, and the last inequality follows from inequalities (5) and (7).

To show that the bound is tight, consider the following instance with three jobs: $J_1=(r_1,p_1)=(1,2)$, $J_2=(r_2,p_2)=(1,1)$ and $J_3=(r_3,p_3)=(4,0)$. The submodular function $\pi (·)$ is defined as following: $\pi \left(\left\{J_1\right\}\right)=3$, $\pi \left(\left\{J_2\right\}\right)=1$, $\pi \left(\left\{J_3\right\}\right)=10$, $\pi \left(\{J_1,J_2\}\right)=4$, $\pi \left(\{J_1,J_3\}\right)=12$, $\pi \left(\{J_2,J_3\}\right)=11$ and $\pi \left(\{J_1,J_2,J_3\}\right)=13$.

Through the Process A$\left(r\right)$, when $r=r_0=0$, the resulting schedule ${\sigma }_{r_0}$ is to reject $J_1$, $J_2$, $J_3$. Thus, we have $Z_{r_0}=\pi \left(\{J_1,J_2,J_3\}\right)=13$; when $r=r_1$(or $r_2$)$=1$, the resulting schedule ${\sigma }_{r_1}$ (or ${\sigma }_{r_2}$) is to accept $J_2$ and reject $J_1$, $J_3$. Thus, we have $Z_{r_1}(=Z_{r_2})=r_1+p_2+\pi \left(\{J_1,J_3\}\right)=14$; when $r=r_3=4$, the resulting schedule ${\sigma }_{r_3}$ is to accept $J_1$, $J_3$ and reject $J_2$. Thus, we have $Z_3=r_3+p_1+p_3+\pi \left(\left\{J_2\right\}\right)=8$. The optimal schedule is to accept $J_1$,$J_2$, $J_3$. And we have $Z^{*}=r_1+p_1+p_2+p_3=4$. Thus, we have $Z=min\{Z_{r_0},Z_{r_1},Z_{r_2},Z_{r_3}\}=8=2Z^{*}$. □

Then, we consider a special case for the problem $1|r_j,reject|C_{max}+\pi \left(R\right)$ where all the jobs have the same release date.

Theorem 2.

The problem $1|r_j,reject|C_{max}+\pi \left(R\right)$ can be solved optitmally in polynomial time when all the jobs have the same release date.

Proof. 

If the optimal schedule ${\sigma }^{*}$ rejected all the jobs, then ${\sigma }^{*}$ is the output schedule of Process A$\left(r_0\right)$, where $r_0=0$, the theorem holds. Otherwise, assume $r_j=r^{*}$ for any job $J_j\in J$. The start processing time of machine is $r^{*}$ and there is no job $J_j$ in J satisfying $r_j>r^{*}$. That implies that

$$B_{r^{*}}=\varnothing \mathrm{and}\pi \left(B_{r^{*}}\right)=0.$$

Thus, we have

$$\begin{array}{ccc}\hfill Z^{*}& =& r^{*}+p\left(A^{*}\right)+\pi \left(R^{*}\right)\hfill \\ & =& r^{*}+\sum _{j:J_j\in A^{*}}{p}_j+\pi (R^{*}\cup B_{r^{*}})\hfill \\ & \ge & r^{*}+\sum _{j:J_j\in A^{*}}{\alpha }_{r^{*},j}+\sum _{j:J_j\in R^{*}}{\alpha }_{r^{*},j}+\pi \left(B_{r^{*}}\right)\hfill \\ & =& r^{*}+\sum _{j:J_j\in J}{\alpha }_{r^{*},j},\hfill \end{array}$$

(8)

where the inequality follows from inequalities (4) and (6).

Through Step 3 of Process A$\left(r\right)$, we have

$$\begin{array}{ccc}\hfill Z& \le & Z_{r^{*}}=r^{*}+p\left(A_{r^{*}}\right)+\pi \left(R_{r^{*}}\right)\hfill \\ & =& r^{*}+\sum _{j:J_j\in A_{r^{*}}}{\alpha }_{r^{*},j}+\sum _{j:J_j\in R_{r^{*}}}{\alpha }_{r^{*},j}+\pi \left(B_{r^{*}}\right)\hfill \\ & =& r^{*}+\sum _{j:J_j\in J}{\alpha }_{r^{*},j}\hfill \\ & \le & Z^{*},\hfill \end{array}$$

where the second equality follows equality (6) and Lemma 4, and the last equality follows from $\pi \left(B_{r^{*}}\right)=0$.

Therefore, $Z=Z^{*}$, implying that the theorem holds. □

4. Conclusions and Future Work

In this paper, we proposed the single machine scheduling problem $1|r_j,reject|C_{max}+\pi \left(R\right)$ with release dates and nonmonotone submodular penalty, which generalizes the single machine scheduling with release dates and rejection [8]. We designed a combinatorial 2-approximation algorithm running in polynomial time with respect to this problem, base on the primal-dual framework. Noting that a combinatorial algorithm [8] only achieved an approximation ratio of 2 when the penalty function is modular, we extend the modular penalty function into submodular one without increasing the approximation ratio. In addition, when all the jobs have the same release date, exactly the same algorithm will become an exact algorithm running in polynomial time.

The topic could be further studied in the following ways. The online version of this problem is worth considering, since we do not always know complete information about jobs that have not arrived in real world. It is also challenging to design a fully polynomial-time approximation scheme for $1|r_j,reject|C_{max}+\pi \left(R\right)$ as in [8]. Moreover, when there are multiple machines rather than a single machine, algorithms under this setting could be further developed.