745 research outputs found
Algebraic Methods in the Congested Clique
In this work, we use algebraic methods for studying distance computation and
subgraph detection tasks in the congested clique model. Specifically, we adapt
parallel matrix multiplication implementations to the congested clique,
obtaining an round matrix multiplication algorithm, where
is the exponent of matrix multiplication. In conjunction
with known techniques from centralised algorithmics, this gives significant
improvements over previous best upper bounds in the congested clique model. The
highlight results include:
-- triangle and 4-cycle counting in rounds, improving upon the
triangle detection algorithm of Dolev et al. [DISC 2012],
-- a -approximation of all-pairs shortest paths in
rounds, improving upon the -round -approximation algorithm of Nanongkai [STOC 2014], and
-- computing the girth in rounds, which is the first
non-trivial solution in this model.
In addition, we present a novel constant-round combinatorial algorithm for
detecting 4-cycles.Comment: This is work is a merger of arxiv:1412.2109 and arxiv:1412.266
Space-Efficient Fault-Tolerant Diameter Oracles
We design -edge fault-tolerant diameter oracles (-FDOs). We preprocess
a given graph on vertices and edges, and a positive integer , to
construct a data structure that, when queried with a set of
edges, returns the diameter of .
For a single failure () in an unweighted directed graph of diameter ,
there exists an approximate FDO by Henzinger et al. [ITCS 2017] with stretch
, constant query time, space , and a combinatorial
preprocessing time of .We
present an FDO for directed graphs with the same stretch, query time, and
space. It has a preprocessing time of .
The preprocessing time nearly matches a conditional lower bound for
combinatorial algorithms, also by Henzinger et al. With fast matrix
multiplication, we achieve a preprocessing time of . We further prove an information-theoretic lower bound
showing that any FDO with stretch better than requires bits
of space.
For multiple failures () in undirected graphs with non-negative edge
weights, we give an -FDO with stretch , query time ,
space, and preprocessing time . We
complement this with a lower bound excluding any finite stretch in
space. We show that for unweighted graphs with polylogarithmic diameter and up
to failures, one can swap approximation for query
time and space. We present an exact combinatorial -FDO with preprocessing
time , query time , and space . When using
fast matrix multiplication instead, the preprocessing time can be improved to
, where is the matrix multiplication
exponent.Comment: Full version of a paper to appear at MFCS'21. Abstract shortened to
meet ArXiv requirement
Improved Parallel Algorithms for Spanners and Hopsets
We use exponential start time clustering to design faster and more
work-efficient parallel graph algorithms involving distances. Previous
algorithms usually rely on graph decomposition routines with strict
restrictions on the diameters of the decomposed pieces. We weaken these bounds
in favor of stronger local probabilistic guarantees. This allows more direct
analyses of the overall process, giving: * Linear work parallel algorithms that
construct spanners with stretch and size in unweighted
graphs, and size in weighted graphs. * Hopsets that lead
to the first parallel algorithm for approximating shortest paths in undirected
graphs with work
Fault-Tolerant ST-Diameter Oracles
We study the problem of estimating the ST-diameter of a graph that is subject to a bounded number of edge failures. An f-edge fault-tolerant ST-diameter oracle (f-FDO-ST) is a data structure that preprocesses a given graph G, two sets of vertices S,T, and positive integer f. When queried with a set F of at most f edges, the oracle returns an estimate D? of the ST-diameter diam(G-F,S,T), the maximum distance between vertices in S and T in G-F. The oracle has stretch ? ? 1 if diam(G-F,S,T) ? D? ? ? diam(G-F,S,T). If S and T both contain all vertices, the data structure is called an f-edge fault-tolerant diameter oracle (f-FDO). An f-edge fault-tolerant distance sensitivity oracles (f-DSO) estimates the pairwise graph distances under up to f failures.
We design new f-FDOs and f-FDO-STs by reducing their construction to that of all-pairs and single-source f-DSOs. We obtain several new tradeoffs between the size of the data structure, stretch guarantee, query and preprocessing times for diameter oracles by combining our black-box reductions with known results from the literature.
We also provide an information-theoretic lower bound on the space requirement of approximate f-FDOs. We show that there exists a family of graphs for which any f-FDO with sensitivity f ? 2 and stretch less than 5/3 requires ?(n^{3/2}) bits of space, regardless of the query time
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
Conditional Hardness for Sensitivity Problems
In recent years it has become popular to study dynamic problems in a sensitivity setting: Instead of allowing for an arbitrary sequence of updates, the sensitivity model only allows to apply batch updates of small size to the original input data. The sensitivity model is particularly appealing since recent strong conditional lower bounds ruled out fast algorithms for many dynamic problems, such as shortest paths, reachability, or subgraph connectivity.
In this paper we prove conditional lower bounds for these and additional problems in a sensitivity setting. For example, we show that under the Boolean Matrix Multiplication (BMM) conjecture combinatorial algorithms cannot compute the (4/3-varepsilon)-approximate diameter of an undirected unweighted dense graph with truly subcubic preprocessing time and truly subquadratic update/query time. This result is surprising since in the static setting it is not clear whether a reduction from BMM to diameter is possible. We further show under the BMM conjecture that many problems, such as reachability or approximate shortest paths, cannot be solved faster than by recomputation from scratch even after only one or two edge insertions. We extend our reduction from BMM to Diameter to give a reduction from All Pairs Shortest Paths to Diameter under one deletion in weighted graphs. This is intriguing, as in the static setting it is a big open problem whether Diameter is as hard as APSP. We further get a nearly tight lower bound for shortest paths after two edge deletions based on the APSP conjecture. We give more lower bounds under the Strong Exponential Time Hypothesis. Many of our lower bounds also hold for static oracle data structures where no sensitivity is required.
Finally, we give the first algorithm for the (1+varepsilon)-approximate radius, diameter, and eccentricity problems in directed or undirected unweighted graphs in case of single edges failures. The algorithm has a truly subcubic running time for graphs with a truly subquadratic number of edges; it is tight w.r.t. the conditional lower bounds we obtain
Approximation Algorithms and Hardness for -Pairs Shortest Paths and All-Nodes Shortest Cycles
We study the approximability of two related problems on graphs with nodes
and edges: -Pairs Shortest Paths (-PSP), where the goal is to find a
shortest path between prespecified pairs, and All Node Shortest Cycles
(ANSC), where the goal is to find the shortest cycle passing through each node.
Approximate -PSP has been previously studied, mostly in the context of
distance oracles. We ask the question of whether approximate -PSP can be
solved faster than by using distance oracles or All Pair Shortest Paths (APSP).
ANSC has also been studied previously, but only in terms of exact algorithms,
rather than approximation. We provide a thorough study of the approximability
of -PSP and ANSC, providing a wide array of algorithms and conditional lower
bounds that trade off between running time and approximation ratio.
A highlight of our conditional lower bounds results is that for any integer
, under the combinatorial -clique hypothesis, there is no
combinatorial algorithm for unweighted undirected -PSP with approximation
ratio better than that runs in
time. This nearly matches an upper bound implied by the result of Agarwal
(2014).
A highlight of our algorithmic results is that one can solve both -PSP and
ANSC in time with approximation factor
(and additive error that is function of ), for any
constant . For -PSP, our conditional lower bounds imply that
this approximation ratio is nearly optimal for any subquadratic-time
combinatorial algorithm. We further extend these algorithms for -PSP and
ANSC to obtain a time/accuracy trade-off that includes near-linear time
algorithms.Comment: Abstract truncated to meet arXiv requirement. To appear in FOCS 202
- …