Greedy and Local Search Advanced Algorithms Nanjing University, - - PowerPoint PPT Presentation

Approximation Algorithms

Greedy and Local Search

Advanced Algorithms Nanjing University, Fall 2018

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4 𝑉

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4 𝑉

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4 𝑉

• This problem is NP-hard!
• Decision version is one of Karp’s

21 NP-complete problems.

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4 𝑉

• This problem is NP-hard!
• Decision version is one of Karp’s

21 NP-complete problems.

• Can we find good enough

solutions efficiently?

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4 𝑉

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. 𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. 𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

OPT(𝐽): value of minimum set cover of instance 𝐽 SOL(𝐽): value of set cover returned by GreedyCover on instance 𝐽

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. 𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

OPT(𝐽): value of minimum set cover of instance 𝐽 SOL(𝐽): value of set cover returned by GreedyCover on instance 𝐽

GreedyCover has approximation ratio 𝛽 if ∀ instance 𝐽, SOL(𝐽) OPT(𝐽) ≤ 𝛽

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. 𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

OPT(𝐽): value of minimum set cover of instance 𝐽 SOL(𝐽): value of set cover returned by GreedyCover on instance 𝐽

GreedyCover has approximation ratio 𝛽 if ∀ instance 𝐽, SOL(𝐽) OPT(𝐽) ≤ 𝛽

For minimization problems, we want Τ SOL(𝐽) OPT 𝐽 ≤ 𝛽 where 𝛽 ≥ 1 For maximization problems, we want Τ SOL(𝐽) OPT 𝐽 ≥ 𝛽 where 𝛽 ≤ 1

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. Set 𝑞𝑠𝑗𝑑𝑓 𝑓 =

1 |𝑇𝑗∩𝑉| for all 𝑓 ∈ 𝑇𝑗 ∩ 𝑉.

𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

• Initially, there must exist some subset that covers its elements with price at most

Τ OPT(𝐽) 𝑜.

• Therefore, price of elements in the first subset covered by GreedyCover is at most

Τ OPT(𝐽) 𝑜.

• After 𝑙 elements in 𝑢 subsets are covered by GreedyCover, there must exist some subset such

that the price of its uncovered elements is at most Τ OPT(𝐽𝑢) (𝑜 − 𝑙) ≤ Τ OPT(𝐽) (𝑜 − 𝑙).

• In general, GreedyCover pays at most

Τ OPT(𝐽) (𝑜 − 𝑙 + 1) to cover the 𝑙th chosen element.

𝐷 = ෍

𝑓∈𝑉

𝑞𝑠𝑗𝑑𝑓(𝑓)

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

𝑞𝑠𝑗𝑑𝑓 = 1 𝑞𝑠𝑗𝑑𝑓 = 1

𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

𝑞𝑠𝑗𝑑𝑓 = 1 𝑞𝑠𝑗𝑑𝑓 = 1

Enumerate 𝑓𝑙 in the order in which they are covered by GreedyCover: 𝑞𝑠𝑗𝑑𝑓 𝑓𝑙 ≤ OPT 𝐽 𝑜 − 𝑙 + 1

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. Set 𝑞𝑠𝑗𝑑𝑓 𝑓 =

1 |𝑇𝑗∩𝑉| for all 𝑓 ∈ 𝑇𝑗 ∩ 𝑉.

𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

𝑞𝑠𝑗𝑑𝑓 = 1 𝑞𝑠𝑗𝑑𝑓 = 1

Enumerate 𝑓𝑙 in the order in which they are covered by GreedyCover: 𝑞𝑠𝑗𝑑𝑓 𝑓𝑙 ≤ OPT 𝐽 𝑜 − 𝑙 + 1

𝐷 = ෍

𝑓∈𝑉

𝑞𝑠𝑗𝑑𝑓(𝑓) ≤ ෍

𝑙=1 𝑜

OPT 𝐽 𝑜 − 𝑙 + 1 = 𝐼𝑜 ⋅ OPT(𝐽)

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. Set 𝑞𝑠𝑗𝑑𝑓 𝑓 =

1 |𝑇𝑗∩𝑉| for all 𝑓 ∈ 𝑇𝑗 ∩ 𝑉.

𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

𝑞𝑠𝑗𝑑𝑓 = 1 𝑞𝑠𝑗𝑑𝑓 = 1

• GreedyCover has approximation ratio 𝐼𝑜 ≈ ln 𝑜 + 𝑃(1).

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. Set 𝑞𝑠𝑗𝑑𝑓 𝑓 =

1 |𝑇𝑗∩𝑉| for all 𝑓 ∈ 𝑇𝑗 ∩ 𝑉.

𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3 𝑞𝑠𝑗𝑑𝑓 = Τ 1 3

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

𝑞𝑠𝑗𝑑𝑓 = 1 𝑞𝑠𝑗𝑑𝑓 = 1

• GreedyCover has approximation ratio 𝐼𝑜 ≈ ln 𝑜 + 𝑃(1).
• [Lund, Yannakakis 1994; Feige 1998] There is no poly-time 1 − 𝑝 1

ln(𝑜)

• approx. algorithm unless NP = quasi-poly-time.
• [Ras, Safra 1997] For some constant 𝑑, there is no poly-time 𝑑 ln(𝑜) approx.

algorithm unless NP = P.

• [Dinur, Steuer 2014] There is no poly-time 1 − 𝑝 1

ln(𝑜) approx. algorithm unless NP = P.

Set Cover Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

GreedyCover： Set 𝐷 = ∅. While 𝑉 ≠ ∅ do: Add 𝑗 with largest |𝑇𝑗 ∩ 𝑉| to 𝐷. Set 𝑞𝑠𝑗𝑑𝑓 𝑓 =

1 |𝑇𝑗∩𝑉| for all 𝑓 ∈ 𝑇𝑗 ∩ 𝑉.

𝑉 = 𝑉 − 𝑇𝑗. Return 𝐷.

Set Cover

Instance: Given a collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉, find the smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4 𝑉

• This problem is NP-hard.
• We have 𝑃(ln 𝑜) approx. alg.
• Frequency of an element:

# of subsets the element is in.

• Use 𝑔

𝐽 to denote the frequency

• f the most frequent element in

instance 𝐽.

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

Since every 𝑓 ∈ 𝑁 must consume a subset to cover ∀𝐷, ∀𝑁: 𝑁 ≤ |𝐷|

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

Since every 𝑓 ∈ 𝑁 must consume a subset to cover ∀𝐷, ∀𝑁: 𝑁 ≤ |𝐷| As a result, ∀𝑁: 𝑁 ≤ OPTprimal = min |𝐷|

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

Since every 𝑓 ∈ 𝑁 must consume a subset to cover ∀𝐷, ∀𝑁: 𝑁 ≤ |𝐷| As a result, ∀𝑁: 𝑁 ≤ OPTprimal = min |𝐷| GreedyMatchingCover： Find arbitrary maximal 𝑁 for the dual problem. Return 𝐷 = {𝑗: 𝑇𝑗 ∩ 𝑁 ≠ ∅}.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

Since every 𝑓 ∈ 𝑁 must consume a subset to cover ∀𝐷, ∀𝑁: 𝑁 ≤ |𝐷| As a result, ∀𝑁: 𝑁 ≤ OPTprimal = min |𝐷| GreedyMatchingCover： Find arbitrary maximal 𝑁 for the dual problem. Return 𝐷 = {𝑗: 𝑇𝑗 ∩ 𝑁 ≠ ∅}. Since 𝑁 is maximal, returned 𝐷 must be a cover.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

Since every 𝑓 ∈ 𝑁 must consume a subset to cover ∀𝐷, ∀𝑁: 𝑁 ≤ |𝐷| As a result, ∀𝑁: 𝑁 ≤ OPTprimal = min |𝐷| GreedyMatchingCover： Find arbitrary maximal 𝑁 for the dual problem. Return 𝐷 = {𝑗: 𝑇𝑗 ∩ 𝑁 ≠ ∅}. Since 𝑁 is maximal, returned 𝐷 must be a cover. 𝐷 ≤ 𝑔

𝐽 ⋅ 𝑁 ≤ 𝑔 𝐽 ⋅ OPTprimal

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛].

Since every 𝑓 ∈ 𝑁 must consume a subset to cover ∀𝐷, ∀𝑁: 𝑁 ≤ |𝐷| As a result, ∀𝑁: 𝑁 ≤ OPTprimal = min |𝐷| GreedyMatchingCover： Find arbitrary maximal 𝑁 for the dual problem. Return 𝐷 = {𝑗: 𝑇𝑗 ∩ 𝑁 ≠ ∅}. Since 𝑁 is maximal, returned 𝐷 must be a cover. 𝐷 ≤ 𝑔

𝐽 ⋅ 𝑁 ≤ 𝑔 𝐽 ⋅ OPTprimal

GreedyMatchingCover has approximation ratio 𝑔

𝐽.

𝑇2 𝑇3 𝑓1 𝑓2 𝑓3 𝑓4 𝑓5 𝑇1 𝑇4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Set Cover: Find smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

What if the frequency of each element is exactly 2?

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Set Cover: Find smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

What if the frequency of each element is exactly 2?

𝑤1 𝑤2 𝑤3 𝑤4 𝑓1 𝑓2 𝑓3 𝑓4 𝑤2 𝑤3 𝑓1 𝑓2 𝑓3 𝑓4 𝑤1 𝑤4 incidence graph

Vertex Cover

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Set Cover: Find smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

What if the frequency of each element is exactly 2?

𝑤1 𝑤2 𝑤3 𝑤4 𝑓1 𝑓2 𝑓3 𝑓4 𝑤2 𝑤3 𝑓1 𝑓2 𝑓3 𝑓4 𝑤1 𝑤4 incidence graph

Instance: An undirected simple graph 𝐻 = (𝑊, 𝐹). Vertex Cover: Find smallest 𝐷 ⊆ 𝑊 s.t. ∀𝑓 ∈ 𝐹: 𝑓 ∩ 𝐷 ≠ ∅.

Vertex Cover

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Set Cover: Find smallest 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉.

What if the frequency of each element is exactly 2?

𝑤1 𝑤2 𝑤3 𝑤4 𝑓1 𝑓2 𝑓3 𝑓4 𝑤2 𝑤3 𝑓1 𝑓2 𝑓3 𝑓4 𝑤1 𝑤4 incidence graph

Instance: An undirected simple graph 𝐻 = (𝑊, 𝐹). Vertex Cover: Find smallest 𝐷 ⊆ 𝑊 s.t. ∀𝑓 ∈ 𝐹: 𝑓 ∩ 𝐷 ≠ ∅.

• Vertex cover is also NP-hard.
• Decision version is one of Karp’s 21 NP-complete problems.

𝑤2 𝑤3 𝑓1 𝑓2 𝑓3 𝑓4 𝑤1 𝑤4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛]. Instance: An undirected simple graph 𝐻 = (𝑊, 𝐹). Primal: Find 𝐷 ⊆ 𝑊 s.t. ∀𝑓 ∈ 𝐹: 𝑓 ∩ 𝐷 ≠ ∅. (Vertex Cover) Dual: Find 𝑁 ⊆ 𝐹 s.t. ∀𝑤 ∈ 𝑊: 𝑤 ∩ 𝑁 ≤ 1. (Matching)

The frequency of each element is exactly 2

𝑤2 𝑤3 𝑓1 𝑓2 𝑓3 𝑓4 𝑤1 𝑤4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛]. Instance: An undirected simple graph 𝐻 = (𝑊, 𝐹). Primal: Find 𝐷 ⊆ 𝑊 s.t. ∀𝑓 ∈ 𝐹: 𝑓 ∩ 𝐷 ≠ ∅. (Vertex Cover) Dual: Find 𝑁 ⊆ 𝐹 s.t. ∀𝑤 ∈ 𝑊: 𝑤 ∩ 𝑁 ≤ 1. (Matching)

The frequency of each element is exactly 2

GreedyMatchingCover： Find arbitrary maximal matching 𝑁 of the input graph. Return 𝐷 = {𝑤: 𝑤 ∈ 𝑊 and 𝑤 ∩ 𝑁 ≠ ∅}.

A 2-approximation algorithm for the vertex cover problem

𝑤2 𝑤3 𝑓1 𝑓2 𝑓3 𝑓4 𝑤1 𝑤4

Instance: A collection of subsets 𝑇1, 𝑇2, ⋯ , 𝑇𝑛 ⊆ 𝑉. Primal: Find 𝐷 ⊆ [𝑛] such that ڂ𝑗∈𝐷 𝑇𝑗 = 𝑉. Dual: Find 𝑁 ⊆ 𝑉 such that 𝑇𝑗 ∩ 𝑁 ≤ 1 for all 𝑗 ∈ [𝑛]. Instance: An undirected simple graph 𝐻 = (𝑊, 𝐹). Primal: Find 𝐷 ⊆ 𝑊 s.t. ∀𝑓 ∈ 𝐹: 𝑓 ∩ 𝐷 ≠ ∅. (Vertex Cover) Dual: Find 𝑁 ⊆ 𝐹 s.t. ∀𝑤 ∈ 𝑊: 𝑤 ∩ 𝑁 ≤ 1. (Matching)

The frequency of each element is exactly 2

GreedyMatchingCover： Find arbitrary maximal matching 𝑁 of the input graph. Return 𝐷 = {𝑤: 𝑤 ∈ 𝑊 and 𝑤 ∩ 𝑁 ≠ ∅}.

A 2-approximation algorithm for the vertex cover problem

• There is no poly-time <1.36-approx. alg. unless P = NP.
• Assuming the unique game conjecture, there is no poly-time (2-ε)-approx. alg.

Scheduling

𝑛 identical machines

Scheduling

𝑛 identical machines 𝑜 jobs processing time 𝑞𝑘 6 1 4 2 3 3 5 2 4 3

Scheduling

𝑛 machines 𝑜 jobs each with processing time 𝑞𝑘

Scheduling

Completion time:

(of machine 𝑗)

𝐷𝑗 = ෍

𝑘: jobs assigned to machine 𝑗

𝑞𝑘

𝑛 machines 𝑜 jobs each with processing time 𝑞𝑘

Scheduling

Completion time:

(of machine 𝑗)

Makespan: 𝐷𝑗 = ෍

𝑘: jobs assigned to machine 𝑗

𝑞𝑘

𝐷max = max

𝑗

𝐷𝑗

𝑛 machines 𝑜 jobs each with processing time 𝑞𝑘 makespan

Instance: 𝑜 jobs 𝑘 = 1,2, ⋯ , 𝑜 each with processing time 𝑞𝑘 ∈ ℤ+. Problem: Find a schedule assigning 𝑜 jobs to 𝑛 identical machines so as the minimize the makespan.

Instance: 𝑜 jobs 𝑘 = 1,2, ⋯ , 𝑜 each with processing time 𝑞𝑘 ∈ ℤ+. Problem: Find a schedule assigning 𝑜 jobs to 𝑛 identical machines so as the minimize the makespan.

• “minimum makespan on identical machines”
• Scheduling problem has many variations:

machines could be different, jobs could have release-dates/deadlines, etc…

Instance: 𝑜 jobs 𝑘 = 1,2, ⋯ , 𝑜 each with processing time 𝑞𝑘 ∈ ℤ+. Problem: Find a schedule assigning 𝑜 jobs to 𝑛 identical machines so as the minimize the makespan.

• “minimum makespan on identical machines”
• Scheduling problem has many variations:

machines could be different, jobs could have release-dates/deadlines, etc… If 𝑛 = 2, the scheduling problem can be used to solve the partition problem!

Instance: 𝑜 positive integers 𝑦1, 𝑦2, ⋯ , 𝑦𝑜 ∈ ℤ+. Problem: Determine whether there exists a partition of {1,2, ⋯ , 𝑜} into two sets 𝐵 and 𝐶 such that σ𝑗∈𝐵 𝑦𝑗 = σ𝑗∈𝐶 𝑦𝑗.

Instance: 𝑜 jobs 𝑘 = 1,2, ⋯ , 𝑜 each with processing time 𝑞𝑘 ∈ ℤ+. Problem: Find a schedule assigning 𝑜 jobs to 𝑛 identical machines so as the minimize the makespan.

• “minimum makespan on identical machines”
• Scheduling problem has many variations:

machines could be different, jobs could have release-dates/deadlines, etc… If 𝑛 = 2, the scheduling problem can be used to solve the partition problem!

Instance: 𝑜 positive integers 𝑦1, 𝑦2, ⋯ , 𝑦𝑜 ∈ ℤ+. Problem: Determine whether there exists a partition of {1,2, ⋯ , 𝑜} into two sets 𝐵 and 𝐶 such that σ𝑗∈𝐵 𝑦𝑗 = σ𝑗∈𝐶 𝑦𝑗.

• The partition problem is one of Karp’s 21 NP-complete problems.
• Thus the considered scheduling problem is NP-hard.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Graham’s Li List Algorithm for Scheduling

𝑛 identical machines 𝑜 jobs each with processing time 𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio?

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Assume machine 𝑙 finishes last in the schedule, and last job on it is 𝑚.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Assume machine 𝑙 finishes last in the schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Assume machine 𝑙 finishes last in the schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚

𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Assume machine 𝑙 finishes last in the schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚

𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT

𝐷𝑙 − 𝑞𝑚 ≤

1 𝑛 σ𝑘≠𝑚 𝑞𝑘 ≤ 1 𝑛 σ𝑘 𝑞𝑘 ≤ OPT

since machine 𝑙 is least loaded when scheduling job 𝑚

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. What about the approximation ratio? OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Assume machine 𝑙 finishes last in the schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚

𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT

𝐷𝑙 − 𝑞𝑚 ≤

1 𝑛 σ𝑘≠𝑚 𝑞𝑘 ≤ 1 𝑛 σ𝑘 𝑞𝑘 ≤ OPT

since machine 𝑙 is least loaded when scheduling job 𝑚

≤ 2 ⋅ OPT

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Algorithm List finishes within poly-time. Algorithm List has approximation ratio 2. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT ≤ 2 ⋅ OPT

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Algorithm List finishes within poly-time. Algorithm List has approximation ratio 2. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT ≤ 2 ⋅ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 = 1 𝑛 ෍

𝑘

𝑞𝑘 − 𝑞𝑚 𝑛

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Algorithm List finishes within poly-time. Algorithm List has approximation ratio 2. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT ≤ 2 ⋅ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 = 1 𝑛 ෍

𝑘

𝑞𝑘 − 𝑞𝑚 𝑛 ≤ 2 − 1 𝑛 ⋅ OPT

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Algorithm List finishes within poly-time. Algorithm List has approximation ratio 2. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT ≤ 2 ⋅ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 = 1 𝑛 ෍

𝑘

𝑞𝑘 − 𝑞𝑚 𝑛 ≤ 2 − 1 𝑛 ⋅ OPT Algorithm List has approximation ratio 2 − Τ 1 𝑛.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Algorithm List finishes within poly-time. Algorithm List has approximation ratio 2. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT ≤ 2 ⋅ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 = 1 𝑛 ෍

𝑘

𝑞𝑘 − 𝑞𝑚 𝑛 ≤ 2 − 1 𝑛 ⋅ OPT Algorithm List has approximation ratio 2 − Τ 1 𝑛.

This bound is tight in the worst case. [Almost tight example: 𝑛2 unit jobs followed by a length 𝑛 job. List generates makespan of 2𝑛 while OPT = 𝑛 + 1.]

Local Search for Scheduling

Start with an arbitrary solution: Keep making improvements by locally adjusting the solution, until no further improvement can be made (local optimum)

Local Search for Scheduling

Start with an arbitrary solution: Keep making improvements by locally adjusting the solution, until no further improvement can be made (local optimum)

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

Local Search for Scheduling

Start with an arbitrary solution: Keep making improvements by locally adjusting the solution, until no further improvement can be made (local optimum)

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

Local Search for Scheduling

Start with an arbitrary solution: Keep making improvements by locally adjusting the solution, until no further improvement can be made (local optimum)

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!)

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 = 1 𝑛 ෍

𝑘

𝑞𝑘 − 𝑞𝑚 𝑛

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗.

This algorithm finishes within poly-time. (No job is transferred twice!) The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. OPT ≥ max

𝑘

𝑞𝑘 𝑛 ⋅ OPT ≥ ෍

𝑘

𝑞𝑘 Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝑞𝑚 ≤ max

𝑘

𝑞𝑘 ≤ OPT 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘≠𝑚

𝑞𝑘 = 1 𝑛 ෍

𝑘

𝑞𝑘 − 𝑞𝑚 𝑛 ≤ 2 − 1 𝑛 ⋅ OPT

(2 − Τ 1 𝑛)

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗. List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗. List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine. LocalSearch finds a schedule with makespan 𝐷max ≤ 2 − 1

𝑛 ⋅ OPT

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗. List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine. LocalSearch finds a schedule with makespan 𝐷max ≤ 2 − 1

𝑛 ⋅ OPT

The schedule returned by List must be a local optimum!

LocalSearch： Start with an arbitrary schedule. Repeat until no job can be reassigned (i.e., local optimum reached): Let 𝑚 be a job that finished last. If exists machine 𝑗 s.t. assigning job 𝑚 to 𝑗 allows 𝑚 finish earlier: Transfer job 𝑚 to earliest such 𝑗. List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine. LocalSearch finds a schedule with makespan 𝐷max ≤ 2 − 1

𝑛 ⋅ OPT

The schedule returned by List must be a local optimum! List will find a schedule with makespan 𝐷max ≤ 2 − 1 𝑛 ⋅ OPT

𝑛 identical machines 𝑜 jobs

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

𝑛 identical machines 𝑜 jobs

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Longest Processing Time (L (LPT)

𝑛 identical machines 𝑜 jobs

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT W.l.o.g.: • # of jobs > # of machines (i.e., 𝑜 > 𝑛)

• makespan is achieved by some job bigger than 𝑛 (i.e., 𝑚 > 𝑛)

Otherwise, LPT returns an optimal solution already!

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT W.l.o.g.: • # of jobs > # of machines (i.e., 𝑜 > 𝑛)

• makespan is achieved by some job bigger than 𝑛 (i.e., 𝑚 > 𝑛)

Otherwise, LPT returns an optimal solution already! 𝑞𝑛 + 𝑞𝑛+1 ≤ OPT

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT W.l.o.g.: • # of jobs > # of machines (i.e., 𝑜 > 𝑛)

• makespan is achieved by some job bigger than 𝑛 (i.e., 𝑚 > 𝑛)

Otherwise, LPT returns an optimal solution already! 𝑞𝑛 + 𝑞𝑛+1 ≤ OPT 𝑞𝑚 ≤ 𝑞𝑛+1

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT W.l.o.g.: • # of jobs > # of machines (i.e., 𝑜 > 𝑛)

• makespan is achieved by some job bigger than 𝑛 (i.e., 𝑚 > 𝑛)

Otherwise, LPT returns an optimal solution already! 𝑞𝑛 + 𝑞𝑛+1 ≤ OPT 𝑞𝑚 ≤ 𝑞𝑛+1 𝑞𝑚 ≤ 𝑞𝑛+1 ≤ 1 2 𝑞𝑛 + 𝑞𝑛+1 ≤ OPT 2

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

This algorithm finishes within poly-time. The approximation ratio of this algorithm?

Assume machine 𝑙 finishes last in final schedule, and last job on it is 𝑚. Makespan 𝐷max = 𝐷𝑙 = 𝐷𝑙 − 𝑞𝑚 + 𝑞𝑚 𝐷𝑙 − 𝑞𝑚 ≤ 1 𝑛 ෍

𝑘

𝑞𝑘 ≤ OPT W.l.o.g.: • # of jobs > # of machines (i.e., 𝑜 > 𝑛)

• makespan is achieved by some job bigger than 𝑛 (i.e., 𝑚 > 𝑛)

Otherwise, LPT returns an optimal solution already! 𝑞𝑛 + 𝑞𝑛+1 ≤ OPT 𝑞𝑚 ≤ 𝑞𝑛+1 𝑞𝑚 ≤ 𝑞𝑛+1 ≤ 1 2 𝑞𝑛 + 𝑞𝑛+1 ≤ OPT 2 ≤ 3 2 ⋅ OPT

LongestProcessingTime (LPT)： Sort jobs so that 𝑞1 ≥ 𝑞2 ≥ ⋯ ≥ 𝑞𝑜. For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

• We have shown LPT has approximation ratio (at most) Τ

3 2.

• By a more careful analysis, it can be shown LPT is actually

a Τ 4 3 approximation algorithm.

• The problem of “minimum makespan on identical machines”

has a PTAS (Polynomial Time Approximation Scheme). ∀𝜗 > 0, ∃poly-time (1 + 𝜗)-approx. alg. for the problem

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

Online Scheduling

𝑛 identical machines Jobs arrive (revealed) one-by-one

Schedule decision must be made once a job arrives, without seeing jobs in the future.

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

LPT is not an

• nline alg. for

scheduling.

Competitive Analysis

The competitive ratio of an online algorithm 𝒝 is 𝛽 if:

For every possible input sequence 𝐽 of the considered problem: solution value returned by online alg. 𝒝 on 𝐽 solution value returned by optimal offline alg. on 𝐽 ≤ 𝛽

Competitive Analysis

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

The competitive ratio of an online algorithm 𝒝 is 𝛽 if:

For every possible input sequence 𝐽 of the considered problem: solution value returned by online alg. 𝒝 on 𝐽 solution value returned by optimal offline alg. on 𝐽 ≤ 𝛽

Competitive Analysis

List (Graham 1966)： For each job 𝑘 = 1,2, ⋯ , 𝑜 do: Assign job 𝑘 to a currently least loaded machine.

The competitive ratio of an online algorithm 𝒝 is 𝛽 if:

For every possible input sequence 𝐽 of the considered problem: solution value returned by online alg. 𝒝 on 𝐽 solution value returned by optimal offline alg. on 𝐽 ≤ 𝛽

List is a 2-competitive online algorithm