Engineering DFS-Based Graph Algorithms

Depth-first search (DFS) is the basis for many efficient graph algorithms. We introduce general techniques for the efficient implementation of DFS-based graph algorithms and exemplify them on three algorithms for computing strongly connected components. The techniques lead to speed-ups by a factor of two to three compared to the implementations provided by LEDA and BOOST. We have obtained similar speed-ups for biconnected components algorithms. We also compare the graph data types of LEDA and BOOST

Sublinear-Space Lexicographic Depth-First Search for Bounded Treewidth Graphs and Planar Graphs

The lexicographic depth-first search (Lex-DFS) is one of the first basic graph problems studied in the context of space-efficient algorithms. It is shown independently by Asano et al. [ISAAC 2014] and Elmasry et al. [STACS 2015] that Lex-DFS admits polynomial-time algorithms that run with O(n)-bit working memory, where n is the number of vertices in the graph. Lex-DFS is known to be P-complete under logspace reduction, and giving or ruling out polynomial-time sublinear-space algorithms for Lex-DFS on general graphs is quite challenging. In this paper, we study Lex-DFS on graphs of bounded treewidth. We first show that given a tree decomposition of width O(n^(1-?)) with ? > 0, Lex-DFS can be solved in sublinear space. We then complement this result by presenting a space-efficient algorithm that can compute, for w ? ?n, a tree decomposition of width O(w ?nlog n) or correctly decide that the graph has a treewidth more than w. This algorithm itself would be of independent interest as the first space-efficient algorithm for computing a tree decomposition of moderate (small but non-constant) width. By combining these results, we can show in particular that graphs of treewidth O(n^(1/2 - ?)) for some ? > 0 admits a polynomial-time sublinear-space algorithm for Lex-DFS. We can also show that planar graphs admit a polynomial-time algorithm with O(n^(1/2+?))-bit working memory for Lex-DFS

An Implementation of External-Memory Depth-First Search

In many different areas of computing, problems can arise which are too large to fit in main memory. For these problems, the I/O cost of moving data between main memory and secondary storage (for example, disks) becomes a significant bottleneck affecting the performance of the program. Since most algorithms do not take into account the size of main memory, new algorithms have been developed to optimize the number of I/O\u27s performed. This paper details the implementation of one such algorithm, for external-memory depth-first search. Depth-first search is a basic tool for solving many problems in graph theory, and since graph theory is applicable for many large computational problems, it is important to make sure that such a basic tool is designed to avoid the bottleneck of main memory to secondary storage I/O\u27s. The algorithm whose implementation is described in this paper is sketched out in an extended abstract by Chiang et al. We attempt to improve the given algorithm by minimizing I/O\u27s performed, and to extend the algorithm by finding disjoint trees, and by classifying all the edges in the problem

Space-efficient Basic Graph Algorithms

We reconsider basic algorithmic graph problems in a setting where an n-vertex input graph is read-only and the computation must take place in a working memory of O(n) bits or little more than that. For computing connected components and performing breadth-first search, we match the running times of standard algorithms that have no memory restrictions, for depth-first search and related problems we come within a factor of Theta(loglog n), and for computing minimum spanning forests and single-source shortest-paths trees we come close for sparse input graphs

Isogeny graphs with maximal real multiplication

An isogeny graph is a graph whose vertices are principally polarized abelian varieties and whose edges are isogenies between these varieties. In his thesis, Kohel described the structure of isogeny graphs for elliptic curves and showed that one may compute the endomorphism ring of an elliptic curve defined over a finite field by using a depth first search algorithm in the graph. In dimension 2, the structure of isogeny graphs is less understood and existing algorithms for computing endomorphism rings are very expensive. Our setting considers genus 2 jacobians with complex multiplication, with the assumptions that the real multiplication subring is maximal and has class number one. We fully describe the isogeny graphs in that case. Over finite fields, we derive a depth first search algorithm for computing endomorphism rings locally at prime numbers, if the real multiplication is maximal. To the best of our knowledge, this is the first DFS-based algorithm in genus 2