*1.1. Background*

In this paper, all jobs arrive over time, i.e., each job has an arrival time. Before the jobs arrive, we do not know any information, including arrival time, processing time, deterioration rate, etc. Due to the unknown information of the jobs, the online algorithm is not guaranteed to be optimal. Borodin and El-Yaniv [1] used the competitive ratio to measure the quality of an online algorithm. For a minimization scheduling problem, we define the competitive ratio of the online algorithm *A* as:

$$\rho = \sup \{ A(\mathcal{Z}) / OPT(\mathcal{Z}) : \mathcal{Z} \text{ is any instance such that } OPT(\mathcal{Z}) > 0 \}.$$

where I is any job instance and *A*(I) and *OPT*(I) are the objective values obtained from the algorithm *A* and an optimal offline scheduling *OPT*, respectively. In this study, the objective was to minimize the makespan. An online algorithm *A* is called the best possible if no other online algorithms *A*∗ produce a smaller competitive ratio.

Parallel-batch means that one batch processing machine can process *b* jobs simultaneously as a batch. The processing time of a batch is the maximum processing time of all jobs in this batch. All jobs in a batch have the same starting time, processing time, and completion time. According to the number of jobs contained in a batch, Brucker et al. [2] divided the model into two cases: the unbounded model (*b* = ∞) and the bounded model (*b* < ∞).

Job families mean that one job must belong to some job family, and jobs of different families cannot be processed in the same batch. Online scheduling problems on parallel batch machines with incompatible job families have been studied extensively. Fu et al. [3] studied the online algorithm on a single machine to minimize the makespan. Li et al. [4] examined the online scheduling of incompatible unit-length job families with lookahead on a single machine. Tian et al. [5] analyzed the problem on *m* parallel machines. However, research is lacking on the parallel-batch online scheduling with incompatible deteriorating job families.

Traditional scheduling problems assume that the processing time of a job is fixed. However, in real life, one job will take longer when it has a later starting time. For example, in steel production and financial management [6,7], the processing time is longer when it starts later. In the steel-making process, strict requirements are placed on temperature. If the waiting time is too long, the temperature of molten steel will drop. So, it will take time to heat up again before further processing. Other examples are provided in cleaning and fire fighting. The scheduling problem of deteriorating jobs was first introduced by Browne and Yechiali [8] and Gupta and Gupta [9], independently. Both considered minimizing makespan on a single machine. Since then, this topic has attracted considerable attentions. Gawiejnowicz and Kononov [10] considered the general properties of scheduling with fixed job processing time and scheduling with job processing time as proportional linear functions of the job starting time. The relevant research includes [11–18], among many others. Recently, some works have been published about online algorithms for linear deteriorating jobs [19–23].

To minimize the makespan of the online scheduling problem on *m* parallel machines with linear deteriorating jobs, Cheng et al. [19] constructed an algorithm and proved that the bound of the competitive ratio of the algorithm is tight, where *m* = 2 and the largest deterioration rate of jobs is known in advance. Yu et al. [22] proved that no deterministic online algorithm is better than (1 + *α*max)-competitive when *m* = 2, where *α*max is the maximum deterioration rate of all jobs.

#### *1.2. Research Problem*

Our contribution is to extend the online scheduling problem on *m* parallel batch machines with simple linear deteriorating job families to minimize the makespan. Here, batch capacity is unbounded, i.e., *b* = ∞. We use f-family to denote there are *f* job families. We constructed the best possible online algorithm with the competitive ratio of (1 + *α*max)*<sup>f</sup>* when *m* = 1, where *f* is the number of job families and *α*max is the maximum deterioration rate of all jobs. When *m* ≥ 1 and *m* = *f* , we created the best possible online algorithm with the competitive ratio of 1 + *α*max.

We examined the online batch scheduling of simple linear deteriorating job families. The actual processing time *pj* of job *Jj* is assumed to be a linear function of its starting time *sj*, i.e., *pj* = *αjsj*, where *α<sup>j</sup>* > 0 is the deterioration rate, which is unknown until it arrives. The objective was to minimize makespan. Assume that the arrival time of all jobs is greater than or equal to *t*<sup>0</sup> > 0; otherwise, jobs arriving at time 0 can be completed at time 0. We used the three-field notation *α*|*β*|*γ* [24] to represent one scheduling problem.

This paper is organized as follows. In Section 2, we consider the problem 1|online,*rj*,p-batch, *b* = ∞,f-family, *pj* = *αjt*|*C*max, where *f* is the number of job families. We prove the lower bound and provide the best possible online algorithm with the competitive ratio of (1 + *α*max)*<sup>f</sup>* . In Section 3, we consider the problem *Pm*|online,*rj*,p-batch, *b* = ∞,*m*-family, *pj* = *αjt*|*C*max, where *m* is the number of machines. We prove the lower bound and provide the best possible online algorithm with the competitive ratio of 1 + *α*max, where *α*max is the maximum deterioration rate of all jobs.

Throughout this paper, we use *σ* and *π* to denote the schedules obtained from an online algorithm and an optimal offline schedule, respectively. Let *C*max(*σ*) and *C*max(*π*) be the objective values of *σ* and *π*, respectively, and *α*max be the maximum deterioration rate of all jobs. Let be an arbitrary small positive number.

#### **2. Single Batch Machine (***m* **= 1)**

In this section, we consider the online scheduling on an unbounded batch machine and the jobs belong to *f* incompatible deteriorating job families. The number of job families, *f* , is known in advance. We prove the lower bound and provide the best possible online algorithm with the competitive ratio of (1 + *α*max)*<sup>f</sup>* .

**Theorem 1.** *For problem* 1|*online,rj,p-batch*, *b* = ∞,*f-family*, *pj* = *αjt*|*C*max*, the competitive ratio of any online algorithm is not less than* (1 + *α*max)*<sup>f</sup> .*

**Proof.** Let *H* be any online algorithm and *I* be a job instance provided by the adversary. In instance *I*, all the jobs have the same deterioration rate of *α*.

At time *t*0, *f* jobs from the *f* different job families arrive by the adversary. If a job is scheduled by *H* to process at time *t* and *t* is in the time interval [*t*0,(1 + *α*)*<sup>f</sup> t*0), then at time *t* + , the adversary releases a copy of this job, which belongs to the same job family. Let *s* be the starting time of the first job whose completion time is at least (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*<sup>f</sup> <sup>t</sup>*0. (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*<sup>s</sup>* <sup>≥</sup> (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*<sup>f</sup> <sup>t</sup>*0. so,

$$s \ge (1+\kappa)^{f-1} t\_0. \tag{1}$$

**Case 1** (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*f*−1*t*<sup>0</sup> <sup>≤</sup> *<sup>s</sup>* <sup>&</sup>lt; (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*<sup>f</sup> <sup>t</sup>*0.

In this case, there are still *f* jobs from *f* distinct job families that are not processed at time (1 + *α*)*s*. So,

$$\mathcal{L}\_{\text{max}}(\sigma) \ge (1+a)^f (1+a)s = (1+a)^{f+1}s. \tag{2}$$

We assume that the jobs processed in the time interval [*t*0,(1 + *α*)*s*) belong to *k* distinct job families, say, F1, F2, ··· , F*k*, where 1 ≤ *k* ≤ *f* . The other *f* − *k* job families are defined by F*k*<sup>+</sup>1, F*k*<sup>+</sup>2, ··· , F*<sup>f</sup>* . Let *si* be the last starting time of the jobs in F*<sup>i</sup>* that start before or at time *s* for 1 ≤ *i* ≤ *k*, and satisfy *s*<sup>1</sup> < *s*<sup>2</sup> < ··· < *sk*. Clearly, *sk* = *s*. From the construction of instance *I*, we know that the last arrival time of the jobs in F*<sup>i</sup>* (1 ≤ *i* ≤ *k*) is *si* + and the arrival time of the jobs in F*<sup>i</sup>* (*k* + 1 ≤ *i* ≤ *f*) is *t*0.

Construct a schedule *π* below: the jobs in F*<sup>i</sup>* (1 ≤ *i* ≤ *f*) form a batch starting at time *si* , where:

$$s\_i^{\prime} = \begin{cases} (1+a)^{i-(k+1)}t\_{0\prime} & k+1 \le i \le f\\ \max\{s\_i + \varepsilon\_\prime (1+a)^{(f+i)-(k+1)}t\_0\}, & 1 \le i \le k. \end{cases}$$

We can see that *π* is feasible, and the maximum completion time of the jobs in *π* is the completion time of the jobs in F*k*. So,

$$\mathbb{C}\_{\text{max}}(\pi') = (1+a) \max \{ s\_k + \epsilon\_\prime (1+a)^{f-1} t\_0 \}. \tag{3}$$

Since *sk* = *s*, we have *C*max(*π* ) = max{(<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)(*<sup>s</sup>* <sup>+</sup> ),(<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*<sup>f</sup> <sup>t</sup>*0}. and *<sup>C</sup>*max(*π*) <sup>≤</sup> *<sup>C</sup>*max(*π* ). If *C*max(*π* )=(1 + *α*)(*s* + ), then by Equation (2) we know that:

$$\frac{\mathbb{C}\_{\max}(\boldsymbol{\sigma})}{\mathbb{C}\_{\max}(\boldsymbol{\pi})} \ge \frac{(1+\boldsymbol{a})^{f+1}\mathbf{s}}{(1+\boldsymbol{a})(\mathbf{s}+\boldsymbol{\epsilon})} \to (1+\boldsymbol{a})^f = (1+\boldsymbol{a}\_{\max})^f, \boldsymbol{\epsilon} \to 0.$$

If *C*max(*π* )=(1 + *α*)*<sup>f</sup> t*0, then by Equations (1) and (2), we know that:

$$\frac{\mathbb{C}\_{\max}(\boldsymbol{\sigma})}{\mathbb{C}\_{\max}(\boldsymbol{\pi})} \ge \frac{(1+a)^{f+1}s}{(1+a)^f t\_0} = \frac{(1+a)s}{t\_0} \ge (1+a)^f = (1+a\_{\max})^f.$$

**Case 2** *<sup>s</sup>* <sup>≥</sup> (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*)*<sup>f</sup> <sup>t</sup>*0.

According to the constructing of *I*, *sk* is the last starting time of the jobs in time interval [*t*0,(1 + *α*)*<sup>f</sup> t*0), and *sk* + is the last arrival time of all jobs.

Since *s* is the starting time of the first job whose completion time is at least (1 + *α*)*<sup>f</sup> t*0, we obtain (1 + *α*)*sk* < (1 + *α*)*<sup>f</sup> t*0, i.e., *sk* < (1 + *α*)*f*−1*t*0. From Equation (3), we have:

$$\begin{aligned} \mathfrak{C}\_{\max}(\pi') &= \max\{ (1+\mathfrak{a})(s\_k+\mathfrak{e}), (1+\mathfrak{a})^f t\_0 \} \\ &\to \max\{ (1+\mathfrak{a})s\_{k\prime}(1+\mathfrak{a})^f t\_0 \} \\ &= (1+\mathfrak{a})^f t\_0 \end{aligned}$$

as → 0.

By the definition of *s*, *f* jobs from *f* distinct job families have not been processed at time *s*. So,

$$\mathsf{C}\_{\max}(\sigma) \ge (1+a)^f s.$$

Thus,

$$\frac{\mathbb{C}\_{\max}(\sigma)}{\mathbb{C}\_{\max}(\pi)} \ge \frac{(1+\alpha)^f s}{(1+\alpha)^f t\_0} = \frac{s}{t\_0} \ge (1+\alpha)^f = (1+\alpha\_{\max})^f.$$

The result follows.

Before introducing the online algorithm, given a batch *B*, we define some notations in the following:

*J*(*B*): the last job with maximum deterioration rate in *B*.

*r*(*B*): the arrival time of *J*(*B*).

*s*(*B*): the starting time of *J*(*B*) in *σ*.

*α*(*B*): the deterioration rate of *J*(*B*).

*U*(*t*): the set of the unprocessed jobs at time *t*.

*Bi*(*t*): the set of the unprocessed jobs of the same family at time *t*, 1 ≤ *i* ≤ *f* , which is a waiting batch at time *t* if *Bi*(*t*) = ∅.

B(*t*): the set of the waiting batches at time *t*.


*r*(B(*t*)) = min{*r*(*B*) : *B* ∈ B(*t*)}.

The online algorithm, called *A*<sup>1</sup> (Algorithm 1), can be stated as follows. Without causing confusion, assume that *Bi*(*t*) = *Bi* in the following.

### **Algorithm 1:** *A*<sup>1</sup>

Input: Job instance *I*. **do** Step 0: Set *t* = *t*0. Step 1: If B(*t*) = ∅, then go to Step 5. Step 2: Let B(*t*) = {*B*1, *B*2, ··· , *Bk*} such that *α*(*B*1) ≥ *α*(*B*2) ≥···≥ *α*(*Bk*), where *k* ≤ *f* . Step 3: If *<sup>t</sup>* <sup>≥</sup> (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*kt*0, then process the batch *<sup>B</sup>*<sup>1</sup> at time *<sup>t</sup>*. Reset *<sup>t</sup>* = (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*t*. Return to Step 1. Step 4: If *<sup>t</sup>* <sup>&</sup>lt; (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*kt*0, then reset *<sup>t</sup>* <sup>=</sup> min{(<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*kt*0, *<sup>t</sup>* ∗}, where *t* ∗ is the arrival time of the next job. Go to Step 2. Step 5: If new jobs arrive after *t*, then reset *t* as the arrival time of the first new job. Go to Step 1. Output: Job schedule *σ*.

**Example 1.** *To make the algorithm more intuitive, we present an instance* I<sup>1</sup> *in Table 1, where* F<sup>1</sup> *and* F<sup>2</sup> *are two different families. As shown in Figure 1, σ is the schedule generated by A*<sup>1</sup> *and π is an optimal offline schedule for* I1*, where B*<sup>1</sup> = {*J*1, *J*3} *and B*<sup>2</sup> = {*J*2}*.*

*We have C*max(*σ*) = 81 *and C*max(*π*) = 9*.*

**Table 1.** Instance I1.


**Figure 1.** Schedule for Instance I1.

Suppose that *rl* is the last arrival time. Let *s* ≥ *rl* be the minimum time, such that *s* is the starting time of some batch and there is no idle time between *s* and *C*max(*σ*) in *σ*. Let B be the set of the batches that process between *s* and *C*max(*σ*) in *σ* and *s*(B) be the start time of B. Since *s*(B) = *s* ≥ *rl*, each batch in B is from a different family and B = B(*s*). From Algorithm 1, B = {*B*1, *B*2, ··· , *Bk*} with *α*(*B*1) ≥ *α*(*B*2) ≥···≥ *α*(*Bk*), where *k* ≤ *f* . Then,

$$\mathbb{C}\_{\text{max}}(\sigma) = \prod\_{i=1}^{k} (1 + \alpha(B\_i)) s(\mathcal{B}). \tag{4}$$

The following two lemmas are the competition ratio analyses of Algorithm 1.

**Lemma 1.** *Suppose the machine has an idle time immediately before s*(B) *in σ. Then, C*max(*σ*)/*C*max(*π*) ≤ (1 + *α*max)*<sup>f</sup> .*

**Proof.** Since an idle time occurs immediately before *s*(B) in *σ*, from Algorithm 1, we have: *s*(B) = max{*rl*,(<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*kt*0}.

If *s*(B) = *rl*, then for each *Bi* ∈ B with 1 ≤ *i* ≤ *k*, *J*(*Bi*) arrives at time *rl*. From Equation (4), we know that *C*max(*σ*) = ∏*<sup>k</sup> <sup>i</sup>*=1(1 + *α*(*Bi*))*rl* ≤ *C*max(*π*).

If *<sup>s</sup>*(B)=(<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*kt*0, then from Equation (4) we have *<sup>C</sup>*max(*σ*) = <sup>∏</sup>*<sup>k</sup> <sup>i</sup>*=1(1 + *α*(*Bi*))(1 + *<sup>α</sup>*(*B*1))*kt*0. Since *<sup>C</sup>*max(*π*) <sup>≥</sup> <sup>∏</sup>*<sup>k</sup> <sup>i</sup>*=1(<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*Bi*))*t*0, so *<sup>C</sup>*max(*σ*)/*C*max(*π*) <sup>≤</sup> (<sup>1</sup> <sup>+</sup> *<sup>α</sup>*(*B*1))*<sup>k</sup>* <sup>≤</sup> (<sup>1</sup> <sup>+</sup> *α*max)*<sup>f</sup>* .

**Lemma 2.** *Suppose the machine has no idle time immediately before s*(B) *in σ. Then, C*max(*σ*)/*C*max(*π*) ≤ (1 + *α*max)*<sup>f</sup> .*

**Proof.** Since the machine has no idle time immediately before *s*(B) in *σ*, *s*(B) is the completion time of some batch, say *B*∗, in *σ*. We have *s*(B)=(1 + *α*(*B*∗))*s*(*B*∗). From the definition of *s*, we know *s*(*B*∗) < *rl*.

We suppose that B is divided into two sets, B<sup>1</sup> and B2, such that:

$$\begin{aligned} \mathcal{B}\_1 &= \{ B\_i \in \mathcal{B} : r(B\_i) > s(B^\*) \}, \\ \mathcal{B}\_2 &= \{ B\_j \in \mathcal{B} : r(B\_j) \le s(B^\*) \}. \end{aligned}$$

Since B = B<sup>1</sup> B2, *<sup>s</sup>*(B)=(<sup>1</sup> + *<sup>α</sup>*(*B*∗))*s*(*B*∗), then from Equation (4) we have:

$$\begin{aligned} \mathsf{C\_{\max}}(\sigma) &= \prod\_{i=1}^{k} (1 + a(B\_i))s(B) \\ &= \prod\_{B\_i \in \mathcal{B}} (1 + a(B\_i))s(B) \\ &= \prod\_{B\_i \in \mathcal{B}\_1} (1 + a(B\_i)) \prod\_{B\_j \in \mathcal{B}\_2} (1 + a(B\_j))(1 + a(B^\*))s(B^\*). \end{aligned}$$

From the definition of B1, we know *<sup>C</sup>*max(*π*) ≥ <sup>∏</sup>*Bi*∈B<sup>1</sup> (<sup>1</sup> + *<sup>α</sup>*(*Bi*))*s*(*B*∗). Hence,

$$\begin{aligned} \mathsf{C\_{\max}}(\sigma) &= \prod\_{B\_i \in \mathcal{B}\_1} (1 + \mathfrak{a}(B\_i)) \prod\_{B\_j \in \mathcal{B}\_2} (1 + \mathfrak{a}(B\_j)) (1 + \mathfrak{a}(B^\*)) \mathfrak{s}(B^\*) \\ &\le \prod\_{B\_j \in \mathcal{B}\_2} (1 + \mathfrak{a}(B\_j)) (1 + \mathfrak{a}(B^\*)) \mathsf{C\_{\max}}(\pi) .\end{aligned}$$

According to the definition of B<sup>2</sup> and Algorithm 1, each batch in set B<sup>2</sup> and *B*<sup>∗</sup> belongs to the different family. Then, at most *f* − 1 batches exist in B2. Hence,

$$\mathbb{C}\_{\max}(\sigma) / \mathbb{C}\_{\max}(\pi) \le \prod\_{B\_j \in B\_2} (1 + a(B\_j)) (1 + a(B^\*)) \le (1 + a\_{\max})^f.$$

By Lemmas 1 and 2, and Theorem 1, we can reach the final conclusion.

**Theorem 2.** *For problem* 1|*online,rj,p-batch*, *b* = ∞,*f-family*, *pj* = *αjt*|*C*max*, Algorithm 1 has a competitive ratio of* (1 + *α*max)*<sup>f</sup> and is the best possible.*
