# Approximation Algorithms - PowerPoint PPT Presentation

PPT – Approximation Algorithms PowerPoint presentation | free to download - id: 2518f0-ZDc1Z

The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
Title:

## Approximation Algorithms

Description:

### The regular greedy Algorithm would not work with a problem between two sites s ... However, this is not enough to make a good approximation algorithm we need to ... – PowerPoint PPT presentation

Number of Views:113
Avg rating:3.0/5.0
Slides: 35
Provided by: luisc7
Category:
Tags:
Transcript and Presenter's Notes

Title: Approximation Algorithms

1
Approximation Algorithms
• By Ryan Kupfer,
• Luis Colón,
• Joe Parisi
• CMSC 435 Algorithm Analysis and Design

2
What is an Approximation Algorithm
• Approximation Algorithms
• Run in polynomial time
• Find solutions that are guaranteed to be close to
optimal

3
Different Problems where approximate Algorithms
are used.
• 11.1 Greedy Algorithm Bounds on the Optimum A
• 11.2 The Center Selection Problem
• 11.3 Set Cover A General Greedy Heuristic
• 11.4 The Pricing Method Vertex Cover
• 11.5 Maximization via the Pricing Method the
Disjoint Problem
• Traveling Salesman Problem

4
Greedy Algorithm Load Balancing Problem -The
Problem
• Problem Balance the load on each of the servers
in order to split up the work load across them
• Declare the load on a machine Mi, minimize a
quantity known as the makespan (maximum load on
any machine)
• Take a greedy approach to this problem, the
algorithm makes one pass through the jobs in any
order and puts that job on the machine with the

5
Load Balancing Analyzing Algorithms
• Our makespan for our algorithm is not much bigger
than the makespan of the optimal solution,
however, we cannot compare that because we cannot
compute that optimal value (due to time
constraints)
• Therefore, we need to set a lower bound on the
optimum quantity with the guarantee that no
matter how good the optimum is, it cannot be less
than this bound in order to make a better
approximation algorithm

6
How can we improve this algorithm?
• Guarantee being within a factor strictly smaller
than 2 away from the optimum

7
11.2 The Center Selection Problem
• Similar to load balancing but also where to place
server in order to keep the formulation clean and
simple
• The Center Selection Problem provides an example
of when a natural greedy algorithm does not give
the optimal solution, instead a slightly
different greedy version can guarantee us a near
optimal solution

8
Designing and Analyzing the Algorithm
• The regular greedy Algorithm would not work with
a problem between two sites s and z and there
distance is 2 the regular greedy algorithm would
place them half way between each other while the
actual optimum solution would just place them at
the same location and the radius around it would
be zero
• Knowing the Optimal Radius helps.

9
11.3 Set Cover A General Greedy Heuristic
• Set Cover is something that can be used for
special case algorithms. Approximate Algorithms
is something that the set Cover Algorithm can be
applied to.
• Set Cover is a collection of subsets of U whose
union is equal to all U.

10
Designing the Algorithm
• The Greddy Algorithm for this problem will have
the property that it builds the cover set one at
a time then it picks the next set depending on
what will reach the goal more naturally.
• A good set has the properties of small weight and
it covers overs lots of elements. However, this
is not enough to make a good approximation
algorithm we need to combine the two properties
and find the cost per element. Which will be a
good guide.

11
Analyzing the Set Cover Algorithm
• Our algorithm is good to find a solution but we
have to wonder how much larger is the weight of
this set cover than the weight of the optimal
set.
• The set cover C selected by the Greedy Set Cover
has weight at most H(d) times the optimal
weight.
• From this we can find a desired bound for trying
to find the optimal weight and a good
approximation algorithm.

12
11.4 The Pricing Method Vertex Cover
• We want to find a vertex cover S for which w(S)
is minimum. When all weights are equal to 1,
deciding of there is a vertex cover of weight at
most K is the standard decision version of the
vertex cover.
• A vertex cover for an undirected graph G (V,E)
is a subset S of its vertices's such that each
edge has at le ast one endpoint in S. In other
words, for each edge ab in E, one of a or b must
be an element of S.
• Vertex Cover lt Set cover if all weights are
equal to 1.

13
Designing Pricing Method Algorithm
• For the case of the Vertex Cover Problem , we
think of the weights on the nodes as Costs, and
we will think of each edge as having to pay for
its share of the cost of the vertex cover we find
• The goal of this approximation algorithm is to
find a vertex cover, set prices at the same time,
and use these prices to select the nodes for the
vertex cover

14
11.5 Maximization via the Pricing Method The
Disjoint Paths Problem
• This usually problem usually arises in network
routing, the special case that we are dealing
with is where each path to be routed has its own
designated starting node, S, and ending node, T
• Treat (S, T) as a routing request which asks for
a path from S to T

15
Solving the Disjoint Path Problem with a Pricing
Algorithm
• For this algorithm
• Have the paths pay for the edges
• Edges can be shared among paths, however the more
that edge is used, the more costly it becomes
• Distinguish the difference between the short and
long paths

16
11.6 Linear Programming and Rounding an
Application to Vertex Cover
• Linear programming is a technique that can be
very powerful in applying to different sets of
problems
• We can apply it to the Vertex Cover Problem
• Linear programming can be seen as following a
more complex version of regular algebraic
expressions just with inequalities instead of
equations

17
Traveling Salesman Problem
• We know that the traveling salesman problem is
more of an optimization problem but it applies to
approximate algorithms because this problem is of
type NP-Hard
• The Problem Given a number of cities and the
costs of traveling from any city to any other
city, what is the least-cost round-trip route
that visits each city at least once and then
returns to the starting city.

18
Solving the salesman Problem
• Since the salesman problem is a problem of NP
Hardness, we are able to solve it in the same way
we can solve an NP-Hard problem using an
Approximation Algorithm.
• It will give us a solution that can be 2 - 3
away from the optimal solution which could be
faster and more cost effective than an exact
solution algorithm.

19
Problem 1 Overview
• A ship arrives with n containers of
• weight (w1, w2, ..., wn)
• There are a set of trucks which
• can hold K units of weight
• Minimize the number of trucks needed to carry all
the containers
• The Greedy Algorithm
• Start with an empty truck and pile the containers
in the order that they came in and move on to the
next truck if the next container does not fit
• Repeat until there are no more containers

20
Problem 1 Continued
• a) Given an example of set of weights and there
value we figure this out.
• If K is 10 and the set of containers is 6, 5,
4, 3
• The first truck would be loaded with container 1,
weight 6 and since the next container is of
weight 5, it would be overflowing so send truck 1
off with container 1. The next truck would
contain containers 2 and 3 (weights 5 and 4), and
the last truck would only have container 4,
weight 3.
• The optimal solution to this would be to load
containers 1 and 3 (weights 6 and 4) into truck 1
and containers 2 and 4 (weights 5 and 3) into
truck 2.

21
Problem 1 Continued
• b) Show that the number of trucks used by this
algorithm is within a factor of 2 of the minimum
possible number of trucks for any set of weights
and any value of K.
• Suppose that each truck could hold a maximum
weight of 10 (K 10)
• Given the set of containers
• S 6, 5, 6, 5, 6, 5, 6, 5 (Worst-case
scenario for K)
• This would require 8 trucks
• A better algorithm which could look ahead would
require only 6 trucks

22
Problem 2 Overview
• The idea of this problem is to build a
representative set for a large collection of
protein molecules whose properties are not
completely understood. This would allow the
researchers to study the smaller representative
set and by inference learn about the whole set

23
Problem 2 Continued
• a) Given a large set of proteins P, using the
similarity-distance function dist(p, q) which
returns a delta value of similarity (lt delta
being similar), give an algorithm to determine
the smallest representative set R.
• Initialize a representative set R with the empty
set
• Start with a set P of proteins
• While P still has proteins
• Select a protein p from P at random
• Choose a protein q from P which maximizes the
function dist(p, q) lt delta
• Add q to R
• Remove p, q, and all proteins where dist(p, q) lt
delta

24
Problem 2 Continued
• b) The algorithm listed for the Center Selection
problem does not solve our protein problem
because increasing the delta to 2 delta would
not be relevant.

25
Problem 3 Overview
• We would like to find a subset S of A which is
the maximum feasible value (the sum of subset S
does not exceed a certain given value)

26
Problem 3 Solution
• a) Given the following algorithm
• S
• T 0
• For I 1, 2, , n
• If T ai lt B
• S S U ai
• T T ai
• End If
• End For
• Give an instance in which the total sum of the
set S returned by this algorithm is less than
half the total sum of some other feasible subset
of A
• A 1, 3, 10, B 11, the algorithm above would
only return 1 and 3 (total of 4) where an optimal
one would return 1 and 10 (total of 11)

27
Problem 3 Solution Continued
• The way that our algorithm works is
• First it sorts the contents of the set in
ascending order using quicksort
• It then alternates between the largest and
smallest elements adding them to a total value to
compare to the given B
• If the new would-be total value is less than or
equal to B then add the chosen element to the
feasible set and add that chosen element to the
total value.

28
Problem 3 Solution Continued
• Now we have a feasible set that contains elements
of the full set A and the summation of the values
of the feasible set (Total). With the value of
Total, we can see that we have the best feasible
set for any given run of this algorithm.
• To be certain that this algorithm ran as I claim,
I ran five million examples of it on randomly
generated data. For each test run, the set A had
a length of range 3-50 and each element was in a
range of 1-50. The random value for B is in the
range of the smallest sum.

29
Problem 3 Solution Continued
• During the 5,000,000 test runs, there were no
cases which returned a feasible subset of A in
which the summation was less than half of the
total possible summation of all elements of A
• Because it is not possible for an algorithm to
have its half point higher than the total half
point of A, our algorithm will always return a
result more than one half of any other subset
returned by any other algorithm

30
Problem 5 Overview
• A company has a business where clients bring in
jobs each day for processing and each job has a
processing time t on ten machines.
• The company is running the Greedy Balance
algorithm and it may not be the best
approximation algorithm that can be used.
• We must prove that the greedy- Balance algorithm
will always give a makespan o fat most 20 percent
above the average load.

31
Problem 5 Solution
• Show that the companys greedy algorithm will
always find a solution whose makespan is at most
20 above the average load
• Assuming the total load is at its lowest value,
3000 and the optimal load is 1/10 of that total
load (since there are 10 machines), 300,
therefore the average load per machine cannot be
higher than 360
• Assume you have 10 jobs at 25 (average job size)
• 300 / 250 120

32
Problem 10 Overview
• We are given an n x n grid graph G.
• Associated with each node v is a weight w(v)
which is a non-negative integer. All the weights
of all nodes are distinct.
• The goal is to choose an independent set S of
nodes of the grid so that the sum of the weights
of node S is as large as possible.
• While G still has nodes
• Choose the highest weighted node, v
• Add v to S
• Delete v and its neighbors from G
• Return S

33
Problem 10 Solution
• a) Let S be the independent set returned, let T
be any other independent set in G. Show that for
each node v in T, either v is in S, or there is a
node v in S so that the weight of v is less than
or equal to the weight of v
• This is true simply due to the fact that it is
asking for independent sets, if a node in the
random independent set is not in the max
weighted independent set, it must have a neighbor
in that set with a higher or equal weight

34
Problem 10 Solution
• b) Show that the greedy algorithm given returns
an S at least 1/4th the maximum total weight of
any independent set
• In order to prove this, youd have to assume for
any node chosen in any independent set that each
of its four neighbors could be a higher value
• Assign the node in the independent set being
tested four times the weight.
• Summing the node weights results in a value 4
times greater than that of the greedy algorithm