CSE 202: Design and

Analysis of Algorithms

Lecture 4

Instructor: Kamalika Chaudhuri

 Announcements

• HW 1 due in class on Tue Jan 24

• Email me your homework partner name, or if you

need a partner today
 Greedy Algorithms

• Direct argument - MST

• Exchange argument - Caching

• Greedy approximation algorithms

 Optimal Caching

Main Memory Cache

Given a sequence of memory accesses, limited cache:

How do you decide which cache element to evict?

Note: We are given future memory accesses for this

problem, which is usually not the case. This is for an application of
greedy algorithms
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a
S1 Cache Contents
b
E - Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a a
S1 Cache Contents
b b
E - - Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a a a
S1 Cache Contents
b b c
E - - b Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a a a b
S1 Cache Contents
b b c c
E - - b a Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a a a b b
S1 Cache Contents
b b c c c
E - - b a - Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a a a b b b
S1 Cache Contents
b b c c c a
E - - b a - c Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching: Example

M a b c b c b a a Memory Access Sequence

a a a b b b b b
S1 Cache Contents
b b c c c a a a
E - - b a - c - - Evicted items

Given a sequence of memory accesses, limited cache size,

How do you decide which cache element to evict?
Goal: Minimize #main memory fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a
S1 Cache Contents
b
E - Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a
S1 Cache Contents
b b
E - - Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a c
S1 Cache Contents
b b b
E - - a Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a c c
S1 Cache Contents
b b b b
E - - a - Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a c c c
S1 Cache Contents
b b b b b
E - - a - - Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a c c c b
S1 Cache Contents
b b b b b c
E - - a - - - Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a c c c b b
S1 Cache Contents
b b b b b c a
E - - a - - - c Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Optimal Caching

M a b c b c b a a Memory Access Sequence

a a c c c b b b
S1 Cache Contents
b b b b b c a a
E - - a - - - c - Evicted items

Farthest-First (FF) Schedule: Evict an item

when needed. Evict the element which is accessed
farthest down in the future
Theorem: The FF algorithm minimizes #fetches
 Caching: Reduced Schedule

M a b c b c b a a Memory Access Sequence

a a c c c b b b
S1 Cache Contents
b b b b b c a a
E - - a - - - c - Evicted items

An eviction schedule is reduced if it fetches an item x only

when it is accessed
Fact: For any S, there is a reduced schedule S* which
makes at most as many fetches as S
 Caching: Reduced Schedule
An eviction schedule is reduced if it fetches an item x only when it is accessed
Fact: For any S, there is a reduced schedule S* with at most as many fetches as S

M a b c b c b a a

a a a b b b b b
S1 Non-reduced
b b c c c a a a
a a a b b b b b
S2 Reduced
b b c c c c a a

To convert S to S*: Be lazy!

 Optimal Caching Theorem

Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF

from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Suppose you claim a magic schedule schedule SM makes less fetches than SFF
Then, we can construct a sequence of schedules:
SM = S0, S1, S2, ..., Sn = SFF such that:
(1) Sj agrees with SFF from t=1 to t = j
(2) #fetches(Sj+1) <= #fetches(Sj)

What does this say about #fetches(SFF) relative to #fetches(SM)?

 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj a, b

SFF a, b

Sj+1 a, b

t=j Cache t=j

 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj a, b a, b

SFF a, b a, b

Sj+1 a, b a, b

t=j t=j+1 Cache t=j Cache t=j+1

Case 1: No cache miss at t=j+1. Sj+1 = Sj

 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj a, b a, c

SFF a, b a, c

Sj+1 a, b a, c

t=j t=j+1 Cache t=j Cache t=j+1

Case 2: Cache miss at t=j+1, Sj and SFF evict same item. Sj+1 = Sj
 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj c, b d, c

SFF a, c ...

Sj+1 a, c d, c

t=j t=j+1 t=q Cache t=j+1 Cache t=q

Case 3a: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b.
Next there is a request to d, and Sj evicts b. Make Sj+1 evict a, bring in d.
 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj c, b c, a

SFF a, c ...

Sj+1 a, c c, a

t=j t=j+1 t=q Cache t=j+1 Cache t=q

Case 3b: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b
Next there is a request to a, and Sj evicts b. Sj+1 does nothing.
 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj c, b d, b

SFF a, c ...

Sj+1 a, c d, b

t=j t=j+1 t=q Cache t=j+1 Cache t=q

Case 3c: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b
Next there is a request to a, and Sj evicts d. Sj+1 evicts d and brings in b.
Now convert Sj+1 to the reduced version of this schedule.
 Caching: FF Schedules
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Sj c, b d, b

SFF a, c ...

Sj+1 a, c d, b

t=j t=j+1 t=q Cache t=j+1 Cache t=q

Case 3d: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b
Next there is a request to b. Cannot happen as a is accessed before b!
 Summary: Optimal Caching
Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF
from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Case 1: No cache miss at t=j+1. Sj+1 = Sj

Case 2: Cache miss at t=j+1, Sj and SFF evict same item. Sj+1 = Sj
Case 3a: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b.
Next there is a request to d, and Sj evicts b. Make Sj+1 evict a, bring in d.
Case 3b: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b
Next there is a request to a, and Sj evicts b. Sj+1 does nothing.
Case 3c: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b
Next there is a request to a, and Sj evicts d. Sj+1 evicts d and brings in b.
Now convert Sj+1 to the reduced version of this schedule.
Case 3d: Cache miss at t=j+1. Sj evicts a, SFF evicts b. Sj+1 also evicts b
Next there is a request to b. Cannot happen as a is accessed before b!
 Summary: Optimal Caching

Theorem: Suppose a reduced schedule Sj makes the same decisions as SFF

from t=1 to t=j. Then, there exists a reduced schedule Sj+1 s.t:
1. Sj+1 makes same decision as SFF from t=1 to t=j+1
2. #fetches(Sj+1) <= #fetches(Sj)

Suppose you claim a magic schedule schedule SM makes less fetches than SFF
Then, we can construct a sequence of schedules:
SM = S0, S1, S2, ..., Sn = SFF such that:
(1) Sj agrees with SFF from t=1 to t = j
(2) #fetches(Sj+1) <= #fetches(Sj)

What does this say about #fetches(SFF) relative to #fetches(SM)?

 Greedy Algorithms

• Direct argument - MST

• Exchange argument - Caching

• Greedy approximation algorithms

Greedy Approximation Algorithms

• k-Center
• Set Cover
 Approximation Algorithms

• Optimization problems, eg, MST, Shortest paths

• What do we optimize?

• What if we do not have enough resources to compute

the optimal solution?
 Approximation Algorithms

For an instance I of a minimization problem, let:

A(I) = value of solution by algorithm A
OPT(I) = value of optimal solution
Approximation ratio(A) = maxI A(I)/OPT(I)
A is an approx. algorithm if approx-ratio(A) is bounded
 Approximation Algorithms

For an instance I of a minimization problem, let:

A(I) = value of solution by algorithm A
OPT(I) = value of optimal solution
Approximation ratio(A) = maxI A(I)/OPT(I)
A is an approx. algorithm if approx-ratio(A) is bounded

Higher approximation ratio means worse algorithm

Greedy Approximation Algorithms

• k-Center
• Set Cover
 k-Center Problem

Given n towns on a map

Find how to place k shopping malls such that:
Drive to the nearest mall from any town is shortest
 k-Center Problem

Given n towns on a map

Find how to place k shopping malls such that:
Drive to the nearest mall from any town is shortest

k=3
 k-Center Problem

Given n points in a metric space

Find k centers such that distance between any point and its
closest center is as small as possible

Metric Space:
Point set w/ distance fn d

Properties of d:
k=3 • d(x, y) >= 0
• d(x, y) = d(y, x)
• d(x, y) <= d(x, z) + d(y, z)
NP Hard in general
 A Greedy Algorithm: Farthest-
first traversal
1. Pick C = {x}, for an arbitrary point x
2. Repeat until C has k centers:
Let y maximize d(y, C), where
d(y, C) = minx in C d(x, y)
C = C U {y}

k=3
 A Greedy Algorithm: Farthest-
first traversal
1. Pick C = {x}, for an arbitrary point x
2. Repeat until C has k centers:
Let y maximize d(y, C), where
d(y, C) = minx in C d(x, y)
C = C U {y}

k=3
 A Greedy Algorithm: Farthest-
first traversal
1. Pick C = {x}, for an arbitrary point x
2. Repeat until C has k centers:
Let y maximize d(y, C), where
d(y, C) = minx in C d(x, y)
C = C U {y}

k=3
 A Greedy Algorithm: Farthest-
first traversal
1. Pick C = {x}, for an arbitrary point x
2. Repeat until C has k centers:
Let y maximize d(y, C), where
d(y, C) = minx in C d(x, y)
C = C U {y}

k=3
 A Greedy Algorithm: Farthest-
first traversal
1. Pick C = {x}, for an arbitrary point x
2. Repeat until C has k centers:
Let y maximize d(y, C), where
d(y, C) = minx in C d(x, y)
C = C U {y}

k=3
 Farthest-first Traversal

Is farthest-first traversal always optimal?

k=3

Theorem: Approx. ratio of farthest-first traversal is 2

 Facts on Analyzing Approx.
Algorithms

• Need to reason about the algorithm relative

to the optimal solution
• Example: Optimal solution has value greater
than or equal to some value X
 Farthest-first(FF) Traversal
Theorem: Approx. ratio of FF-traversal is 2
Metric Space: Define, for any instance: r = max x d(x, C)
Point set w/ distance fn d q = argmax x d(x, C)
Properties of d:
•d(x, y) >= 0 q
•d(x, y) = d(y, x)
•d(x, y) <= d(x, z) + d(y, z)
k=3
For a set S,
d(x, S) = miny in Sd(x, y)
Property 1. Solution value of FF-traversal = r

FF-traversal:
Pick C = {x}, arbitrary x
Repeat until C has k centers:
Let y maximize d(y, C)
C = C U {y}
 Farthest-first(FF) Traversal
Theorem: Approx. ratio of FF-traversal is 2
Metric Space: Define, for any instance: r = max x d(x, C)
Point set w/ distance fn d q = argmax x d(x, C)
Properties of d:
•d(x, y) >= 0 q
•d(x, y) = d(y, x)
•d(x, y) <= d(x, z) + d(y, z)
k=3
For a set S,
d(x, S) = miny in Sd(x, y)
Property 1. Solution value of FF-traversal = r
Property 2. There are at least k+1 points S s.t
FF-traversal: each pair has distance >= r
Pick C = {x}, arbitrary x
Repeat until C has k centers:
Let y maximize d(y, C)
C = C U {y}
 Farthest-first(FF) Traversal
Theorem: Approx. ratio of FF-traversal is 2
Metric Space: Define, for any instance: r = max x d(x, C)
Point set w/ distance fn d q = argmax x d(x, C)
Properties of d:
•d(x, y) >= 0 q
•d(x, y) = d(y, x)
•d(x, y) <= d(x, z) + d(y, z)
k=3
For a set S,
d(x, S) = miny in Sd(x, y)
Property 1. Solution value of FF-traversal = r
Property 2. There are at least k+1 points S s.t
FF-traversal: each pair has distance >= r, where S = C U {q}.
Pick C = {x}, arbitrary x
Repeat until C has k centers:
Let y maximize d(y, C)
C = C U {y}
 Farthest-first(FF) Traversal
Theorem: Approx. ratio of FF-traversal is 2
Metric Space: Define, for any instance: r = max x d(x, C)
Point set w/ distance fn d q = argmax x d(x, C)
Properties of d:
•d(x, y) >= 0 q
•d(x, y) = d(y, x)
•d(x, y) <= d(x, z) + d(y, z)
k=3
For a set S,
d(x, S) = miny in Sd(x, y)
Property 1. Solution value of FF-traversal = r
Property 2. There are at least k+1 points S s.t
FF-traversal: each pair has distance >= r, where S = C U {q}.
Pick C = {x}, arbitrary x Property 3. The Optimal solution must assign
Repeat until C has k centers: at least two points x, y in S to the same center c
Let y maximize d(y, C)
C = C U {y} What is Max(d(x, c), d(y, c)) ?
 Farthest-first(FF) Traversal
Theorem: Approx. ratio of FF-traversal is 2
Metric Space: Define, for any instance: r = max x d(x, C)
Point set w/ distance fn d q = argmax x d(x, C)
Properties of d:
•d(x, y) >= 0 q
•d(x, y) = d(y, x)
•d(x, y) <= d(x, z) + d(y, z)
k=3
For a set S,
d(x, S) = miny in Sd(x, y)
Property 3. The optimal solution must assign at
least two points x, y in S to the same center c
FF-traversal: What is max(d(x, c), d(y, c)) ?
Pick C = {x}, arbitrary x x
Repeat until C has k centers: From property of d,
Let y maximize d(y, C) d(x,c) d(x,y) d(x,c) + d(y, c) >= d(x, y)
C = C U {y} max(d(x,c), d(y,c)) >= d(x,y)/2
c y
d(y,c)
 Farthest-first(FF) Traversal
Theorem: Approx. ratio of FF-traversal is 2
Metric Space: Define, for any instance: r = max x d(x, C)
Point set w/ distance fn d q = argmax x d(x, C)
Properties of d:
•d(x, y) >= 0 q
•d(x, y) = d(y, x)
•d(x, y) <= d(x, z) + d(y, z)
k=3
For a set S,
d(x, S) = miny in Sd(x, y)
Property 1. Solution value of FF-traversal = r
Property 2. There are at least k+1 points S s.t
FF-traversal: each pair has distance >= r, where S = C U {q}
Pick C = {x}, arbitrary x Property 3. The optimal solution must assign at
Repeat until C has k centers: least two points x, y in S to the same center c
Let y maximize d(y, C)
Max(d(x, c), d(y, c)) >= d(x,y)/2 >= r/2
C = C U {y}
Property 4. Thus, Opt. solution has value >= r/2
 Summary: k center

Given n points in a metric space

Find k centers such that distance between any point and its
closest center is as small as possible

FF-Traversal Algorithm:
1. Pick C = {x}, for an arbitrary point x
2. Repeat until C has k centers:
Let y maximize d(y, C), where
d(y, C) = minx in C d(x, y)
C = C U {y}

k-center is NP hard, but approx. ratio of FF-traversal is 2

 Applications of k-center:

• Facility-location problems
• Clustering
Greedy Approximation Algorithms

• k-Center
• Set Cover
 Set Cover Problem
Given:
• Universe U with n elements
• Collection C of sets of elements of U
Find the smallest subset C* of C that covers all of U

NP Hard in general
 Set Cover Problem
Given:
• Universe U with n elements
• Collection C of sets of elements of U
Find the smallest subset C* of C that covers all of U

NP Hard in general
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*

Greedy: #sets=7
 A Greedy Set-Cover Algorithm

C* = { }
Repeat until all of U is covered:
Pick the set S in C with highest # of uncovered elements
Add S to C*

Greedy: #sets=7
OPT: #sets=5
 Greedy Set-Cover Algorithm

Theorem: If optimal set cover has k sets, then greedy selects <= k ln n sets

Greedy Algorithm:
C* = { }
Repeat until U is covered:
Pick S in C with highest # of uncovered elements
Add S to C*

Define:
n(t) = #uncovered elements after step t in greedy
Property 1: There is some S that covers at
least n(t)/k of the uncovered elements
Property 2: n(t+1) <= n(t)(1 - 1/k)
Property 3: n(T) <= n(1 - 1/k)T < 1,
when T = k ln n t=1
 Summary: set cover

Given: Universe U with n elements

Collection C of sets of elements of U
Find the smallest subset C* of C that covers all of U

Greedy Algorithm:
C* = { }
Repeat until U is covered:
Pick S in C with highest # of uncovered elements

Set-cover is NP hard, but approx. ratio of Greedy is O(log n)

 The Maximum Coverage
Problem
Given:
• Universe U with n elements
• Collection C of sets of elements of U
Find a subset C* of C of size k that covers as many
elements of U as possible

A different version of Set-cover

NP hard
Greedy algorithm also has a good approx-ratio
 Applications of Set Cover and
Max. Coverage

• Facility location problems

• Submodular optimization
 Greedy Algorithms

• Direct argument - MST

• Exchange argument - Caching

• Greedy approximation algorithms

• k-center, set-cover