17,400 research outputs found
Approximation Algorithms for Covering/Packing Integer Programs
Given matrices A and B and vectors a, b, c and d, all with non-negative
entries, we consider the problem of computing min {c.x: x in Z^n_+, Ax > a, Bx
< b, x < d}. We give a bicriteria-approximation algorithm that, given epsilon
in (0, 1], finds a solution of cost O(ln(m)/epsilon^2) times optimal, meeting
the covering constraints (Ax > a) and multiplicity constraints (x < d), and
satisfying Bx < (1 + epsilon)b + beta, where beta is the vector of row sums
beta_i = sum_j B_ij. Here m denotes the number of rows of A.
This gives an O(ln m)-approximation algorithm for CIP -- minimum-cost
covering integer programs with multiplicity constraints, i.e., the special case
when there are no packing constraints Bx < b. The previous best approximation
ratio has been O(ln(max_j sum_i A_ij)) since 1982. CIP contains the set cover
problem as a special case, so O(ln m)-approximation is the best possible unless
P=NP.Comment: Preliminary version appeared in IEEE Symposium on Foundations of
Computer Science (2001). To appear in Journal of Computer and System Science
A Robust AFPTAS for Online Bin Packing with Polynomial Migration
In this paper we develop general LP and ILP techniques to find an approximate
solution with improved objective value close to an existing solution. The task
of improving an approximate solution is closely related to a classical theorem
of Cook et al. in the sensitivity analysis for LPs and ILPs. This result is
often applied in designing robust algorithms for online problems. We apply our
new techniques to the online bin packing problem, where it is allowed to
reassign a certain number of items, measured by the migration factor. The
migration factor is defined by the total size of reassigned items divided by
the size of the arriving item. We obtain a robust asymptotic fully polynomial
time approximation scheme (AFPTAS) for the online bin packing problem with
migration factor bounded by a polynomial in . This answers
an open question stated by Epstein and Levin in the affirmative. As a byproduct
we prove an approximate variant of the sensitivity theorem by Cook at el. for
linear programs
Maximum weight cycle packing in directed graphs, with application to kidney exchange programs
Centralized matching programs have been established in several countries to organize kidney exchanges between incompatible patient-donor pairs. At the heart of these programs are algorithms to solve kidney exchange problems, which can be modelled as cycle packing problems in a directed graph, involving cycles of length 2, 3, or even longer. Usually, the goal is to maximize the number of transplants, but sometimes the total benefit is maximized by considering the differences between suitable kidneys. These problems correspond to computing cycle packings of maximum size or maximum weight in directed graphs. Here we prove the APX-completeness of the problem of finding a maximum size exchange involving only 2-cycles and 3-cycles. We also present an approximation algorithm and an exact algorithm for the problem of finding a maximum weight exchange involving cycles of bounded length. The exact algorithm has been used to provide optimal solutions to real kidney exchange problems arising from the National Matching Scheme for Paired Donation run by NHS Blood and Transplant, and we describe practical experience based on this collaboration
Data-Collection for the Sloan Digital Sky Survey: a Network-Flow Heuristic
The goal of the Sloan Digital Sky Survey is ``to map in detail one-quarter of
the entire sky, determining the positions and absolute brightnesses of more
than 100 million celestial objects''. The survey will be performed by taking
``snapshots'' through a large telescope. Each snapshot can capture up to 600
objects from a small circle of the sky. This paper describes the design and
implementation of the algorithm that is being used to determine the snapshots
so as to minimize their number. The problem is NP-hard in general; the
algorithm described is a heuristic, based on Lagriangian-relaxation and
min-cost network flow. It gets within 5-15% of a naive lower bound, whereas
using a ``uniform'' cover only gets within 25-35%.Comment: proceedings version appeared in ACM-SIAM Symposium on Discrete
Algorithms (1998
A Parallelizable Acceleration Framework for Packing Linear Programs
This paper presents an acceleration framework for packing linear programming
problems where the amount of data available is limited, i.e., where the number
of constraints m is small compared to the variable dimension n. The framework
can be used as a black box to speed up linear programming solvers dramatically,
by two orders of magnitude in our experiments. We present worst-case guarantees
on the quality of the solution and the speedup provided by the algorithm,
showing that the framework provides an approximately optimal solution while
running the original solver on a much smaller problem. The framework can be
used to accelerate exact solvers, approximate solvers, and parallel/distributed
solvers. Further, it can be used for both linear programs and integer linear
programs
Statistical Mechanics of maximal independent sets
The graph theoretic concept of maximal independent set arises in several
practical problems in computer science as well as in game theory. A maximal
independent set is defined by the set of occupied nodes that satisfy some
packing and covering constraints. It is known that finding minimum and
maximum-density maximal independent sets are hard optimization problems. In
this paper, we use cavity method of statistical physics and Monte Carlo
simulations to study the corresponding constraint satisfaction problem on
random graphs. We obtain the entropy of maximal independent sets within the
replica symmetric and one-step replica symmetry breaking frameworks, shedding
light on the metric structure of the landscape of solutions and suggesting a
class of possible algorithms. This is of particular relevance for the
application to the study of strategic interactions in social and economic
networks, where maximal independent sets correspond to pure Nash equilibria of
a graphical game of public goods allocation
AFPTAS results for common variants of bin packing: A new method to handle the small items
We consider two well-known natural variants of bin packing, and show that
these packing problems admit asymptotic fully polynomial time approximation
schemes (AFPTAS). In bin packing problems, a set of one-dimensional items of
size at most 1 is to be assigned (packed) to subsets of sum at most 1 (bins).
It has been known for a while that the most basic problem admits an AFPTAS. In
this paper, we develop methods that allow to extend this result to other
variants of bin packing. Specifically, the problems which we study in this
paper, for which we design asymptotic fully polynomial time approximation
schemes, are the following. The first problem is "Bin packing with cardinality
constraints", where a parameter k is given, such that a bin may contain up to k
items. The goal is to minimize the number of bins used. The second problem is
"Bin packing with rejection", where every item has a rejection penalty
associated with it. An item needs to be either packed to a bin or rejected, and
the goal is to minimize the number of used bins plus the total rejection
penalty of unpacked items. This resolves the complexity of two important
variants of the bin packing problem. Our approximation schemes use a novel
method for packing the small items. This new method is the core of the improved
running times of our schemes over the running times of the previous results,
which are only asymptotic polynomial time approximation schemes (APTAS)
- âŚ