Finding Articulation Points of Large Graphs in Linear Time

Farach-Colton, Martı́n; Hsu, Tsan Sheng; Li, Meng; Tsai, Meng-Tsung

doi:10.1007/978-3-319-21840-3_30

Cited by 7 publications

(7 citation statements)

References 11 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…It is unknown whether DFS trees require more than one passes [14,31], but the current best algorithm needs Õ(h) passes due to Khan and Mehta [31], where h is the height of computed DFS trees. We devise a randomized algorithm that has pass complexity O( √ n) w.h.p., and give a smooth tradeoff between pass complexity and space usage.…”

Section: Dfs Treesmentioning

confidence: 99%

“…BFS computation is known to require ω(1) passes [17], but only the naive O(n)-pass algorithm is known. It is unknown whether DFS computation requires more than one passes [14,31], but the current best algorithm needs Õ(h) passes [31] where h is the height of the computed DFS trees, so h = O(n) for dense graphs. The tractability of maximum-leaf spanning trees (MLST) is unknown even allowing O(n 2 ) space, since it is APX-complete [35,20].…”

Section: Introductionmentioning

confidence: 99%

“…Due to the lack of efficient streaming algorithms for spanning tree computation, for some graph problems that are traditionally solved using spanning trees, such as finding articulation points and bridges, people had to look for alternative methods when designing streaming algorithms for these problems [16,14]. The alternative methods, even if they are based on known results in graph theory, may still involve the design of new streaming algorithms.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Streaming Complexity of Spanning Tree Computation

Chang¹,

Farach-Colton

Hsu

et al. 2020

Preprint

Self Cite

View full text Add to dashboard Cite

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 Õ(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 Õ(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 Õ(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.

show abstract

Section: Dfs Treesmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Streaming Complexity of Spanning Tree Computation

Chang¹,

Farach-Colton

Hsu

et al. 2020

Preprint

Self Cite

View full text Add to dashboard Cite

show abstract

“…However, computing the DFS tree in evenÕ (1) passes is considered hard [18]. To the best of our knowledge, it remains an open problem to compute the DFS tree using even o(n) passes in any relaxed streaming environment [46,50].…”

Section: Experiments On Directed Graphs and Dagsmentioning

confidence: 99%

Incremental DFS algorithms: a theoretical and experimental study

Baswana

Goel

Khan

2018

Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms

View full text Add to dashboard Cite

The depth first search (DFS) tree is a fundamental data structure used for solving various graph problems. For a given graph G = (V, E) on n vertices and m edges, a DFS tree can be built in O(m + n) time. In the last 20 years, a few algorithms have been designed for maintaining a DFS tree efficiently under insertion of edges. For undirected graphs, there are two prominent algorithms, namely, ADFS1 and ADFS2 [ICALP14] that achieve total update time of O(n 3/2 √ m) and O(n 2 ) respectively. For directed acyclic graphs, the only non-trivial algorithm, namely, FDFS [IPL97] requires total O(mn) update time. However, even after 20 years of this result, there does not exist any non-trivial incremental algorithm for maintaining a DFS tree in directed graphs with o(m 2 ) worst case bound. In this paper, we carry out extensive experimental and theoretical evaluation of the existing incremental DFS algorithms in random graphs and real world graphs and derive the following results.1. For insertion of a uniformly random sequence of n 2 edges, each of ADFS1, ADFS2 and FDFS perform equally well and are found to take Θ(n 2 ) time experimentally. This is quite surprising because the worst case bounds of ADFS1 and FDFS are greater than Θ(n 2 ) by a factor of m/n and m/n respectively, which are also proven to be tight. We complement this experimental result with a probabilistic analysis of these algorithms establishingÕ(n 2 ) 1 bound on their time complexity. For this purpose, we derive results about the structure of a DFS tree in a random graph. These results are of independent interest in the domain of random graphs. 2. The insight that we developed about DFS tree in random graphs leads us to design an extremely simple algorithm for incremental DFS that works for both undirected and directed graphs. Moreover, this algorithm theoretically matches and experimentally outperforms the state-of-the-art algorithm in dense random graphs. Furthermore, it can also be used as a single-pass semi-streaming algorithm for computing incremental DFS and strong connectivity for random graphs using O(n log n) space. 3. Even for real world graphs, which are usually sparse, both ADFS1 and FDFS turn out to be much better than their theoretical bounds. Here again, we present two simple algorithms for incremental DFS for directed and undirected graphs respectively, which perform very well on real graphs. In fact our proposed algorithm for directed graphs almost always matches the performance of FDFS.

show abstract

“…This can also be easily improved to O(h) passes, where h is the height of the computed DFS tree. Despite most applications of DFS trees in undirected graphs being efficiently solved in the semi-streaming environment [56,25,24,4,5,23,41], due to its fundamental nature DFS is considered a long standing open problem [23,49,50] even for undirected graphs. Moreover, computing a DFS tree in O(poly log n) passes is considered hard [23].…”

Section: Introductionmentioning

confidence: 99%

Depth First Search in the Semi-streaming Model

Khan¹,

Mehta²

2019

Preprint

View full text Add to dashboard Cite

Depth first search (DFS) tree is a fundamental data structure for solving various graph problems. The classical algorithm for building a DFS tree requires O(m + n) time for a given undirected graph G having n vertices and m edges. In the streaming model, an algorithm is allowed several passes (preferably single) over the input graph having a restriction on the size of local space used. Now, a DFS tree of a graph can be trivially computed using a single pass if O(m) space is allowed. In the semi-streaming model allowing O(n) space, it can be computed in O(n) passes over the input stream, where each pass adds one vertex to the DFS tree. However, it remains an open problem to compute a DFS tree using o(n) passes using o(m) space even in any relaxed streaming environment.We present the first semi-streaming algorithms that compute a DFS tree of an undirected graph in o(n) passes using o(m) space. We first describe an extremely simple algorithm that requires at most n/k passes to compute a DFS tree using O(nk) space, where k is any positive integer. For example using k = √ n, we can compute a DFS tree in √ n passes using O(n √ n) space. We then improve this algorithm by using more involved techniques to reduce the number of passes to h/k under similar space constraints, where h is the height of the computed DFS tree. In particular, this algorithm improves the bounds for the case where the computed DFS tree is shallow (having o(n) height). Moreover, this algorithm is presented in form of a framework that allows the flexibility of using any algorithm to maintain a DFS tree of a stored sparser subgraph as a black box, which may be of an independent interest. Both these algorithms essentially demonstrate the existence of a trade-off between the space and number of passes required for computing a DFS tree. Furthermore, we evaluate these algorithms experimentally which reveals their exceptional performance in practice. For both random and real graphs, they require merely a few passes even when allowed just O(n) space.

show abstract

Finding Articulation Points of Large Graphs in Linear Time

Cited by 7 publications

References 11 publications

Streaming Complexity of Spanning Tree Computation

Streaming Complexity of Spanning Tree Computation

Incremental DFS algorithms: a theoretical and experimental study

Depth First Search in the Semi-streaming Model

Contact Info

Product

Resources

About