38 research outputs found
Triangle-Free Penny Graphs: Degeneracy, Choosability, and Edge Count
We show that triangle-free penny graphs have degeneracy at most two, list
coloring number (choosability) at most three, diameter , and
at most edges.Comment: 10 pages, 2 figures. To appear at the 25th International Symposium on
Graph Drawing and Network Visualization (GD 2017
Streaming Complexity of Spanning Tree Computation
The semi-streaming model is a variant of the streaming model frequently used for the computation of graph problems. It allows the edges of an n-node input graph to be read sequentially in p passes using OÌ(n) space. If the list of edges includes deletions, then the model is called the turnstile model; otherwise it is called the insertion-only model. In both models, some graph problems, such as spanning trees, k-connectivity, densest subgraph, degeneracy, cut-sparsifier, and (Î+1)-coloring, can be exactly solved or (1+Δ)-approximated in a single pass; while other graph problems, such as triangle detection and unweighted all-pairs shortest paths, are known to require ΩÌ(n) passes to compute. For many fundamental graph problems, the tractability in these models is open. In this paper, we study the tractability of computing some standard spanning trees, including BFS, DFS, and maximum-leaf spanning trees. Our results, in both the insertion-only and the turnstile models, are as follows.
Maximum-Leaf Spanning Trees: This problem is known to be APX-complete with inapproximability constant Ï â [245/244, 2). By constructing an Δ-MLST sparsifier, we show that for every constant Δ > 0, MLST can be approximated in a single pass to within a factor of 1+Δ w.h.p. (albeit in super-polynomial time for Δ †Ï-1 assuming P â NP) and can be approximated in polynomial time in a single pass to within a factor of Ï_n+Δ w.h.p., where Ï_n is the supremum constant that MLST cannot be approximated to within using polynomial time and OÌ(n) space. In the insertion-only model, these algorithms can be deterministic.
BFS Trees: It is known that BFS trees require Ï(1) passes to compute, but the naĂŻve approach needs O(n) passes. We devise a new randomized algorithm that reduces the pass complexity to O(ân), and it offers a smooth tradeoff between pass complexity and space usage. This gives a polynomial separation between single-source and all-pairs shortest paths for unweighted graphs.
DFS Trees: It is unknown whether DFS trees require more than one pass. The current best algorithm by Khan and Mehta [STACS 2019] takes OÌ(h) passes, where h is the height of computed DFS trees. Note that h can be as large as Ω(m/n) for n-node m-edge graphs. Our contribution is twofold. First, we provide a simple alternative proof of this result, via a new connection to sparse certificates for k-node-connectivity. Second, we present a randomized algorithm that reduces the pass complexity to O(ân), and it also offers a smooth tradeoff between pass complexity and space usage.ISSN:1868-896
How Fast Can We Play Tetris Greedily With Rectangular Pieces?
Consider a variant of Tetris played on a board of width and infinite
height, where the pieces are axis-aligned rectangles of arbitrary integer
dimensions, the pieces can only be moved before letting them drop, and a row
does not disappear once it is full. Suppose we want to follow a greedy
strategy: let each rectangle fall where it will end up the lowest given the
current state of the board. To do so, we want a data structure which can always
suggest a greedy move. In other words, we want a data structure which maintains
a set of rectangles, supports queries which return where to drop the
rectangle, and updates which insert a rectangle dropped at a certain position
and return the height of the highest point in the updated set of rectangles. We
show via a reduction to the Multiphase problem [P\u{a}tra\c{s}cu, 2010] that on
a board of width , if the OMv conjecture [Henzinger et al., 2015]
is true, then both operations cannot be supported in time
simultaneously. The reduction also implies polynomial bounds from the 3-SUM
conjecture and the APSP conjecture. On the other hand, we show that there is a
data structure supporting both operations in time on
boards of width , matching the lower bound up to a factor.Comment: Correction of typos and other minor correction
Finding Small Complete Subgraphs Efficiently
(I) We revisit the algorithmic problem of finding all triangles in a graph
with vertices and edges. According to a result of Chiba and
Nishizeki (1985), this task can be achieved by a combinatorial algorithm
running in time, where is the
graph arboricity. We provide a new very simple combinatorial algorithm for
finding all triangles in a graph and show that is amenable to the same running
time analysis. We derive these worst-case bounds from first principles and with
very simple proofs that do not rely on classic results due to Nash-Williams
from the 1960s.
(II) We extend our arguments to the problem of finding all small complete
subgraphs of a given fixed size. We show that the dependency on and
in the running time of the algorithm of
Chiba and Nishizeki for listing all copies of , where , is
asymptotically tight.
(III) We give improved arboricity-sensitive running times for counting and/or
detection of copies of , for small . A key ingredient in
our algorithms is, once again, the algorithm of Chiba and Nishizeki. Our new
algorithms are faster than all previous algorithms in certain high-range
arboricity intervals for every .Comment: 14 pages, 1 figure. arXiv admin note: substantial text overlap with
arXiv:2105.0126
Decomposing a Graph into Shortest Paths with Bounded Eccentricity
We introduce the problem of hub-laminar decomposition which generalizes that of computing a shortest path with minimum eccentricity (MESP). Intuitively, it consists in decomposing a graph into several paths that collectively have small eccentricity and meet only near their extremities. The problem is related to computing an isometric cycle with minimum eccentricity (MEIC). It is also linked to DNA reconstitution in the context of metagenomics in biology. We show that a graph having such a decomposition with long enough paths can be decomposed in polynomial time with approximated guaranties on the parameters of the decomposition. Moreover, such a decomposition with few paths allows to compute a compact representation of distances with additive distortion. We also show that having an isometric cycle with small eccentricity is related to the possibility of embedding the graph in a cycle with low distortion
Independent-Set Reconfiguration Thresholds of Hereditary Graph Classes
Traditionally, reconfiguration problems ask the question whether a given solution of an optimization problem can be transformed to a target solution in a sequence of small steps that preserve feasibility of the intermediate solutions. In this paper, rather than asking this question from an algorithmic perspective, we analyze the combinatorial structure behind it. We consider the problem of reconfiguring one independent set into another, using two different processes: (1) exchanging exactly k vertices in each step, or (2) removing or adding one vertex in each step while ensuring the intermediate sets contain at most k fewer vertices than the initial solution. We are interested in determining the minimum value of k for which this reconfiguration is possible, and bound these threshold values in terms of several structural graph parameters. For hereditary graph classes we identify structures that cause the reconfiguration threshold to be large
Worst-Case Efficient Sorting with QuickMergesort
The two most prominent solutions for the sorting problem are Quicksort and
Mergesort. While Quicksort is very fast on average, Mergesort additionally
gives worst-case guarantees, but needs extra space for a linear number of
elements. Worst-case efficient in-place sorting, however, remains a challenge:
the standard solution, Heapsort, suffers from a bad cache behavior and is also
not overly fast for in-cache instances.
In this work we present median-of-medians QuickMergesort (MoMQuickMergesort),
a new variant of QuickMergesort, which combines Quicksort with Mergesort
allowing the latter to be implemented in place. Our new variant applies the
median-of-medians algorithm for selecting pivots in order to circumvent the
quadratic worst case. Indeed, we show that it uses at most
comparisons for large enough.
We experimentally confirm the theoretical estimates and show that the new
algorithm outperforms Heapsort by far and is only around 10% slower than
Introsort (std::sort implementation of stdlibc++), which has a rather poor
guarantee for the worst case. We also simulate the worst case, which is only
around 10% slower than the average case. In particular, the new algorithm is a
natural candidate to replace Heapsort as a worst-case stopper in Introsort