ISSN Online: 2160-8849 ISSN Print: 2160-8830

DOI: 10.4236/ajor.2019.95015 Sep. 20, 2019 235 American Journal of Operations Research

**Better Algorithm of Ordinal Online Schedule for **

**Jobs with Similar Sizes on Two Machines **

**Limin Wang**

**1**

**, Rongheng Li**

**1***

**, Yunxia Zhou**

**2**

1_{Key Laboratory of Computing and Stochastic Mathematics (Ministry of Education), Department of Mathematics, }

School of Mathematics and Statistics, Hunan Normal University, Changsha, China

2_{College of Information Science and Engineering, Hunan Normal University, Changsha, China }

**Abstract **

Ordinal online schedule for jobs with similar sizes in

### [ ](

1,*r*1≤ ≤

*r*2

### )

on two parallel machines system is considered. Firstly it is proved that the worst case performance ratio of the existing algorithm P2 cannot be improved even if thejob processing times are known in

### [ ]

1,*r*for any

*r*≥1. Then a better algo-rithm named S is developed and its worst case performance ratio is given for

1≤ ≤*r* 2_{. }

**Keywords **

Semi-Online Scheduling, Pm Algorithm, S Algorithm, Worst Performance

Ratio

**1. Introduction **

The scheduling problem on m parallel identical machines is defined as follows:
Given a job set *L*=

### {

*J J*1, , ,2

*Jn*

### }

of n jobs where job*Jj*has non-negative

processing time *pj*, assign the jobs on m machines

### {

*M M*1, 2, ,

*Mm*

### }

so as tominimize the maximum completion times of the jobs on each machine. The earliest algorithm for on-line scheduling jobs on parallel machines is the List Scheduling (LS) algorithm, which was introduced by Graham [1]. Many models and algorithms for online scheduling are proposed later on. In classic scheduling problem, there is no constraints on the size of job. However, in practice, the size of job can neither be too large nor too small. This motivates researchers to study scheduling problems when the sizes of all jobs are known in

### [ ]

1,*r*with

*r*≥1 [2]-[7].

In this paper, we will consider ordinal online scheduling jobs with sizes in

How to cite this paper: Wang, L.M., Li, R.H. and Zhou, Y.X. (2019) Better Algo-rithm of Ordinal Online Schedule for Jobs with Similar Sizes on Two Machines. Amer-ican Journal of Operations Research, 9, 235-243.

https://doi.org/10.4236/ajor.2019.95015 Received: June 5, 2019

Accepted: September 17, 2019 Published: September 20, 2019 Copyright © 2019 by author(s) and Scientific Research Publishing Inc. This work is licensed under the Creative Commons Attribution International License (CC BY 4.0).

http://creativecommons.org/licenses/by/4.0/

DOI: 10.4236/ajor.2019.95015 236 American Journal of Operations Research

### [ ](

1,*r*1≤ ≤

*r*2

### )

_{ on two parallel machines. The model of ordinal online sche- }duling was proposed by Liu et al. [8]. It is assumed that the values of the processing times are unknown, but that the order of the jobs by non-increasing processing time is known, i.e., without loss of generality that

*p*1≥

*p*2≥≥

*pn*.

An algorithm named Pm was developed for the system of m machines and it is

proved that the algorithm is the best online algorithm for *m*=2,3. In current
research, it will be proved that, for *m*=2_{, the worst case performance ratio of }
algorithm P2 can not be improved even if the sizes of all jobs are known in

### [ ]

1,*r*

for any *r*≥1_{. Then a better algorithm named }_{S}_{ is proposed for } *r*∈

### [ ]

1,2_{ and }its worst case performance ratio is given.

The rest of the paper is organized as follows. In Section 2, some definitions and the algorithm S and P2 are given. Section 3 analyzes the competitive ratio of

the algorithm S. Finally, some concluding remarks are given in Section 4.

**2. Some Definitions and Algorithms **

Definition 1. Given m parallel machines, let *L*=

### {

*J J*1, , ,2

*Jn*

### }

beany list ofjobs. AlgorithmAisaheuristicalgorithm. Let *C*max*A*

### ( )

*L*and

*C*max

*OPT*

### ( )

*L*be the

makespan of algorithm A and the makespan of an optimal off-line algorithm respectively. Wereferto

### (

### )

max### ( )

_{( )}

max
, sup _{OPT}A

*L*

*C* *L*

*R m A*

*C* *L*

=

as the worst case performance ratio of algorithm A.

In the following of this paper, we always assume that the number of machines
is two (i.e. *m*=2_{) and the sizes of job list } *L*=

_{{}

*J J*

_{1}, , ,

_{2}

*J*

_{n}_{}}

satisfies
1 2 *n*

*p* ≥ *p* ≥≥ *p* and *p _{j}*∈

### [ ](

1,*r j*=1,2, , ,1

*n*≤ ≤

*r*2

### )

if no specific explana- tion is given.Algorithm P2 [8]. Jobs are assigned to machines as follows:

### {

### }

### {

### }

1 3 1

2 3 1 3

: | 0 ,

: , | 1 .

*k*

*k* *k*

*M* *J* *k*

*M* *J* *J* *k*

+

−

≥ ≥

i.e.

1 1 4 7 10

2 2 3 5 6 8 9

: :

*M J J* *J* *J*

*M J* *J* *J* *J* *J* *J*

Algorithm S.

Jobs are assigned to machines as follows:

### { } {

### }

### {

### }

1 1 4 4 1

2 4 2 4 1

: , | 1 ,

: , | 1 .

*k* *k*

*k* *k*

*M* *J* *J J* *k*

*M* *J* *J* *k*

+

− −

≥ ≥

∪

i.e.

1 1 4 5 8 9 12

2 2 3 6 7 10 11

: :

*M J J* *J* *J* *J* *J*
*M J* *J* *J* *J* *J* *J*

DOI: 10.4236/ajor.2019.95015 237 American Journal of Operations Research

ferences are that P2 assign the first two jobs on M2 and the third on M1 for job set

### {

*J jj*| =3

*k*+2,3

*k*+3,3

*k*+4

### }

### (

*k*≥1

### )

. However algorithm S assign the two conse- cutive job*J*2 1

*k*+ ,

*J*2

*k*+2

### (

*k*≥2

### )

on two machines alteratively.In the following, we consider the worst case performance ratio of algorithm P2

and S. We will show that algorithm S is better than P2 under the assumption of

### [ ]

1,*j*

*p* ∈ *r* _{ for } *r*≤2_{. }

**3. Main Results **

Theorem 1. For algorithm P2, its worst case performance ratio is 4 3. Fur- thermore, its worst case performance ratio can not be improved if

### (

1,2, ,### )

*j*

*p j*= *n* satisfy *pj*∈

### [ ]

1,*r*for any

*r*≥1.

Proof: The first conclusion is a direct result from Liu et al. [8]. For the second
conclusion, consider job list *L*=

### {

*J J*1, , ,2

*J*6

*k*+4

### }

satisfying1 2 3 4 1, 5 6 6 4*k* 1.

*p* =*p* = *p* = *p* = ≥*r* *p* = *p* = ⋅⋅⋅ = *p* + =
By the rules of P2, we get

1

2

: 1 1

: 1 1 1 1

*M r r*
*M r r*

It is obvious that 2

### ( )

max*P* 2 4

*C* *L* = *r*+ *k* and *C*max*OPT*

### ( )

*L*=2 3

*r*+

*k*. Hence

### ( )

### ( )

### (

### )

2

max max

2 4 4 _{.}

2 3 3

*P*
*OPT*

*C* *L* *r* *k* _{k}

*r* *k*

*C* *L*

+

= → → ∞

+

In the following of this paper, let *L ii*

### (

=1,2### )

to denote the completion time of machine Mi in the schedule assigned by algorithm S.Lemma 2. Given any job list *L*=

### {

*J J*1, , ,2

*Jn*

### }

, the following inequalityholds

### ( )

### ( )

### ( )

max

max max

1 .

2

*S*

*OPT* *OPT*

*C* *L* *r*

*C* *L* ≤ + *C* *L*

Proof: By the rules of S algorithm, we get

### ( )

### ( )

### {

### ( )

### }

### {

### }

### {

### }

### ( )

### ( )

max 1 2

max max

1 2 1 2 1 2

max

1 2 max

max ,

max , min ,

2

1 .

2

*S*

*OPT* *OPT*

*OPT*

*OPT*

*C* *L* *L L*

*C* *L* *C* *L*

*L L* *L L* *L L*

*C* *L*

*L L*

*C* *L*

=

+ + −

=

− ≤ +

That means it is enough to prove *L L*1− 2 ≤*r*. We consider it according to
the four cases of *n*=4*k*, *n*=4*k*+1, *n*=4*k*+2, *n*=4*k*+3.

Case 1: *n*=4*k*. In this case,

### (

### )

### (

### )

1

1 1 4 4 1 4 2 4 2 4 1

1 ; 1 .

*k* *k*

*j* *j* *k* *j* *j*

*j* *j*

*L* *p* − *p* *p* + *p* *L* *p* − *p* −

= =

= +

### ∑

+ + =### ∑

+DOI: 10.4236/ajor.2019.95015 238 American Journal of Operations Research

### (

### )

### (

### )

1

1 2 1 4 4 1 4 2 4 1 4 4 2 4 1 1

1

1

2 1 2 3 1 4 2 4 3 4 4 1 4 2

1

,

.

*k*

*j* *j* *j* *j* *k* *k* *k*

*j*

*k*

*j* *j* *j* *j* *k*

*j*

*L L* *p* *p* *p* *p* *p* *p* *p* *p* *p r*

*L L* *p* *p* *p* *p* *p* *p* *p* *p* *p* *r*

−

+ − − − −

=

−

+ + +

=

− = + + − − + − − ≤ ≤

− = + − + + − − − ≤ ≤

### ∑

### ∑

That means *L L*1− 2 ≤*r*.
Case 2: *n*=4*k*+1. In this case,

### (

### )

### (

### )

1 1 4 4 1 2 4 2 4 3

1 , 1 .

*k* *k*

*j* *j* *j* *j*

*j* *j*

*L* *p* *p* *p* + *L* *p* − *p* −

= =

= +

### ∑

+ =### ∑

+Hence the following inequalities hold:

### (

### )

### (

### )

1 2 1 4 4 1 4 2 4 1 1

1

1

2 1 2 3 1 4 2 4 3 4 4 1 4 4 1 2

1

,

.

*k*

*j* *j* *j* *j*

*j*

*k*

*j* *j* *j* *j* *k* *k*

*j*

*L L* *p* *p* *p* *p* *p* *p r*

*L L* *p* *p* *p* *p* *p* *p* *p* *p* *p* *p* *r*

+ − −

=

−

+ + + +

=

− = + + − − ≤ ≤

− = + − + + − − − − ≤ ≤

### ∑

### ∑

That means *L L*1− 2 ≤*r*. Similarly it is easy to show that the conclusion is
true for the case of *n*=4*k*+2 and *n*=4*k*+3.

Theorem 3. For any job list *L*=

### {

*J J*1, , ,2

*Jn*

### }

with*p*1≥

*p*2≥≥

*pn*and

### [ ](

1, 1 2### )

*j*

*p* ∈ *r* ≤ ≤*r* _{, algorithm }_{S}_{ has worst case performance ratio }

### ( )

### ( )

maxmax

2 _{,} 3 _{2}

3 2

7_{ ,} 4 3

6 3 2

1_{, 1} 4

2 3

*S*

*OPT*

*r* _{r}

*C* *L*

*r*

*C* *L*

*r* _{r}

+

_{< ≤}

≤ ≤ ≤

+

_{≤ <}

(1)

Proof: Suppose (1) is not true. For 3 2

2≤ ≤*r* the following inequalities hold
by Lemma 2:

### ( )

### ( )

### ( )

max

max max

2 _{1}

3 2

*S*

*OPT* *OPT*

*C* *L*

*r* *r*

*C* *L* *C* *L*

+ _{<} _{≤ +}

That means *C*max*OPT*

### ( )

*L*<

_{2}

_{(}

*3*

_{r}*r*

_{−}

_{1}

_{)}

<5. Similarly *C*max

*OPT*

### ( )

*L*<5 also holds for

4 3

3≤ <*r* 2. That means there are at most four jobs assigned on any machine in
any optimal schedule, i.e., *n*≤8_{. It is easy to prove that algorithm S is optimal if }

5

*n*< . Now consider *n*=5. In this case

### ( )

1 1 4 5 2 2 3 2

max 3 4 5

2 ,

.

*OPT*

*L* *p p* *p* *p* *p* *p* *L*

*C* *L* *p* *p* *p*

= + + ≥ + ≥ + =

≥ + +

Hence

### ( )

### ( )

1### (

### (

4 5### )

### )

max 1 4 5 1

3 4 5 3 4 5 3

max

2 _{2 .}

2 3

*S*
*OPT*

*p* *p* *p*

*C* *L* *p* *p* *p* *p* *r*

*p* *p* *p* *p* *p* *p* *p*

*C* *L*

+ +

+ + + +

≤ ≤ ≤ ≤

+ + + + +

DOI: 10.4236/ajor.2019.95015 239 American Journal of Operations Research

### ( )

### ( )

max 1 4 5 4 1 5

1 5 6 6 1 5

max

2 3

*S*
*OPT*

*C* *L* *p* *p* *p* *p* *p* *p* *r*

*p* *p* *p* *p* *p* *p*

*C* *L*

+ + + + +

≤ ≤ ≤

+ + + +

If *L L*1≤ 2 we have

### ( )

### ( )

2### (

### (

3 6### )

### )

max 2 3 6 2

1 5 6 5 3 6 3

max

2 _{2 .}

2 3

*S*
*OPT*

*p* *p* *p*

*C* *L* *p* *p* *p* *p* *r*

*p* *p* *p* *p* *p* *p* *p*

*C* *L*

+ +

+ + + +

≤ ≤ ≤ ≤

+ + + + +

For the case of *n*=7_{, the following holds }

2 2 3 6 7 2 3 2 1 2 3 1.

*L* = *p* +*p* +*p* +*p* ≥ *p* +*p* + ≥ *p* +*p* +*p* =*L*

In any optimal schedule, exactly four jobs are assigned on one machine and exactly three jobs are assigned on another. If the machine assigned four jobs in optimal schedule has at least one job from set

### {

*J J J*1, ,2 3

### }

, then the following inequality holds:### ( )

max*OPT* 3 5 6 7.

*C* *L* ≥ *p* +*p* +*p* +*p*

Hence we get

### ( )

### ( )

max 2 3 6 7 2

3 5 6 7 5

max

3 3 _{2 .}

3 4 3

*S*
*OPT*

*C* *L* *p* *p* *p* *p* *p* *r* *r*

*p* *p* *p* *p* *p*

*C* *L*

+ + + + + +

≤ ≤ ≤ ≤

+ + + +

Otherwise the optimal schedule is that

### {

*J J J*1, ,2 3

### }

and### {

*J J J J*4, , ,5 6 7

### }

are assigned separately on two machines. Let 2 32

*p* *p*

*a*= + _{, } 4 5
2

*p* *p*
*b*= + _{, }

6 7

2

*p* *p*

*c*= + _{. It is easy to see that } *a b c*≥ ≥ holds. We analyze the following two
cases. In the case of 3*a*≤2*b*+2*c*, we get

### ( )

### ( )

max 2 3 6 7

4 5 6 7

max

2 5 2 _{7 ,}

3 3 3 6

*S*
*OPT*

*C* *L* *p* *p* *p* *p* *a c* *b* *c* *c*

*p* *p* *p* *p* *b c* *b* *c* *b c*

*C* *L*

+ + + + +

≤ = ≤ = + ≤

+ + + + + +

the last inequality results from *b c*≥ .
In the case of 3*a*>2*b*+2*c* we get

### ( )

### ( )

max 2 3 6 7

1 2 3

max

2 2 2 2 2 2 _{7 .}

3 3 3 3 2 2 6

*S*
*OPT*

*C* *L* *p* *p* *p* *p* *a* *c* *c* *c*

*p* *p* *p* *a* *a* *b* *c*

*C* *L*

+ + + +

≤ = = + ≤ + ≤

+ + +

For *n*=8, there are exactly four jobs assigned on each machine and there is a
machine on which at least two jobs from

### {

*J J J*1, ,2 3

### }

are assigned in any optimal schedule. Hence the following inequality holds:### ( )

### {

### }

max*OPT* max 2 3 7 8, 1 6 7 8 .

*C* *L* ≥ *p* +*p* +*p* +*p p p*+ +*p* +*p*

Therefore if *L L*1≥ 2 we get

### ( )

### ( )

max 1 4 5 8 1 4 5 8

2 3 7 8 7 4 5 8

max

3 _{2 .}

4 3

*S*
*OPT*

*C* *L* *p* *p* *p* *p* *p* *p* *p* *p* *r* *r*

*p* *p* *p* *p* *p* *p* *p* *p*

*C* *L*

+ + + + + + + +

≤ ≤ ≤ ≤

+ + + + + +

If *L L*1≤ 2 we get

### ( )

### ( )

max 2 3 6 7 2 3 6 7

1 6 7 8 8 3 6 7

max

3 _{2 .}

4 3

*S*
*OPT*

*C* *L* *p* *p* *p* *p* *p* *p* *p* *p* *r* *r*

*p p* *p* *p* *p* *p* *p* *p*

*C* *L*

+ + + + + + + +

≤ ≤ ≤ ≤

DOI: 10.4236/ajor.2019.95015 240 American Journal of Operations Research

By the conclusions above, we get

### ( )

### ( )

max max

2 _{,} 3 _{2}

7 2 3 2

max ,

7 4 3

6 3 _{,}

6 3 2

*S*
*OPT*

*r* _{r}

*C* *L* *r*

*C* *L* _{r}

+

_{< ≤}

+
≤ _{} _{ }=
_{ } _{≤ ≤}

Hence (1) is true for 4 2

3≤ ≤*r* .

Now we consider the case of 1 4 3

*r*

≤ ≤ according to the four cases of

### 4 1,4

### 2,4

### 3,4

### 4,

### 0,1,2,

*n*

### =

*k*

### +

*k*

### +

*k*

### +

*k*

### +

*k*

### =

. In the following, we will use*Si*

and *

*i*

*S* to denote the job set assigned on machine Mi by algorithm S and optimal

algorithm, respectively.

For the case of *n*=4*k*+1, we have *S*1 =2*k*+1, *S*2 =2*k*,

### {

* *### }

1 2

max *S* ,*S* ≥2*k*+1_{. Without loss of generality, suppose } *

1 2 1

*S* ≥ *k*+ _{. Then }
it is easy to see that there exists *i*∈

### { }

1,2 satisfying *1 *i* 1

*S* ∩*S* ≥ +*k* . If

*

1 1 1

*S* ∩*S* ≥ +*k* , then *
1\ 1

*S S* ≤*k*_{. By }

### (

### )

1

2 1 2 3 1 4 2 4 3 4 4 1 4 4 1

1 0,

*k*

*j* *j* *j* *j* *k* *k*

*j*

*L L* *p* *p* *p* − *p* + *p* + *p* *p* + *p* *p* +

=

− = + − +

### ∑

+ − − − − ≤we get *L L*1≥ 2. Therefore

### ( )

### ( )

### ( )

### (

### )

* *

1 1 1 1 1

* * *

1 1 1 1 1

\

max 1

max max

\

* *

1 1 1 1

* *

1 1 1 1

* *

1 1 1 1 1

\ \

2 1

1 _{1.}

2 1 2

*j* *j*

*j*
*S*

*j S* *j S S* *j S S*

*OPT* *OPT*

*j* *j* *j*

*j S* *j S S* *j S S*

*p* *p*

*p*

*C* *L* *L*

*p* *p* *p*

*C* *L* *C* *L*

*S* *S* *S S r*

*S* *S* *S S*

*S* *S* *S* *S* *S r*

*k*
*kr k* *r*

*k*
∈ ∈ ∈
∈ ∈ ∈
+
= ≤ ≤
+
+
≤
+
+ −
≤
+
+ + +
≤ ≤
+

### ∑

### ∑

### ∑

### ∑

### ∑

∩### ∑

∩ ∩ ∩ ∩ ∩If *

1 1

*S* ∩*S* ≤*k*, then *

1 2 1

*S* ∩*S* ≥ +*k* . By

### (

### )

1 2 1 4 4 1 4 2 4 3 1

1

*k*

*j* *j* *j* *j*

*j*

*L L* *p* *p* *p* + *p* − *p* − *p*

=

− = +

### ∑

+ − − ≤we get *L L*1≤ 2+*p*1. Therefore

### ( )

### ( )

### ( )

### (

### )

* *

2 2 1 2 1

* * *

1 2 1 1 2

1 \

max 2 1

max max

\

* *

2 1 2 1

* *

2 1 1 2

* *

2 1 2 2 1

\ \

2 1

1 _{1.}

2 1 2

*j* *j*

*j*
*S*

*j S* *j S* *S* *j S S*

*OPT* *OPT*

*j* *j* *j*

*j S* *j S* *S* *j S S*

*p* *p* *p*

*p*

*C* *L* *L* *p*

*p* *p* *p*

*C* *L* *C* *L*

*S* *S* *S S r r*

*S* *S* *S S*

*S* *S* *S* *S* *S r r*

*k*
*kr k* *r*

DOI: 10.4236/ajor.2019.95015 241 American Journal of Operations Research

For the case of *n*=4*k*+2, we have *S*1 =2*k*+1, *S*2 =2*k*+1,

### {

* *### }

1 2

max *S* ,*S* ≥2*k*+1_{. Without loss of generality, suppose } *

1 2 1

*S* ≥ *k*+ . There-
fore there exists *i*∈

### { }

1,2 satisfying *1 *i* 1

*S* ∩*S* ≥ +*k* . In the following we con-
sider this case according to the two subcases of *L L*1≥ 2 and *L L*1< 2 .

In this case of *L L*1≥ 2, if *S*1*∩*S*1 ≥ +*k* 1 holds, then the following is true:

### ( )

### ( )

### ( )

### (

### )

* *

1 1 1 1 1

* * *

1 1 1 1 1

\

max 1

max max

\

* *

1 1 1 1

* *

1 1 1 1

* *

1 1 1 1 1

\ \

2 1

1 _{1.}

2 1 2

*j* *j*

*j*
*S*

*j S* *j S S* *j S S*

*OPT* *OPT*

*j* *j* *j*

*j S* *j S S* *j S S*

*p* *p*

*p*

*C* *L* *L*

*p* *p* *p*

*C* *L* *C* *L*

*S* *S* *S S r*

*S* *S* *S S*

*S* *S* *S* *S* *S r*

*k*
*kr k* *r*

*k*
∈ ∈ ∈
∈ ∈ ∈
+
= ≤ ≤
+
+
≤
+
+ −
≤
+
+ + +
≤ ≤
+

### ∑

### ∑

### ∑

### ∑

### ∑

∩### ∑

∩ ∩ ∩ ∩ ∩If *

1 1

*S* ∩*S* ≤*k* holds, we consider the following two subcases of *

1 2 1

*S* = *k*+
and *

1 2 2

*S* ≥ *k*+ _{. }
For the case of *

1 2 1

*S* = *k*+ , *

2 2 1

*S* = *k*+ holds by *n*=4*k*+2. By

1 2 1

*S* = *k*+ _{ and } *

1 1

*S* ∩*S* ≤*k* we get *

2 1 1

*S* ∩*S* ≥ +*k* . Therefore

### ( )

### ( )

### ( )

### (

### )

* *

1 1 2 1 2

* * *

2 1 2 2 1

\

max 1

max max

\

* *

1 2 1 2

* *

1 2 2 1

* *

1 2 1 1 2

\ \

2 1

1 _{1.}

2 1 2

*j* *j*

*j*
*S*

*j S* *j S S* *j S S*

*OPT* *OPT*

*j* *j* *j*

*j S* *j S S* *j S S*

*p* *p*

*p*

*C* *L* *L*

*p* *p* *p*

*C* *L* *C* *L*

*S* *S* *S S r*

*S* *S* *S S*

*S* *S* *S* *S* *S r*

*k*
*kr k* *r*

*k*
∈ ∈ ∈
∈ ∈ ∈
+
= ≤ ≤
+
+
≤
+
+ −
≤
+
+ + +
≤ ≤
+

### ∑

### ∑

### ∑

### ∑

### ∑

∩### ∑

∩ ∩ ∩ ∩ ∩For the case of *

1 2 2

*S* ≥ *k*+ _{, by } *
1 1

*S* ∩*S* ≤*k* we get *

1 2 2

*S* ∩*S* ≥ +*k* . By rules
of S algorithm, we have

### (

### )

1 2 1 4 4 1 4 2 4 1 4 2 1 4 2

1 .

*k*

*j* *j* *j* *j* *k* *k*

*j*

*L L* *p* *p* *p* + *p* − *p* − *p* + *p p* +

=

− = +

### ∑

+ − − − ≤ −That means *L L*1≤ 2+*p p*1− 4 2*k*+ . Therefore

### ( )

### ( )

### ( )

### ( )

### (

### )

* *

2 1 2 1

* *

2 1 1 2

max 1 2 1 4 2

max max max

1 4 2 * *

2 1 2 1

\

* *

2 1 1 2

\

* *

2 1 2 2 1

\ 1

\

1 _{1} _{1} _{1.}

2 2 2 2 2 1 2

*S*

*k*

*OPT* *OPT* *OPT*

*j* *j* *k*

*j S* *S* *j S S*

*j* *j*

*j S* *S* *j S S*

*C* *L* *L* *L* *p p*

*C* *L* *C* *L* *C* *L*

*p* *p* *p p*

*S* *S* *S S r r*

*p* *p* *S* *S* *S S*

*S* *S* *S* *S* *S r r* _{kr k}_{kr k}_{r}

*k* *k* *k*

DOI: 10.4236/ajor.2019.95015 242 American Journal of Operations Research

Similarly we can prove the case of *L L*1< 2.

By the same way used above, we can also show that (1) is true for the case of 4 3

*n*= *k*+ _{ and } *n*=4*k*+4_{ for }1 4
3

*r*

≤ ≤ _{. Now we show the tightness of the }
bound.

For 3 2

2< ≤*r* , Let

( )1

_{{}

_{}}

1, , , ,2 3 4 5
*L* = *J J J J J* _{ with } *p*_{1}=*r p*, *i* =1,*i*=2, ,5 . By
the rules of S algorithm, we have *L r*1= +2,*L*2 =2, i.e., *C*max*S*

### ( )

*L*( )1 = +

*r*2. It is easy to see that

### ( )

( )1max*OPT* 3

*C* *L* = _{. Hence }

( )

### ( )

( )

### ( )

1 max

1 max

2 . 3

*S*
*OPT*

*C* *L* _{r}

*C* *L*

+ =

It is easy to show the tightness for 4_{3}≤ ≤*r* 3_{2}_{ by job list }

( )2

_{{}

_{}}

1, , , , , ,2 3 4 5 6 7
*L* = *J J J J J J J* with *p*1=*p*2= *p*3=_{3}4 , *p*4= *p*5= *p*6= *p*7 =1

and for 1 4 3

*r*

≤ ≤ by job list with *p*1= *p*2 = *p*3 =*r*, *p*4= *p*5= *p*6 =*p*7=1.

**4. Concluding Remarks **

In this paper, we consider ordinal on-line scheduling for jobs with known sizes in

### [ ](

1,*r r*≥1

### )

_{ and non-decreasing processing times on two parallel machines }system. Firstly it is proved that the worst case performance ratio of the existing algorithm P2 can not be improved even if the job processing times are known in

### [ ]

1,*r*for any

*r*≥1. Secondly, an algorithm named S is proposed and its worst case performance ratio is given as follow:

### ( )

2 _{,} 3 _{2}

3 2

7 4 3

2, ,

6 3 2

1_{,} _{1} 4

2 3

*r* _{r}

*R* *S* *r*

*r* _{r}

+

_{< ≤}

= ≤ ≤

+

_{≤ <}

which is better than algorithm P2. Just two machines are considered here. It is an

interesting problem to consider general m machines system to design better algorithm.

**Acknowledgements **

The authors would like to express their thanks to the National Natural Science Foundation of China for financially supporting under Grant No. 11471110 and the Foundation Grant of Education Department of Hunan (No. 16A126).

**Conflicts of Interest **

DOI: 10.4236/ajor.2019.95015 243 American Journal of Operations Research

**References **

[1] Graham R.L. (1969) Bounds on Multiprocessing Timing Anomalies. SIAM Journal on Applied Mathematics, 17, 416-429. https://doi.org/10.1137/0117039

[2] Cheng, T.C.E., Kellerer, H. and Kotov, V. (2012) Algorithms Better than LPT for Semi-Online Scheduling with Decreasing Processing Times. Operations Research Letters, 40, 349-352.

[3] He, Y. and Dósa, G. (2005) Semi-Online Scheduling Jobs with Tightly-Grouped Processing Times on Three Identical Machines. Discrete Applied Mathematics, 150, 140-159.

[4] He, Y. and Zhang, G. (1999) Semi on-Line Scheduling on Two Identical Machines. Computing, 62, 179-187. https://doi.org/10.1007/s006070050020

[5] Kellerer, H., Kotov, V., Speranza, M.G. and Tuza, Z. (1997) Semi on-Line Algo-rithms for the Partition Problem. Operations Research Letters, 21, 235-242. https://doi.org/10.1016/S0167-6377(98)00005-4

[6] Lin, L. and Tan, Z. (2014) Inefficiency of Nash Equilibrium for Scheduling Games with Constrained Jobs: A Parametric Analysis. Theoretical Computer Science, 521, 123-134. https://doi.org/10.1016/j.tcs.2013.11.012

[7] Gupta, S., Dalal, U.D. and Mishra, V.N. (2014) Novel Analytical Approach of Con-ventional Mapping Scheme with Discrete Hartley Transform in OFDM System. American Journal of Operations Research, 4, 281-292.

https://doi.org/10.4236/ajor.2014.45027

[8] Liu, W.P., Sidney, J.B. and Vliet, A.V. (1996) Ordinal Algorithms for Parallel Ma-chine Scheduling. OperationsResearchLetters, 18, 223-232.