47 research outputs found
Distributed Algorithms for Scheduling on Line and Tree Networks
We have a set of processors (or agents) and a set of graph networks defined
over some vertex set. Each processor can access a subset of the graph networks.
Each processor has a demand specified as a pair of vertices , along
with a profit; the processor wishes to send data between and . Towards
that goal, the processor needs to select a graph network accessible to it and a
path connecting and within the selected network. The processor requires
exclusive access to the chosen path, in order to route the data. Thus, the
processors are competing for routes/channels. A feasible solution selects a
subset of demands and schedules each selected demand on a graph network
accessible to the processor owning the demand; the solution also specifies the
paths to use for this purpose. The requirement is that for any two demands
scheduled on the same graph network, their chosen paths must be edge disjoint.
The goal is to output a solution having the maximum aggregate profit. Prior
work has addressed the above problem in a distibuted setting for the special
case where all the graph networks are simply paths (i.e, line-networks).
Distributed constant factor approximation algorithms are known for this case.
The main contributions of this paper are twofold. First we design a
distributed constant factor approximation algorithm for the more general case
of tree-networks. The core component of our algorithm is a tree-decomposition
technique, which may be of independent interest. Secondly, for the case of
line-networks, we improve the known approximation guarantees by a factor of 5.
Our algorithms can also handle the capacitated scenario, wherein the demands
and edges have bandwidth requirements and capacities, respectively.Comment: Accepted to PODC 2012, full versio
Scheduling Resources for Executing a Partial Set of Jobs
In this paper, we consider the problem of choosing a minimum cost set of
resources for executing a specified set of jobs. Each input job is an interval,
determined by its start-time and end-time. Each resource is also an interval
determined by its start-time and end-time; moreover, every resource has a
capacity and a cost associated with it. We consider two versions of this
problem. In the partial covering version, we are also given as input a number
k, specifying the number of jobs that must be performed. The goal is to choose
k jobs and find a minimum cost set of resources to perform the chosen k jobs
(at any point of time the capacity of the chosen set of resources should be
sufficient to execute the jobs active at that time). We present an O(log
n)-factor approximation algorithm for this problem.
We also consider the prize collecting version, wherein every job also has a
penalty associated with it. The feasible solution consists of a subset of the
jobs, and a set of resources, to perform the chosen subset of jobs. The goal is
to find a feasible solution that minimizes the sum of the costs of the selected
resources and the penalties of the jobs that are not selected. We present a
constant factor approximation algorithm for this problemComment: Full version of paper accepted to FSTTCS'201
A simple linear time ( 1+ ε)- approximation algorithm for geometric k-means clustering in any dimensions
We present the first linear time (1+ε)-approximation algorithm for the k-means problem for fixed k and ε. Our algorithm runs in O(nd) time, which is linear in the size of the input. Another feature of our algorithm is its simplicity - the only technique involved is random sampling
The update complexity of selection and related problems
We present a framework for computing with input data specified by intervals, representing uncertainty in the values of the input parameters. To compute a solution, the algorithm can query the input parameters that yield more refined estimates in form of sub-intervals and the objective is to minimize the number of queries. The previous approaches address the scenario where every query returns an exact value. Our framework is more general as it can deal with a wider variety of inputs and query responses and we establish interesting relationships between them that have not been investigated previously. Although some of the approaches of the previous restricted models can be adapted to the more general model, we
require more sophisticated techniques for the analysis and we also obtain improved algorithms for the previous model. We address selection problems in the generalized model and show that there exist 2-update competitive algorithms that do not depend on the lengths or distribution of the sub-intervals and hold against the worst case adversary. We also obtain similar bounds on the competitive ratio for the MST problem
in graphs
A Near-linear Time Constant Factor Algorithm for Unsplittable Flow Problem on Line with Bag Constraints
Consider a scenario where we need to schedule a set of jobs on a system offering some resource (such as electrical power or communication bandwidth), which we shall refer to as bandwidth. Each job consists of a set (or bag) of job instances. For each job instance, the input specifies the start time, finish time, bandwidth requirement and profit. The bandwidth offered by the system varies at different points of time and is specified as part of the input. A feasible solution is to choose a subset of instances such that at
any point of time, the sum of bandwidth requirements of the chosen instances does not exceed the bandwidth available at that point of time, and furthermore, at most one instance is picked from each job.
The goal is to find a maximum profit feasible solution. We study this problem under a natural assumption called the no-bottleneck assumption (NBA), wherein the bandwidth requirement of any job instance is at most the minimum bandwidth available. We present a simple, near-linear time constant factor approximation algorithm for this problem, under NBA. When each job consists of only one job instance, the above problem is the same as the well-studied unsplittable flow problem (UFP) on lines. A constant factor approximation algorithm is known for the UFP on line, under NBA.
Our result leads to an alternative constant factor approximation algorithm for this problem. Though the approximation ratio achieved by our algorithm is inferior, it is much simpler, deterministic and faster in comparison to the existing algorithms. Our algorithm runs in near-linear time (), whereas the running time of the known algorithms is a high order polynomial. The core idea behind our algorithm is a reduction from the varying bandwidth case to the easier uniform bandwidth case, using a technique that we call slicing
Distributed and Parallel Algorithms for Set Cover Problems with Small Neighborhood Covers
In this paper, we study a class of set cover problems that satisfy a special
property which we call the {\em small neighborhood cover} property. This class
encompasses several well-studied problems including vertex cover, interval
cover, bag interval cover and tree cover. We design unified distributed and
parallel algorithms that can handle any set cover problem falling under the
above framework and yield constant factor approximations. These algorithms run
in polylogarithmic communication rounds in the distributed setting and are in
NC, in the parallel setting.Comment: Full version of FSTTCS'13 pape
Generalizations of Length Limited Huffman Coding for Hierarchical Memory Settings
In this paper, we study the problem of designing prefix-free encoding schemes having minimum average code length that can be decoded efficiently under a decode cost model that captures memory hierarchy induced cost functions. We also study a special case of this problem that is closely related to the length limited Huffman coding (LLHC) problem; we call this the soft-length limited Huffman coding problem. In this version, there is a penalty associated with each of the n characters of the alphabet whose encodings exceed a specified bound D(? n) where the penalty increases linearly with the length of the encoding beyond D. The goal of the problem is to find a prefix-free encoding having minimum average code length and total penalty within a pre-specified bound P. This generalizes the LLHC problem. We present an algorithm to solve this problem that runs in time O(nD). We study a further generalization in which the penalty function and the objective function can both be arbitrary monotonically non-decreasing functions of the codeword length. We provide dynamic programming based exact and PTAS algorithms for this setting