View source for Longest-processing-time-first scheduling

{{Short description|Algorithm for job scheduling}}
'''Longest-processing-time-first (LPT)''' is a [[greedy algorithm]] for [[Optimal job scheduling|job scheduling]]. The input to the algorithm is a set of ''jobs'', each of which has a specific processing-time. There is also a number ''m'' specifying the number of ''machines'' that can process the jobs. The LPT algorithm works as follows:

# Order the jobs by descending order of their processing-time, such that the job with the longest processing time is first.
# Schedule each job in this sequence into a machine in which the current load (= total processing-time of scheduled jobs) is smallest.

Step 2 of the algorithm is essentially the [[List scheduling|list-scheduling]] (LS) algorithm. The difference is that LS loops over the jobs in an arbitrary order, while LPT pre-orders them by descending processing time.

LPT was first analyzed by [[Ronald Graham]] in the 1960s in the context of the [[identical-machines scheduling]] problem.<ref name="Graham19692">{{cite journal|last1=Graham|first1=R. L.|date=March 1969|title=Bounds on Multiprocessing Timing Anomalies|journal=SIAM Journal on Applied Mathematics|volume=17|issue=2|pages=416–429|citeseerx=10.1.1.90.8131|doi=10.1137/0117039|jstor=2099572|id={{NAID|30006801878}} {{ProQuest|917998761}}}}</ref> Later, it was applied to many other variants of the problem.

LPT can also be described in a more abstract way, as an algorithm for [[multiway number partitioning]].  The input is a set ''S'' of numbers, and a positive integer ''m''; the output is a partition of ''S'' into ''m'' subsets. LPT orders the input from largest to smallest, and puts each input in turn into the part with the smallest sum so far.

== Examples ==
If the input set is S = {4, 5, 6, 7, 8} and ''m'' = 2, then the resulting partition is {8, 5, 4}, {7, 6}. If ''m'' = 3, then the resulting 3-way partition is {8}, {7, 4}, {6, 5}.

== Properties ==
LPT might not find the optimal partition. For example, in the above instance the optimal partition {8,7}, {6,5,4}, where both sums are equal to 15. However, its suboptimality is bounded both in the worst case and in the average case; see [[Longest-processing-time-first scheduling#performance|Performance guarantees]] below.

The running time of LPT is dominated by the sorting, which takes O(''n'' log ''n'') time, where ''n'' is the number of inputs.
{{Anchor|performance}}

LPT is ''monotone'' in the sense that, if one of the input numbers increases, the objective function (the largest sum or the smallest sum of a subset in the output) weakly increases.<ref>{{Citation |last=Segal-Halevi |first=Erel |title=On Monotonicity of Number-Partitioning Algorithms |date=2021-10-17 |url=http://arxiv.org/abs/2110.08886 |access-date=2024-02-22 |arxiv=2110.08886}}</ref> This is in contrast to [[Multifit algorithm]].

== Performance guarantees: identical machines ==
When used for [[identical-machines scheduling]], LPT attains the following approximation ratios.

=== Worst-case maximum sum ===
In the worst case, the largest sum in the greedy partition is at most  <math>\frac{4}{3}</math> times the optimal (minimum) largest sum.<ref>{{Cite book|last=Xiao|first=Xin|title=Proceedings of the 2017 5th International Conference on Frontiers of Manufacturing Science and Measuring Technology (FMSMT 2017) |chapter=A Direct Proof of the 4/3 Bound of LPT Scheduling Rule |date=2017-04-01|chapter-url=https://www.atlantis-press.com/proceedings/fmsmt-17/25875520|language=en|publisher=Atlantis Press|pages=486–489|doi=10.2991/fmsmt-17.2017.102|isbn=978-94-6252-331-9|doi-access=free}}</ref>{{Efn|1='''Proof'''. Normalize the input items such that OPT=1. This implies that the sum of all items is at most m.

Partition the items into large (more than 2/3), medium (between 1/3 and 2/3), and small (less than 1/3). Let their numbers be nL, nM and nS. In each optimal partition, each part contains at most one large item, so nL ≤ m. Moreover, each optimal part cannot contain both a large and a medium item, or three medium items; so nM ≤ 2(m-nL).

The operation of the greedy algorithm can be partitioned into three phases:

1. Allocating the large items - each of which is put in a different bin. Since nL ≤ m, when this phase completes, each bin contains at most one item, so the max-sum is at most 1.
2. Allocating the medium items. The first m-nL ones are put in empty bins, and the next m-nL ones (if any) are added into the same bins. Since nM ≤ 2(m-nL), when this phase completes, each bin contains either one large item - with sum at most 1, or at most two medium items - with sum at most 4/3.
3. Allocating the small items. Each item is added into the bin with the smallest sum. The smallest sum is at most the average sum, which is at most 1. Hence, once a small item is added, the new sum becomes at most 4/3.}}

A more detailed analysis yields a factor of <math>\frac{4m-1}{3m} = \frac{4}{3}-\frac{1}{3 m}</math> times the optimal (minimum) largest sum.<ref name="Graham19692"/><ref name=":2">{{Cite book|last1=Coffman|first1=E. G.|last2=Sethi|first2=Ravi|title=Proceedings of the 1976 ACM SIGMETRICS conference on Computer performance modeling measurement and evaluation - SIGMETRICS '76 |chapter=A generalized bound on LPT sequencing |date=1976-03-29|chapter-url=https://doi.org/10.1145/800200.806205|location=New York, NY, USA|publisher=Association for Computing Machinery|pages=306–310|doi=10.1145/800200.806205|isbn=978-1-4503-7497-2|s2cid=16980306 }}</ref> (for example, when ''m'' =2 this ratio is <math>7/6\approx 1.167</math>).{{Efn|1='''Proof.''' The previous proof can be refined in two ways.

First, one can prove that, once all large and medium items are allocated, the sum in each bin is at most 1.

If there are at most m-nL medium items, then each large and medium item is placed in a separate bin, so the sum is clearly at most 1.
Otherwise, denote the first m-nL medium items by top-medium items, and the others (at most m-nL) by bottom-medium items.
Assume first that item #m is larger than 1/2. This means that the items #1,...,#m are all larger than 1/2, so each must be in a different optimal part. Each of the bottom-medium items (items #m+1,...#nM) must fit into an optimal part with exactly one of the items #1,...,#m . Let us call two items matchable if their sum is at most 1, so that they can fit into the same optimal part. By Hall's theorem, each subset of k bottom-medium items must be matchable to at least k of the items #1,...,#m. In particular, the item #m+1 must be matchable to item #m; items #m+1 and #m+2 must be matchable to item #m-1; and in general, item #m+k must be matchable to item #'m-k+1. LPT indeed puts item #m+k in the same bin as #'m-k+1, so the sum of each bin is at most 1.

Second, one can prove that, when allocating the small inputs, the sum of every new bin is at most 4/3-1/(3m). There are two cases:

1. If the current smallest sum is at most 1-1/(3m), then the new sum - after adding one small input - is at most 1-1/(3m)+1/3 = 4/3-1/(3m).

2. Otherwise, all sums are larger than 1-1/(3m), so the sum of the m-1 largest bins is larger than m-1-1/3+1/(3m) = m-(4/3-1/(3m)). Since the total sum of all inputs is at most m, the new sum must be less than 4/3-1/(3m).}}

The factor <math>\frac{4m-1}{3m} </math> is tight. Suppose there are <math>2 m+1</math> inputs (where ''m'' is even): <math>2 m-1,2 m-1, 2 m-2,2 m-2, \ldots, m+1,m+1, m,m, m</math>. Then the greedy algorithm returns:

* <math>2 m-1,m,m</math>
* <math>2 m-1,m</math>
* <math>2 m-2,m+1</math>
* <math>2 m-2,m+1</math>,
* ...
* <math>3 m/2,3 m/2-1</math>
* <math>3 m/2,3 m/2-1</math>

with a maximum of <math>4 m-1</math>, but the optimal partition is:

* <math>m,m,m</math>
* <math>2 m-1,m+1</math>
* <math>2 m-1,m+1</math>
* <math>2 m-2,m+2</math>
* <math>2 m-2,m+2</math>
* ...
* <math>3 m/2,3 m/2</math>

with a maximum of <math>3 m</math>.

==== Input consideration ====
An even more detailed analysis takes into account the number of inputs in the max-sum part.

# In each part of the greedy partition, the ''j''-th highest number is at most <math>OPT/j</math>''.<ref name=":1">{{Cite journal|last=Chen|first=Bo|date=1993-10-01|title=A note on LPT scheduling|url=https://dx.doi.org/10.1016/0167-6377%2893%2990024-B|journal=Operations Research Letters|language=en|volume=14|issue=3|pages=139–142|doi=10.1016/0167-6377(93)90024-B|issn=0167-6377}}</ref>''
# Suppose that, in the greedy part ''P'' with the max-sum, there are ''L'' inputs. Then, the approximation ratio of the greedy algorithm is <math>\frac{L+1}{L}-\frac{1}{L m} = 1 + \frac{1}{L} - \frac{1}{L m} </math>.<ref name=":2" /> It is tight for ''L≥''3 (For ''L''=3, we get the general factor <math>\frac{4}{3}-\frac{1}{3 m}</math>). ''Proof''.<ref name=":1" /> Denote the numbers in ''P'' by x<sub>1</sub>,...,''x''<sub>L</sub>. Before ''x''<sub>L</sub> was inserted into ''P'', its sum was smallest. Therefore, the ''average'' sum per part is at least the sum x<sub>1</sub>+...+''x''<sub>L-1</sub> ''+ x''<sub>L</sub>/''m''. The optimal max-sum must be at least the average sum. In contrast, the greedy sum is x<sub>1</sub>+...+''x''<sub>L-1</sub>+''x''<sub>L.</sub> So the difference is at most (1-1/''m'')''x<sub>L</sub>'', which by (1) is at most (1-1/''m'')*OPT/''L''. So the ratio is at most (1 + 1/''L'' - 1/''Lm'').
=== Worst-case minimum sum ===
In the worst case, the ''smallest'' sum in the returned partition is at least  <math>\frac{3}{4}</math> times the optimal (maximum) smallest sum.<ref name=":4">{{cite journal|last1=Deuermeyer|first1=Bryan L.|last2=Friesen|first2=Donald K.|last3=Langston|first3=Michael A.|date=June 1982|title=Scheduling to Maximize the Minimum Processor Finish Time in a Multiprocessor System|journal=SIAM Journal on Algebraic and Discrete Methods|volume=3|issue=2|pages=190–196|doi=10.1137/0603019}}</ref>

==== Proof ====
The proof is by contradiction. We consider a ''minimal counterexample'', that is, a counterexample with a smallest ''m'' and fewest input numbers. Denote the greedy partition by P<sub>1</sub>,...,P''<sub>m</sub>'', and the optimal partition by Q<sub>1</sub>,...,Q''<sub>m</sub>''. Some properties of a minimal counterexample are:

* The min-sum in the optimal partition is 4, and the min-sum in the greedy partition is less than 3 (this is just normalization - it is without loss of generality).
* The max-sum in the greedy partition is more than 4 (since the total sum in both partitions is the same, and it is at least 4''m'').
* If sum(P<sub>''i''</sub>)≥3 for some greedy bin P<sub>''i''</sub>, then P<sub>''i''</sub> is not dominated by any optimal bin Q<sub>''j''</sub>. ''Proof'': if P<sub>''i''</sub> is dominated by Q<sub>''j''</sub>, then we can construct a smaller counterexample by decreasing ''m'' to ''m''-1 and removing the items in P<sub>''i''</sub>. The min-sum in the greedy partition remains less than 3. In the optimal partition, the items in  P<sub>''i''</sub> can be replaced by their dominating items in Q<sub>''j''</sub>, so the min-sum remains at least 4.
* If sum(P<sub>''i''</sub>)≥3 for some greedy bin P<sub>''i''</sub>, then P<sub>''i''</sub> contains at least two numbers. ''Proof'': if P<sub>''i''</sub> contains only one number x, then it is dominated by the optimal bin Q<sub>''j''</sub> which contains x.givese some input ''x'' is at least 3, and the greedy algorithm puts it in some P''<sub>i</sub>''. Then, since there is a bundle with sum less than 3, the greedy algorithm will not put any other input in P''<sub>i</sub>'', contradicting the previous lemma.
* Every greedy bin P<sub>''i''</sub> contains at most one input weakly-larger than 3/2. ''Proof'': Let P<sub>''i''</sub> be the first greedy bin which is assigned two such inputs. Since inputs are assigned in descending order, P<sub>''i''</sub> ''is'' the first greedy bin assigned two inputs. This means that it must contain the smallest two inputs from among the largest ''m''+1 inputs. Moreover, since the sum of these two items is at least 3/2+3/2=3, P<sub>''i''</sub> is not assigned any other input. On the other hand, by the [[pigeonhole principle]], there must be some optimal bin Q<sub>''j''</sub> that contains some two inputs from among the largest ''m''+1 inputs; so P<sub>''i''</sub> is dominated by Q<sub>''j''</sub>.
*During the run of the greedy algorithm, the sum in every bin P<sub>''i''</sub> becomes at least 8/3 before the sum of any bin exceeds 4. ''Proof'': Let ''y'' be the first input added to some bin P<sub>''i''</sub>, which made its sum larger than 4. Before ''y'' was added, P<sub>''i''</sub> had the smallest sum, which by assumption was smaller than 8/3; this means that y>4/3. Let T denote the set of all inputs from the first one down to ''y''; all these inputs are larger than 4/3 too. Since P<sub>''i''</sub> was smaller than 8/3, it contained exactly one item x from T. So now P<sub>''i''</sub> contains exactly 2 items {x,y}, and remains with these 2 items until the algorithm ends. Let ''m'' be the number of items from the first one down to x. We now show a contradiction by counting the items in T in two ways.
**First, consider the ''n'' optimal bins. If any such bin contains an item at least as large as x, then it cannot contain any other item of T, since otherwise it dominates {x,y}. Moreover, any such bin cannot contain three items from T, since the sum of any two of them is larger than 8/3, which is larger than x; and the third one is at least y, so it dominates {x,y}. Therefore, the number of items in T is at most 1*''m'' + 2*(''n''-''m'') = 2''n''-''m''. 
**Now, consider the ''n'' greedy bins. When ''y'' is added to the bundle containing ''x'', it is the bundle with the smallest sum. Therefore, all elements of ''T'' that are smaller than x, must be in a greedy bin with at least one other item of T. The same is true for x and y. Therefore, the number of items in T is at least (m-1)+2*(n-m+1) = 2''n''-''m''+1 - contradiction.
**
*We can assume, without loss of generality, that all inputs are either smaller than 1/3, or at least 1. ''Proof'': Suppose some input ''x'' is in (1/3,1). We replace x with 1. This obviously does not decrease the optimal min-sum. We show that it does not change the greedy min-sum. We know that some greedy bundle P<sub>''i''</sub> has a final sum larger than 4. Before the last input was added into P<sub>''i''</sub>, its sum was smaller than 3; so P<sub>''i''</sub> became larger than 4 when some input larger than 1 was added to it. By the previous lemma, at that point the sum of all other greedy bundles was at least 8/3. The algorithm arrives at x afterwards. Once the algorithm adds x to some bin P<sub>''j''</sub>, the sum of P<sub>''j''</sub> becomes at least 8/3+1/3=3, so no more items are added into P<sub>''j''</sub>. So P<sub>''j''</sub> contains only one input with size in [1/3,1). Once x is replaced with 1, it is still inserted into P<sub>''j''</sub>, and its sum is still above 3. So the greedy min-sum does not change. 
*We can now partition the inputs into  ''small'' (less than 1/3) and ''large'' (at least 1). The set of small items in P<sub>''i''</sub> is denoted by S''<sub>i</sub>''. Note that, when the algorithm starts processing small items, the sum in all bundles is at least 8/3.
The proof that a minimal counterexample does not exist uses a ''weighting scheme''. Each input x is assigned a weight w(x) according to its size and greedy bundle P<sub>i</sub>:

* If x is a large item:
** If x is the single large item in P<sub>''i''</sub>, then w(x)=8/3.
** If P<sub>''i''</sub> contains exactly two items {x,y} and both of them are large, and x>y, and sum(P<sub>''i''</sub>)≥3, then w(x)=8/3.
** Otherwise, w(x)=4/3.
* If x is a small item:
** if sum(P<sub>''i''</sub>)≥3, then w(x) = 4x/(3 sum(S''<sub>i</sub>'')); so w(S''<sub>i</sub>'') = 4/3.
** if sum(P<sub>''i''</sub>)<3, then w(x) = 2x/(3 sum(S''<sub>i</sub>'')); so w(S''<sub>i</sub>'') = 2/3.
This weighting scheme has the following properties:

* If x≥2, then w(x)=8/3. ''Proof'': x is large. Suppose it is in P<sub>i</sub>. If P<sub>i</sub> contains another large item y, then x+y≥3 so there is no other item in P<sub>i</sub>. Moreover, x>y since there is at most one item larger than 3/2. So w(x)=8/3.
* If x<1/3, then w(x) > 2x. ''Proof'': x is small. Suppose it is in P<sub>i</sub>.
**If sum(P<sub>''i''</sub>)≥3 then, since sum(P<sub>''i''</sub>) was smaller than 3 before x was added to it, it is now smaller than 10/3. But when the algorithm started processing small items, sum(P<sub>''i''</sub>) was at least 8/3. This means that sum(S<sub>''i''</sub>) < 2/3, so w(x) = 4x/(3 sum(S''<sub>i</sub>'')) > 2x.
**If sum(P<sub>''i''</sub>)<3 then sum(S<sub>''i''</sub>) < 3-8/3=1/3, so w(x) = 2x/(3 sum(S''<sub>i</sub>'')) > 2x.
* The weight of every greedy bin P<sub>''i''</sub> is at most 4, and the weight of at least one greedy bin is at most 10/3. ''Proof'': 
**If all inputs in P<sub>''i''</sub> are large, then it contains either a single input with weight 8/3, two inputs with weights 8/3+4/3, or three inputs with weights 4/3+4/3+4/3.
**If some inputs in P<sub>''i''</sub> are small, then their total weight is at most 4/3. There are at most two large inputs, and their weights are either 8/3 or 4/3+4/3.
**Finally, the weight of the greedy bin with sum smaller than 3 is at most 8/3 (if it has only large inputs) or 10/3 (if it has some small inputs).
* The weight of every optimal bin Q<sub>''j''</sub> is at least 4. ''Proof'':
**If Q<sub>''j''</sub> contains only small items, then each of them satisfies w(x) > 2x, so w(Q<sub>''j''</sub>) > 2 sum(Q<sub>''j''</sub>) ≥ 8. 
**If Q<sub>''j''</sub> contains exactly one large item x, then it must contain some small items whose sum is at least 4-x and weight at least 8-2x. Then, either x<2 and the weight of small items is at least 8-4=4, or x in (2,3) and w(x)=8/3 and the weight of small items is at least 8-6=2. In both cases the total weight is at least 4.
**If Q<sub>''j''</sub> contains exactly two large items x>y, and x≥2, then there is at least 8/3+4/3=4. If x+y≤10/3, then the sum of small items must be at least 2/3, so the total weight is at least 4/3+4/3+2*2/3=4. Otherwise, x>5/3. So x was the first input in some greedy bin P<sub>''m''</sub>. Let z be the second input added into P<sub>''m''</sub>. If x+z≥3, then there are no more inputs in P<sub>''m''</sub>, so w(x)=8/3 and we are done. Otherwise, x+z<3. Let v be the smallest input in some greedy bin whose sum exceeds 4. Since x<8/3, z must have been processed before v, so z≥v. Consider now any small item t in Q<sub>''j''</sub>, and suppose it is in some greedy bin P<sub>''i''</sub>''.''
***If sum(P<sub>''i''</sub>)<3, then the fact that v was not put in P<sub>''i''</sub> implies that v > 4-sum(large-items-in-P<sub>''i''</sub>) > 1+sum(small-items-in-P<sub>''i''</sub>). Therefore, 1+sum(S<sub>''i''</sub>)+x < v+x ≤ z+x < 3 and sum(S<sub>''i''</sub>) < 2-x. This means that 2*sum(S<sub>''i''</sub>) < 4-2x ≤ 4-x-y ≤ sum(small-items-in-Q<sub>''j''</sub>). So w(t) = 2t/(3sum(S<sub>''i''</sub>)) > 4t/(3sum(small-items-in-Q<sub>''j''</sub>)). 
***If sum(P<sub>''i''</sub>)≥3, and sum(S<sub>''i''</sub>)≤1, then w(t)=4/3 and we are done. Since sum(P<sub>''i''</sub>) was less than 3 before t was added into it, sum(P<sub>''i''</sub>)<3+sum(S<sub>''i''</sub>)/2. The fact that v was not put in P<sub>''i''</sub> implies that v > 4-sum(large-items-in-P<sub>''i''</sub>) > 1+sum(small-items-in-P<sub>''i''</sub>)/2. Similariy to the previous paragraph, w(t) > 4t/(3sum(small-items-in-Q<sub>''j''</sub>)).  
***Therefore, the total weight of all small items in Q<sub>''j''</sub> is at least 4/3, so the total weight of Q<sub>''j''</sub> is at least 4/3+10/3>4. 
**If Q<sub>''j''</sub> contains exactly three or more large items, then its total weight is at least 4/3+4/3+4/3=4.
*The last two claims are contradictory, since the former implies that the weight of all inputs is at most 4''m''-2/3, and the latter implies that the weight of all inputs is at least 4''m.'' Therefore, a counterexample does not exist.

==== Upper bound on the ratio ====
A more sophisticated analysis shows that the ratio is at most <math>\frac{3 m-1}{4 m-2}</math> (for example, when ''m''=2 the ratio is 5/6).<ref>{{cite journal|last1=Csirik|first1=János|last2=Kellerer|first2=Hans|last3=Woeginger|first3=Gerhard|date=June 1992|title=The exact LPT-bound for maximizing the minimum completion time|journal=Operations Research Letters|volume=11|issue=5|pages=281–287|doi=10.1016/0167-6377(92)90004-M}}</ref><ref>{{cite journal|last1=Wu|first1=Bang Ye|date=December 2005|title=An analysis of the LPT algorithm for the max–min and the min–ratio partition problems|journal=Theoretical Computer Science|volume=349|issue=3|pages=407–419|doi=10.1016/j.tcs.2005.08.032|doi-access=free}}</ref>

==== Tightness and example ====
The above ratio is tight.<ref name=":4" />

Suppose there are 3''m''-1 inputs (where ''m'' is even). The first 2''m'' inputs are: 2''m''-1, 2''m''-1, 2''m''-2, 2''m''-2, ..., ''m'', ''m''. The last ''m''-1 inputs are all ''m''. Then the greedy algorithm returns:

* 2''m''-1, ''m'', ''m''
* 2''m''-1, ''m'', ''m''
* 2''m''-2, ''m+1'', ''m''
* 2''m''-2, ''m+1'', ''m''
* ...
* 3 m/2, 3 m/2-1, m
* 3 m/2, 3 m/2-1

with a minimum of 3''m''-1. But the optimal partition is:

* 2''m''-1, 2''m''-1
* 2''m''-2, ''m'', ''m''
* 2''m''-2, ''m'', ''m''
* 2''m''-3, ''m''+1, ''m''
* 2''m''-3, ''m''+1, ''m''
* ...
* 3 m/2, 3 m/2-2, ''m''
* 3 m/2, 3 m/2-2, ''m''
* 3 m/2-1, 3 m/2-1, ''m''

with a minimum of 4''m''-2.

==== Restricted LPT ====
There is a variant of LPT, called Restricted-LPT or RLPT,<ref>{{Cite journal|last=Walter|first=Rico|date=2013-01-01|title=Comparing the minimum completion times of two longest-first scheduling-heuristics|url=https://doi.org/10.1007/s10100-011-0217-4|journal=Central European Journal of Operations Research|language=en|volume=21|issue=1|pages=125–139|doi=10.1007/s10100-011-0217-4|s2cid=254144745 |issn=1613-9178}}</ref> in which the inputs are partitioned into subsets of size ''m'' called ''ranks'' (rank 1 contains the largest ''m'' inputs, rank 2 the next-largest ''m'' inputs, etc.). The inputs in each rank must be assigned to ''m'' different bins: rank 1 first, then rank 2, etc. The minimum sum in RLPT is at most the minimum sum at LPT. The approximation ratio of RLPT for maximizing the minimum sum is at most ''m''.

=== Average-case maximum sum ===
In the average case, if the input numbers are distributed uniformly in [0,1], then the largest sum in an LPT schedule satisfies the following properties:

* The expected largest sum for ''m''=2 machines is at least <math>\frac{n}{4}+\frac{1}{4n+4}</math>  and at most <math>\frac{n}{4}+\frac{e}{2n+2}</math>, where ''n'' is the number of inputs.<ref name=":3">{{Cite journal|last1=Coffman|first1=E. G.|last2=Frederickson|first2=G. N.|last3=Lueker|first3=G. S.|date=1984-05-01|title=A Note on Expected Makespans for Largest-First Sequences of Independent Tasks on Two Processors|url=https://pubsonline.informs.org/doi/abs/10.1287/moor.9.2.260|journal=Mathematics of Operations Research|volume=9|issue=2|pages=260–266|doi=10.1287/moor.9.2.260|issn=0364-765X}}</ref>
* The largest sum is at most <math>1 + O(\log{\log{n}}/n)</math> times the optimum [[almost surely]], and <math>1 + O(1/n)</math> in expectation, where <math>n</math> is the number of inputs.<ref>{{cite journal|last1=Frenk|first1=J.B.G.|last2=Kan|first2=A.H.G.Rinnooy|date=June 1986|title=The rate of convergence to optimality of the LPT rule|journal=Discrete Applied Mathematics|volume=14|issue=2|pages=187–197|doi=10.1016/0166-218X(86)90060-0|hdl-access=free|hdl=1765/11698}}</ref>
* The difference between the LPT largest sum and the optimal largest sum is at most <math>O(\log{n}/n)</math> almost surely (for uniform or [[Negative exponential distribution|negative exponential]] distributions), and at most <math>O(m^2/n)</math> in expectation (for uniform distribution). These results hold also for [[Uniform-machines scheduling|machines with different speeds]].<ref name=":5">{{Cite journal|last1=Frenk|first1=J. B. G.|last2=Rinnooy Kan|first2=A. H. G.|date=1987-05-01|title=The Asymptotic Optimality of the LPT Rule|url=https://pubsonline.informs.org/doi/abs/10.1287/moor.12.2.241|journal=Mathematics of Operations Research|volume=12|issue=2|pages=241–254|doi=10.1287/moor.12.2.241|s2cid=31770203 |issn=0364-765X}}</ref>

=== General objectives ===
Let ''C<sub>i</sub>'' (for ''i'' between 1 and ''m'') be the sum of subset ''i'' in a given partition. Instead of minimizing the objective function max(''C<sub>i</sub>''), one can minimize the objective function max(''f''(''C<sub>i</sub>'')), where ''f'' is any fixed function. Similarly, one can minimize the objective function sum(''f''(''C<sub>i</sub>'')). Alon, Azar, Woeginger and Yadid<ref name=":12">{{Cite journal|last1=Alon|first1=Noga|last2=Azar|first2=Yossi|last3=Woeginger|first3=Gerhard J.|last4=Yadid|first4=Tal|date=1998|title=Approximation schemes for scheduling on parallel machines|url=https://onlinelibrary.wiley.com/doi/abs/10.1002/%28SICI%291099-1425%28199806%291%3A1%3C55%3A%3AAID-JOS2%3E3.0.CO%3B2-J|journal=Journal of Scheduling|language=en|volume=1|issue=1|pages=55–66|doi=10.1002/(SICI)1099-1425(199806)1:1<55::AID-JOS2>3.0.CO;2-J|issn=1099-1425}}</ref> prove that, if ''f'' satisfies the following two conditions:

# A strong continuity condition called ''Condition F*'': for every ε>0 there exists δ>0 such that, if |''y''-''x''|<δ''x'', then |f(''y'')-f(''x'')|<ε''f''(''x'').
# [[Convex function|Convexity]].

Then the LPT rule has a finite approximation ratio for minimizing sum(''f''(''C<sub>i</sub>'')).

=== Performance with divisible item sizes ===
An important special case is that the item sizes form a ''divisible sequence'' (also called ''factored''). A special case of divisible item sizes occurs in memory allocation in computer systems, where the item sizes are all powers of 2. If the item sizes are divisible, and in addition, the largest item sizes divides the bin size, then LPT always finds a scheduling that minimizes the maximum size,<ref name=":6">{{Cite journal |last1=Coffman |first1=E. G |last2=Garey |first2=M. R |last3=Johnson |first3=D. S |date=1987-12-01 |title=Bin packing with divisible item sizes |url=https://dx.doi.org/10.1016/0885-064X%2887%2990009-4 |journal=Journal of Complexity |volume=3 |issue=4 |pages=406–428 |doi=10.1016/0885-064X(87)90009-4 |issn=0885-064X}}</ref>{{Rp|location=Thm.4}} and maximizes the minimum size.<ref name=":6" />{{Rp|location=Thm.5}} 

== Adaptations to other settings ==
Besides the simple case of identical-machines scheduling, LPT has been adapted to more general settings.

=== Uniform machines{{Anchor|uniform}} ===
In [[uniform-machines scheduling]], different machines may have different speeds. The LPT rule assigns each job to the machine on which its ''completion time'' will be earliest (that is, LPT may assign a job to a machine with a ''larger'' current load, if this machine is so fast that it would finish that job ''earlier'' than all other machines).<ref name=":0">{{Cite journal|last1=Gonzalez|first1=Teofilo|last2=Ibarra|first2=Oscar H.|last3=Sahni|first3=Sartaj|date=1977-03-01|title=Bounds for LPT Schedules on Uniform Processors|url=https://epubs.siam.org/doi/abs/10.1137/0206013|journal=SIAM Journal on Computing|volume=6|issue=1|pages=155–166|doi=10.1137/0206013|issn=0097-5397}}</ref>

* Gonzalez, Ibarra and Sahni<ref name=":0" />  show that the approximation ratio of LPT with ''m'' uniform machines is at most <math>2 m/(m+1)</math>. It is not tight, but there is an asymptotic lower bound of 1.5 when ''m'' approaches infinity.  For the special case of ''m''=2 machines, the approximation ratio is at most <math>(1+\sqrt{17})/4\approx 1.281</math> and it is tight.
*Mireault, Orlin and Vohra<ref>{{Cite journal|last1=Mireault|first1=Paul|last2=Orlin|first2=James B.|last3=Vohra|first3=Rakesh V.|date=1997-02-01|title=A Parametric Worst Case Analysis of the LPT Heuristic for Two Uniform Machines|url=https://pubsonline.informs.org/doi/abs/10.1287/opre.45.1.116|journal=Operations Research|volume=45|issue=1|pages=116–125|doi=10.1287/opre.45.1.116|issn=0030-364X}}</ref> study a setting with ''two'' machines, in which one machine is ''q'' times faster than the other. They compute the approximation ratio of LPT as a function of ''q''. When ''q''=1, their result coincides with the 7/6 factor known for identical machines.
*Koulamas and Kyparisis<ref>{{Cite journal|last1=Koulamas|first1=Christos|last2=Kyparisis|first2=George J.|date=2009-07-01|title=A modified LPT algorithm for the two uniform parallel machine makespan minimization problem|url=https://www.sciencedirect.com/science/article/pii/S0377221708001938|journal=European Journal of Operational Research|language=en|volume=196|issue=1|pages=61–68|doi=10.1016/j.ejor.2008.02.008|issn=0377-2217}}</ref> present a modification of LPT in which the three longest jobs are scheduled optimally, and the remaining jobs are scheduled based on the LPT rule. The approximation ratio for two machines is <math>\sqrt{1.5}\approx 1.2247</math> and it is tight.

=== Cardinality constraints ===
In the [[balanced partition problem]], there are constraints on the ''number'' of jobs that can be assigned to each machine. A simple constraint is that each machine can process at most ''c'' jobs. The LPT rule assigns each job to the machine with the smallest load from among those with fewer than ''c'' jobs. This rule is called ''modified LPT'' or ''MLPT''.

* Kellerer and Woeginger<ref>{{Cite journal|last1=Kellerer|first1=Hans|last2=Woeginger|first2=Gerhard|date=1993-09-07|title=A tight bound for 3-partitioning|journal=Discrete Applied Mathematics|language=en|volume=45|issue=3|pages=249–259|doi=10.1016/0166-218X(93)90013-E|issn=0166-218X|doi-access=free}}</ref> study a variant in which there are at most 3*''m'' jobs, and each machine must contain at most 3 jobs (this can be seen as a generalization of [[3-partition problem]]). They show that MLPT attains at most <math>(4 m-1)/(3 m)</math> of the ''minimum largest'' sum, which the same approximation ratio that LPT attains for the unconstrained problem. The bound is tight for MLPT. It is conjectured<ref name=":42">{{Cite journal|last1=Babel|first1=Luitpold|last2=Kellerer|first2=Hans|last3=Kotov|first3=Vladimir|date=1998-02-01|title=The m-partitioning problem|url=https://doi.org/10.1007/BF01193837|journal=Mathematical Methods of Operations Research|language=en|volume=47|issue=1|pages=59–82|doi=10.1007/BF01193837|s2cid=5594197 |issn=1432-5217}}</ref> that MLPT has the same approximation ratio for more general cardinality constraints (''c''>3). Currently, it is known that the approximation ratio of MLPT for general ''c''>3 is at most 2.<ref name=":9">{{Cite journal|last1=Dell'Amico|first1=Mauro|last2=Martello|first2=Silvano|date=2001|title=Bounds for the cardinality constrained P∥Cmax problem|url=https://onlinelibrary.wiley.com/doi/abs/10.1002/jos.68|journal=Journal of Scheduling|language=en|volume=4|issue=3|pages=123–138|doi=10.1002/jos.68|issn=1099-1425}}</ref>
* Chen, He and Lin<ref>{{Cite journal|last1=Chen|first1=Shi Ping|last2=He|first2=Yong|last3=Lin|first3=Guohui|date=2002-03-01|title=3-Partitioning Problems for Maximizing the Minimum Load|url=https://doi.org/10.1023/A:1013370208101|journal=Journal of Combinatorial Optimization|language=en|volume=6|issue=1|pages=67–80|doi=10.1023/A:1013370208101|s2cid=9053629 |issn=1573-2886}}</ref> show that, for the same problem, MLPT attains at least <math>(3 m-1)/(4 m-2)</math> of the ''maximum smallest'' sum, which is again the same ratio that LPT attains for the unconstrained problem.
Another constraint is that the number of jobs on all machines should be <math>n/m</math> rounded either up or down. In an adaptation of LPT called ''restricted LPT'' or ''RLPT'', inputs are assigned in pairs - one to each machine (for ''m''=2 machines).<ref name=":3" /> The resulting partition is balanced by design.

* Coffman, Frederickson and Lueker<ref name=":3" /> show that the expected largest sum of RLPT when inputs are uniformly-distributed random variables is exactly <math>\frac{n}{4}+\frac{1}{2n+2}</math>. The expected difference between the largest and smallest sum is <math>\Theta(1/n)</math>.<ref name=":52">{{Cite journal|last=Tsai|first=Li-Hui|date=1992-02-01|title=Asymptotic Analysis of an Algorithm for Balanced Parallel Processor Scheduling|url=https://epubs.siam.org/doi/abs/10.1137/0221007|journal=SIAM Journal on Computing|volume=21|issue=1|pages=59–64|doi=10.1137/0221007|issn=0097-5397}}</ref>

=== Kernel constraints - non-simultaneous availability ===
In the ''kernel partitioning problem'', there are some ''m'' pre-specified jobs called kernels, and each kernel must be scheduled to a unique machine. An equivalent problem is scheduling when machines are available in different times: each machine ''i'' becomes available at some time ''t<sub>i</sub> ≥'' 0 (the time ''t<sub>i</sub>'' can be thought of as the length of the kernel job).

A simple heuristic algorithm, called SLPT,<ref>{{Cite journal|last1=Chen|first1=S. -P.|last2=He|first2=Y.|last3=Yao|first3=E. -Y.|date=1996-09-01|title=Three-partitioning containing kernels: Complexity and heuristic|url=https://doi.org/10.1007/BF02247409|journal=Computing|language=en|volume=57|issue=3|pages=255–271|doi=10.1007/BF02247409|s2cid=21935917 |issn=1436-5057}}</ref> assigns each kernel to a different subset, and then runs the [[LPT algorithm]].

* Lee<ref>{{Cite journal|last=Lee|first=Chung-Yee|date=1991-01-07|title=Parallel machines scheduling with nonsimultaneous machine available time|journal=Discrete Applied Mathematics|language=en|volume=30|issue=1|pages=53–61|doi=10.1016/0166-218X(91)90013-M|issn=0166-218X|doi-access=free}}</ref> proves that this heuristic has a tight approximation ratio <math>\frac{3 m-1}{2 m}</math> for the minimum largest sum. He then suggests running, in the second step, a modified version of LPT, and proves that it attains an approximation ratio <math>\frac{4}{3}</math> .
* Lin, Yao and He<ref>{{Cite journal|last1=Lin|first1=Guo-Hui|last2=Yao|first2=En-Yu|last3=He|first3=Yong|date=1998-03-01|title=Parallel machine scheduling to maximize the minimum load with nonsimultaneous machine available times|url=https://www.sciencedirect.com/science/article/pii/S0167637797000539|journal=Operations Research Letters|language=en|volume=22|issue=2|pages=75–81|doi=10.1016/S0167-6377(97)00053-9|issn=0167-6377}}</ref> prove that this heuristic has a tight approximation ratio <math>\frac{2 m-1}{3 m-2}</math> for the maximum smallest sum.
*Shen, Wang and Wang<ref>{{Cite journal|last1=Shen|first1=Lixin|last2=Wang|first2=Dan|last3=Wang|first3=Xiao-Yuan|date=2013-04-01|title=Parallel-machine scheduling with non-simultaneous machine available time|url=https://www.sciencedirect.com/science/article/pii/S0307904X12005847|journal=Applied Mathematical Modelling|language=en|volume=37|issue=7|pages=5227–5232|doi=10.1016/j.apm.2012.09.053|issn=0307-904X}}</ref> study different objective functions for this setting, and present polynomial-time algorithms.

=== Online settings ===
Often, the inputs come [[Online algorithm|online]], and their sizes becomes known only when they arrive. In this case, it is not possible to sort them in advance. [[List scheduling]] is a similar algorithm that takes a list in any order, not necessarily sorted. Its approximation ratio is <math>\frac{2 m-1}{m} = 2-\frac{1}{m}</math>.

A more sophisticated adaptation of LPT to an online setting attains an approximation ratio of 3/2.<ref>{{cite journal|last1=Chen|first1=Bo|last2=Vestjens|first2=Arjen P. A.|date=1 November 1997|title=Scheduling on identical machines: How good is LPT in an on-line setting?|journal=Operations Research Letters|volume=21|issue=4|pages=165–169|doi=10.1016/S0167-6377(97)00040-0|url=https://pure.tue.nl/ws/files/1556464/459560.pdf }}</ref>

== Implementations ==

* '''Python''': there is an implementation of LPT ("greedy") [https://github.com/fuglede/numberpartitioning/blob/master/src/numberpartitioning/greedy.py in the numberpartitioning package], as well as [https://github.com/erelsgl/prtpy/blob/main/prtpy/partitioning/greedy.py in the prtpy package].

== See also ==
* [[Greedy number partitioning]] - generalizations and extensions of LPT for the problem of multiway number partitioning.

== Notes ==
{{Notelist}}

== References ==
{{reflist}}

[[Category:Scheduling algorithms]]
[[Category:Number partitioning]]