Set Cover Problem

Set cover problem
From Wikipedia, the free encyclopedia
http://en.wikipedia.org/wiki/Set_cover_problem - mwheadhttp://en.wikipedia.org/wiki/Set_cover_problem - p-search

The set covering problem (SCP) is a classical question in combinatorics, computer science and complexity
theory.
It is a problem "whose study has led to the development of fundamental techniques for the entire field"
of approximation algorithms.[1] It was also one of Karp's 21 NP-complete problems shown to be NPcomplete in 1972.
Given a set of elements
(called the universe) and a set
of
sets whose union
equals the universe, the set cover problem is to identify the smallest subset of
whose union equals the
universe. For example, consider the universe
and the set of
sets
is
. Clearly the union of

. However, we can cover all of the elements with the following, smaller number of sets:
Simply put, the algorithm initializes the distance to the source to 0 and all other nodes to infinity. Then
for all edges, if the distance to the destination can be shortened by taking the edge, the distance is
updated to the new lower value. At each iteration
shortest paths of at most length
that the edges are scanned, the algorithm finds all
edges. Since the longest possible path without a cycle can
be
edges, the edges must be scanned
times to ensure the shortest path
has been found for all nodes. A final scan of all the edges is performed and if any distance is updated,
then a path of length
exists in the graph.
edges has been found which can only occur if at least one negative cycle
3.
a)Len(x,i) = {max(len(x1,i-1)(if x1 is less than x),len(x2,i-2)(if x2 is less
than x),len(x3,i-3)(if x3 is less than x),...len(xn,1)(if xn is less than x),0)
+ 1}
b) you could use the exact same equation but this time, add a third
parameter, ( a vector containing the longest ascending subsequence
ending with xi). To compute xi in the previous equation, simply take the
largest subvector previously computed where the tail is less then x and
then append x.)
This can be solved in O(n^2) using dynamic programming. Basically, the problem is
about building the longest palindromic subsequence in x[i...j] using the longest
subsequence for x[i+1...j], x[i,...j-1] and x[i+1,...,j-1] (if first and last letters are the
same).
Firstly, the empty string and a single character string is trivially a palindrome. Notice
that for a substring x[i,...,j], if x[i]==x[j], we can say that the length of the longest
palindrome is the longest palindrome over x[i+1,...,j-1]+2. If they don't match, the
longest palindrome is the maximum of that of x[i+1,...,j] and y[i,...,j-1].
This gives us the function:
longest(i,j)= j-i+1 if j-i<=0,
2+longest(i+1,j-1) if x[i]==x[j]
max(longest(i+1,j),longest(i,j-1)) otherwise
You can simply implement a memoized version of that function, or code a table of
longest[i][j] bottom up.
This gives you only the length of the longest subsequence, not the actual
subsequence itself. But it can easily be extended to do that as well.
1. Dynamic Programming ([KT] Ch.6: 6.2, 6.4, 6.8, 6.10)

2. Network Flow ([KT] Ch.7: 7.1, 7.2, 7.3, 7.5, 7.6, 7.7)
3. Computational Intractability ([KT] Ch.8: 8.1, 8.2, 8.3, 8.4, 8.5, 8.8)
In computer science, the subset sum problem is an important problem in complexity

theory and cryptography. The problem is this: given a set (or multiset) of integers, is there a non-empty
subset whose sum is zero? For example, given the set {7, 3, 2, 5, 8}, the answer is yes because
the subset {3, 2, 5} sums to zero. The problem is NP-complete.
The knapsack problem is interesting from the perspective of computer science for many reasons:
The decision problem form of the knapsack problem (Can a value of at least V be achieved
without exceeding the weight W?) is NP-complete, thus there is no possible algorithm both correct
and fast (polynomial-time) on all cases, unless P=NP.
While the decision problem is NP-complete, the optimization problem is NP-hard, its resolution
is at least as difficult as the decision problem, and there is no known polynomial algorithm which
can tell, given a solution, whether it is optimal (which would mean that there is no solution with a
larger V, thus solving the decision problem NP-complete).
There is a pseudo-polynomial time algorithm using dynamic programming.
There is a fully polynomial-time approximation scheme, which uses the pseudo-polynomial

time algorithm as a subroutine, described below.
Many cases that arise in practice, and "random instances" from some distributions, can
nonetheless be solved exactly.
time.
Meet-in-the-middle algorithm
input:asetofitemswithweightsandvaluesoutput:the
greatestcombinedvalueofasubsetpartitiontheset{1...n}intotwo
setsAandBofapproximatelyequalsizecomputetheweightsand
valuesofallsubsetsofeachsetforeachsubsetofAfindthe
subsetofBofgreatestvaluesuchthatthecombinedweightislessthan
Wkeeptrackofthegreatestcombinedvalueseensofar
Unbounded knapsack problem[edit]

If all weights (
) are nonnegative integers, the knapsack problem can be solved
in pseudo-polynomial time using dynamic programming. The following describes a dynamic

programming solution for theunbounded knapsack problem.
To simplify things, assume all weights are strictly positive (wi > 0). We wish to maximize total value
subject to the constraint that total weight is less than or equal to W. Then for each w W,
define m[w] to be the maximum value that can be attained with total weight less than or equal
to w. m[W] then is the solution to the problem.
Observe that m[w] has the following properties:
(the sum of zero items, i.e., the summation of the empty set)
where
is the value of the i-th kind of item.
(To formulate the equation above, the idea used is that the solution for a knapsack is the same as the
value of one correct item plus the solution for a knapsack with smaller capacity, specifically one with
the capacity reduced by the weight of that chosen item.)
Here the maximum of the empty set is taken to be zero. Tabulating the results from
through
gives the solution. Since the calculation of each
items, and there are
values of
programming solution is
up
involves examining
to calculate, the running time of the dynamic

. Dividing
by
their greatest common divisor is a way to improve the running time.

The
complexity does not contradict the fact that the knapsack problem is NP-complete,
since
, unlike
, is not polynomial in the length of the input to the problem. The length of the
input to the problem is proportional to the number of bits in

0/1 knapsack problem[edit]
, not to
itself.
A similar dynamic programming solution for the 0/1 knapsack problem also runs in pseudo-polynomial
time. Assume
are strictly positive integers. Define
to be the maximum value that can be attained with weight less than or equal to
(first
using items up to
items).
We can define
recursively as follows:
if
(the new item is more than the
current weight limit)
if
.
The solution can then be found by calculating
to store previous computations.
The following is pseudo code for the dynamic program:
. To do this efficiently we can use a table
//Input://Values(storedinarrayv)//Weights(storedinarrayw)//
Numberofdistinctitems(n)//Knapsackcapacity(W)forjfrom0toWdo
m[0,j]:=0endforforifrom1tondoforjfrom0toWdoif
w[i]<=jthenm[i,j]:=max(m[i1,j],m[i1,jw[i]]+v[i])
elsem[i,j]:=m[i1,j]endifendforendfor
This solution will therefore run in
only a 1-dimensional array
array
only
times, rewriting from
time and
space. Additionally, if we use
to store the current optimal values and pass over this

to
every time, we get the same result for
space.
Note: Algorithm V should work for EVERY G, for SOME C. For every input there should
EXIST information that could help us verify whether the input is in the problem
domain or not. That is, there should not be an input where the information doesn't
exist.
2) Prove it's NP-hard.
This involves getting a known NP-complete problem like SAT (the set of boolean
expressions in the form "(A OR B OR C) AND (D OR E OR F) AND ..." where the
expression is satisfiable (ie there exists some setting for these booleans which makes
the expression true).
Then reduce the NP-complete problem to your problem in polynomial time.
That is, given some input X for SAT (or whatever NP-complete problem you are
using), create some input Y for your problem such that X is in SAT if and only if Y is in
your problem. The function f:X -> Y must run in polynomial time.
In the example above the input Y would be the graph G and the size of the vertex
cover k.
For a full proof, you'd have to prove both:
that X is in SAT => Y in your problem
and Y in your problem => X in SAT.

Set Cover Problem

Uploaded by

Copyright:

Available Formats

Set Cover Problem

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Set Cover Problem

Uploaded by

Copyright:

Available Formats

Set cover problem

From Wikipedia, the free encyclopedia

http://en.wikipedia.org/wiki/Set_cover_problem - mwheadhttp://en.wikipedia.org/wiki/Set_cover_problem - p-search

(called the universe) and a set

sets whose union

whose union equals the

universe. For example, consider the universe

and the set of

. Clearly the union of

that the edges are scanned, the algorithm finds all

edges. Since the longest possible path without a cycle can

1. Dynamic Programming ([KT] Ch.6: 6.2, 6.4, 6.8, 6.10)

In computer science, the subset sum problem is an important problem in complexity

There is a pseudo-polynomial time algorithm using dynamic programming.

There is a fully polynomial-time approximation scheme, which uses the pseudo-polynomial

Unbounded knapsack problem[edit]

) are nonnegative integers, the knapsack problem can be solved

in pseudo-polynomial time using dynamic programming. The following describes a dynamic

is the value of the i-th kind of item.

gives the solution. Since the calculation of each

items, and there are

to calculate, the running time of the dynamic

their greatest common divisor is a way to improve the running time.

input to the problem is proportional to the number of bits in

are strictly positive integers. Define

(the new item is more than the

current weight limit)

. To do this efficiently we can use a table

times, rewriting from

space. Additionally, if we use

to store the current optimal values and pass over this

every time, we get the same result for

that X is in SAT => Y in your problem

and Y in your problem => X in SAT.

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.