1,068 research outputs found
Truthful Facility Assignment with Resource Augmentation: An Exact Analysis of Serial Dictatorship
We study the truthful facility assignment problem, where a set of agents with
private most-preferred points on a metric space are assigned to facilities that
lie on the metric space, under capacity constraints on the facilities. The goal
is to produce such an assignment that minimizes the social cost, i.e., the
total distance between the most-preferred points of the agents and their
corresponding facilities in the assignment, under the constraint of
truthfulness, which ensures that agents do not misreport their most-preferred
points.
We propose a resource augmentation framework, where a truthful mechanism is
evaluated by its worst-case performance on an instance with enhanced facility
capacities against the optimal mechanism on the same instance with the original
capacities. We study a very well-known mechanism, Serial Dictatorship, and
provide an exact analysis of its performance. Although Serial Dictatorship is a
purely combinatorial mechanism, our analysis uses linear programming; a linear
program expresses its greedy nature as well as the structure of the input, and
finds the input instance that enforces the mechanism have its worst-case
performance. Bounding the objective of the linear program using duality
arguments allows us to compute tight bounds on the approximation ratio. Among
other results, we prove that Serial Dictatorship has approximation ratio
when the capacities are multiplied by any integer . Our
results suggest that even a limited augmentation of the resources can have
wondrous effects on the performance of the mechanism and in particular, the
approximation ratio goes to 1 as the augmentation factor becomes large. We
complement our results with bounds on the approximation ratio of Random Serial
Dictatorship, the randomized version of Serial Dictatorship, when there is no
resource augmentation
Depth-Independent Lower bounds on the Communication Complexity of Read-Once Boolean Formulas
We show lower bounds of and on the
randomized and quantum communication complexity, respectively, of all
-variable read-once Boolean formulas. Our results complement the recent
lower bound of by Leonardos and Saks and
by Jayram, Kopparty and Raghavendra for
randomized communication complexity of read-once Boolean formulas with depth
. We obtain our result by "embedding" either the Disjointness problem or its
complement in any given read-once Boolean formula.Comment: 5 page
Parameterized Algorithms for Graph Partitioning Problems
In parameterized complexity, a problem instance (I, k) consists of an input I and an
extra parameter k. The parameter k usually a positive integer indicating the size of the
solution or the structure of the input. A computational problem is called fixed-parameter
tractable (FPT) if there is an algorithm for the problem with time complexity O(f(k).nc
),
where f(k) is a function dependent only on the input parameter k, n is the size of the
input and c is a constant. The existence of such an algorithm means that the problem
is tractable for fixed values of the parameter. In this thesis, we provide parameterized
algorithms for the following NP-hard graph partitioning problems:
(i) Matching Cut Problem: In an undirected graph, a matching cut is a partition
of vertices into two non-empty sets such that the edges across the sets induce a matching.
The matching cut problem is the problem of deciding whether a given graph has
a matching cut. The Matching Cut problem is expressible in monadic second-order
logic (MSOL). The MSOL formulation, together with Courcelle’s theorem implies linear
time solvability on graphs with bounded tree-width. However, this approach leads to a
running time of f(||ϕ||, t) · n, where ||ϕ|| is the length of the MSOL formula, t is the
tree-width of the graph and n is the number of vertices of the graph. The dependency of
f(||ϕ||, t) on ||ϕ|| can be as bad as a tower of exponentials.
In this thesis we give a single exponential algorithm for the Matching Cut problem
with tree-width alone as the parameter. The running time of the algorithm is 2O(t)
· n.
This answers an open question posed by Kratsch and Le [Theoretical Computer Science,
2016]. We also show the fixed parameter tractability of the Matching Cut problem
when parameterized by neighborhood diversity or other structural parameters.
(ii) H-Free Coloring Problems: In an undirected graph G for a fixed graph H,
the H-Free q-Coloring problem asks to color the vertices of the graph G using at
most q colors such that none of the color classes contain H as an induced subgraph.
That is every color class is H-free. This is a generalization of the classical q-Coloring
problem, which is to color the vertices of the graph using at most q colors such that no
pair of adjacent vertices are of the same color. The H-Free Chromatic Number is
the minimum number of colors required to H-free color the graph.
For a fixed q, the H-Free q-Coloring problem is expressible in monadic secondorder
logic (MSOL). The MSOL formulation leads to an algorithm with time complexity
f(||ϕ||, t) · n, where ||ϕ|| is the length of the MSOL formula, t is the tree-width of the
graph and n is the number of vertices of the graph.
In this thesis we present the following explicit combinatorial algorithms for H-Free
Coloring problems:
• An O(q
O(t
r
)
· n) time algorithm for the general H-Free q-Coloring problem,
where r = |V (H)|.
• An O(2t+r log t
· n) time algorithm for Kr-Free 2-Coloring problem, where Kr is
a complete graph on r vertices.
The above implies an O(t
O(t
r
)
· n log t) time algorithm to compute the H-Free Chromatic
Number for graphs with tree-width at most t. Therefore H-Free Chromatic
Number is FPT with respect to tree-width.
We also address a variant of H-Free q-Coloring problem which we call H-(Subgraph)Free
q-Coloring problem, which is to color the vertices of the graph such that none of the
color classes contain H as a subgraph (need not be induced).
We present the following algorithms for H-(Subgraph)Free q-Coloring problems.
• An O(q
O(t
r
)
· n) time algorithm for the general H-(Subgraph)Free q-Coloring
problem, which leads to an O(t
O(t
r
)
· n log t) time algorithm to compute the H-
(Subgraph)Free Chromatic Number for graphs with tree-width at most t.
• An O(2O(t
2
)
· n) time algorithm for C4-(Subgraph)Free 2-Coloring, where C4
is a cycle on 4 vertices.
• An O(2O(t
r−2
)
· n) time algorithm for {Kr\e}-(Subgraph)Free 2-Coloring,
where Kr\e is a graph obtained by removing an edge from Kr.
• An O(2O((tr2
)
r−2
)
· n) time algorithm for Cr-(Subgraph)Free 2-Coloring problem,
where Cr is a cycle of length r.
(iii) Happy Coloring Problems: In a vertex-colored graph, an edge is happy if its
endpoints have the same color. Similarly, a vertex is happy if all its incident edges are
happy. we consider the algorithmic aspects of the following Maximum Happy Edges
(k-MHE) problem: given a partially k-colored graph G, find an extended full k-coloring
of G such that the number of happy edges are maximized. When we want to maximize
the number of happy vertices, the problem is known as Maximum Happy Vertices
(k-MHV).
We show that both k-MHE and k-MHV admit polynomial-time algorithms for trees.
We show that k-MHE admits a kernel of size k + `, where ` is the natural parameter,
the number of happy edges. We show the hardness of k-MHE and k-MHV for some
special graphs such as split graphs and bipartite graphs. We show that both k-MHE
and k-MHV are tractable for graphs with bounded tree-width and graphs with bounded
neighborhood diversity.
vii
In the last part of the thesis we present an algorithm for the Replacement Paths
Problem which is defined as follows: Let G (|V (G)| = n and |E(G)| = m) be an undirected
graph with positive edge weights. Let PG(s, t) be a shortest s − t path in G. Let l be the
number of edges in PG(s, t). The Edge Replacement Path problem is to compute a
shortest s − t path in G\{e}, for every edge e in PG(s, t). The Node Replacement
Path problem is to compute a shortest s−t path in G\{v}, for every vertex v in PG(s, t).
We present an O(TSP T (G) + m + l
2
) time and O(m + l
2
) space algorithm for both
the problems, where TSP T (G) is the asymptotic time to compute a single source shortest
path tree in G. The proposed algorithm is simple and easy to implement
Competitive Analysis for Two Variants of Online Metric Matching Problem
14th International Conference, COCOA 2020, Dallas, TX, USA, December 11–13, 2020
Competitive Analysis for Two Variants of Online Metric Matching Problem
In this paper, we study two variants of the online metric matching problem.
The first problem is the online metric matching problem where all the servers
are placed at one of two positions in the metric space. We show that a simple
greedy algorithm achieves the competitive ratio of 3 and give a matching lower
bound. The second problem is the online facility assignment problem on a line,
where servers have capacities, servers and requests are placed on 1-dimensional
line, and the distances between any two consecutive servers are the same. We
show lower bounds ,
and on the competitive ratio when the
numbers of servers are 3, 4 and 5, respectively.Comment: 12 pages. Update from the 1st version: The first author was added and
Theorems 3, 4 and 5 were improve
On Packet Scheduling with Adversarial Jamming and Speedup
In Packet Scheduling with Adversarial Jamming packets of arbitrary sizes
arrive over time to be transmitted over a channel in which instantaneous
jamming errors occur at times chosen by the adversary and not known to the
algorithm. The transmission taking place at the time of jamming is corrupt, and
the algorithm learns this fact immediately. An online algorithm maximizes the
total size of packets it successfully transmits and the goal is to develop an
algorithm with the lowest possible asymptotic competitive ratio, where the
additive constant may depend on packet sizes.
Our main contribution is a universal algorithm that works for any speedup and
packet sizes and, unlike previous algorithms for the problem, it does not need
to know these properties in advance. We show that this algorithm guarantees
1-competitiveness with speedup 4, making it the first known algorithm to
maintain 1-competitiveness with a moderate speedup in the general setting of
arbitrary packet sizes. We also prove a lower bound of on
the speedup of any 1-competitive deterministic algorithm, showing that our
algorithm is close to the optimum.
Additionally, we formulate a general framework for analyzing our algorithm
locally and use it to show upper bounds on its competitive ratio for speedups
in and for several special cases, recovering some previously known
results, each of which had a dedicated proof. In particular, our algorithm is
3-competitive without speedup, matching both the (worst-case) performance of
the algorithm by Jurdzinski et al. and the lower bound by Anta et al.Comment: Appeared in Proc. of the 15th Workshop on Approximation and Online
Algorithms (WAOA 2017
Improved Quantum Communication Complexity Bounds for Disjointness and Equality
We prove new bounds on the quantum communication complexity of the
disjointness and equality problems. For the case of exact and non-deterministic
protocols we show that these complexities are all equal to n+1, the previous
best lower bound being n/2. We show this by improving a general bound for
non-deterministic protocols of de Wolf. We also give an O(sqrt{n}c^{log^*
n})-qubit bounded-error protocol for disjointness, modifying and improving the
earlier O(sqrt{n}log n) protocol of Buhrman, Cleve, and Wigderson, and prove an
Omega(sqrt{n}) lower bound for a large class of protocols that includes the
BCW-protocol as well as our new protocol.Comment: 11 pages LaTe
Distributed Minimum Cut Approximation
We study the problem of computing approximate minimum edge cuts by
distributed algorithms. We use a standard synchronous message passing model
where in each round, bits can be transmitted over each edge (a.k.a.
the CONGEST model). We present a distributed algorithm that, for any weighted
graph and any , with high probability finds a cut of size
at most in
rounds, where is the size of the minimum cut. This algorithm is based
on a simple approach for analyzing random edge sampling, which we call the
random layering technique. In addition, we also present another distributed
algorithm, which is based on a centralized algorithm due to Matula [SODA '93],
that with high probability computes a cut of size at most
in rounds for any .
The time complexities of both of these algorithms almost match the
lower bound of Das Sarma et al. [STOC '11], thus
leading to an answer to an open question raised by Elkin [SIGACT-News '04] and
Das Sarma et al. [STOC '11].
Furthermore, we also strengthen the lower bound of Das Sarma et al. by
extending it to unweighted graphs. We show that the same lower bound also holds
for unweighted multigraphs (or equivalently for weighted graphs in which
bits can be transmitted in each round over an edge of weight ),
even if the diameter is . For unweighted simple graphs, we show
that even for networks of diameter , finding an -approximate minimum cut
in networks of edge connectivity or computing an
-approximation of the edge connectivity requires rounds
- …