Linear-Time In-Place DFS and BFS on the Word RAM

Research on space efficient graph algorithms, particularly for st-connectivity, has a long history including the celebrated polynomial time, O(lg n) bits1 algorithm in undirected graphs by Reingold J. JACM. 55(4) (2008), and polynomial time, \(n/2^{\Theta (\sqrt {\lg n})}\) bits algorithm in directed graphs by Barnes et al. SICOMP. 27(5), 1273–1282 (1998). Recent works by Asano et al. ISAAC (2014) and Elmasry et al. STACS (2015), reconsidered classical fundamental graph algorithms focusing on improving the space complexity. Elmasry et al. gave, among others, an implementation of breadth first search (BFS) in a graph G with n vertices and m edges, taking the optimal O(m + n) time using O(n) bits improving the naive O(n lg n) bits implementation. Similarly, Asano et al. provided space efficient implementations for performing depth first search (DFS) in a graph G. We continue this line of work focusing on improving the space requirement for implementing a few classical graph algorithms. Our first result is a simple data structure that can maintain any subset S of a universe of u elements using just u + o(u) bits and supports in constant time, apart from the standard insert, delete and membership queries, the operation findany that finds and returns any element of the set (or outputs that the set is empty). It can also enumerate all elements present currently in the set in no particular order in O(k + 1) time where k is the number of elements currently belonging to the set. While this data structure supports a weaker set of operations than that of Elmasry et al. STACS (2015), it is simple, more space efficient and is sufficient to support a BFS implementation optimally in O(m + n) time using at most 2n + o(n) bits. Later, we further improve the space requirement of BFS to at most n lg 3 + o(n) bits albeit with a slight increase in running time to O(m lg nf(n)) time where f(n) is any extremely slow growing function of n, and the o term in the space is a function of f(n). We also discuss a similar time-space tradeoff result for finding a minimum weight spanning tree of a weighted (bounded by polynomial in n) undirected graph using n + O(n/f(n)) bits and O(m lg nf(n)) time, for any function f(n) such that 1 ≤ f(n) ≤ n. For DFS in a graph G, we provide an implementation taking O(m + n) time and O(n lg m/n) bits. This partially answers at least for sparse graphs, a question asked by Asano et al. ISAAC (2014) whether DFS can be performed in O (m + n) time and using O(n) bits, and also simultaneously improves the DFS result of Elmasry et al. STACS (2015). Using our DFS algorithm and other careful implementations, we show how one can also test for biconnectivity, 2-edge connectivity, and find cut vertices and bridges of a given undirected graph within the same time and space bounds; earlier classical linear time algorithms for these problems used Ω(n lg n) bits of space.

We present linear-I/O algorithms for fundamental graph problems on embedded outerplanar graphs. We show that breadth-first search, depth-first search, single-source shortest paths, triangulation, and computing an � separator of size O(1/� )t akeO(scan(N)) I/Os on embedded outerplanar graphs. We also show that it takes O(sort(N)) I/Os to test whether a given graph is outerplanar and to compute an outerplanar embedding of an outerplanar graph, thereby providing O(sort(N))-I/O algorithms for the above problems if no embedding of the graph is given. As all these problems have linear-time algorithms in internal memory, a simple simulation technique can be used to improve the I/O-complexity of our algorithms from O(sort(N)) to O(perm(N)). We prove matching lower bounds for embedding, breadth-first search, depth-first search, and singlesource shortest paths if no embedding is given. Our algorithms for the above problems use a simple linear-I/O time-forward processing algorithm for rooted trees whose vertices are stored in preorder.

We initiate the systematic study of the energy complexity of algorithms (in addition to time and space complexity) based on Landauer's Principle in physics, which gives a lower bound on the amount of energy a system must dissipate if it destroys information. We propose energy-aware variations of three standard models of computation: circuit RAM, word RAM, and transdichotomous RAM. On top of these models, we build familiar high-level primitives such as control logic, memory allocation, and garbage collection with zero energy complexity and only constant-factor overheads in space and time complexity, enabling simple expression of energy-efficient algorithms. We analyze several classic algorithms in our models and develop low-energy variations: comparison sort, insertion sort, counting sort, breadth-first search, Bellman-Ford, Floyd-Warshall, matrix all-pairs shortest paths, AVL trees, binary heaps, and dynamic arrays. We explore the time/space/energy trade-off and develop several general techniques for analyzing algorithms and reducing their energy complexity. These results lay a theoretical foundation for a new field of semi-reversible computing and provide a new framework for the investigation of algorithms.

Graph searching is one of the simplest and most widely used tools in graph algorithms. Every graph search method is defined using some partic-ular selection rule, and the analysis of the corre-sponding vertex orderings can aid greatly in de-vising algorithms, writing proofs of correctness, or recognition of various graph families. We study graphs where the sets of vertex order-ings produced by two di˙erent search methods coincide. We characterise such graph families for ten pairs from the best-known set of graph searches: Breadth First Search (BFS), Depth First Search (DFS), Lexicographic Breadth First Search (LexBFS) and Lexicographic Depth First Search (LexDFS), and Maximal Neighborhood Search (MNS).

Logic synthesis with reversible circuits has received considerable interest in the light of advances recently made in quantum computation. In this paper, we propose an improved technique for synthesizing reversible circuits based on a combined depth-first search (DFS) and breadth-first search (BFS) algorithm. A method based on DFS alone may often take a long time to converge, whereas, a BFS based method requires a large amount of memory for designing a circuit of moderate complexity. To strike a balance between these two approaches, we propose a hybrid DFS-BFS based synthesis algorithm that reduces the computation time compared to the DFS method and requires less space compared to the BFS method, while optimizing the cost of the circuit. Synthesis results on several reversible benchmark circuits have been reported.

Symbolic Execution is a widely used technique for program testing and analysis. When a program executes a trace symbolically, it simulates all possible paths. This results in an exponential growth of the number of states within the problem, which is commonly referred to as path explosion. We therefore propose novel strategies that only require limited resources to give priority to more valuable paths. In this paper, we utilize a method based on the Monte Carlo tree search (MCTS) strategy to resolve the problem. We then compare the proposed MCTS-based strategy with other methods such as depth-first search (DFS) and breadth-first search (BFS). We also perform different scales of experiments based on time and space resource constraints. For smaller test cases, we found that MCTS performs on average 1.4 times better than BFS and DFS in terms of the block discovery rate. In addition, for larger test cases, MCTS performs on average 2.8 times better than DFS and BFS in terms of the block discovery rate.

Efficient access to timely information is critical in today's digital era. Web crawlers, automated programs that navigate the Internet, play an important role in collecting data from websites such as Kumparan, a leading news site in Indonesia. This research shows the effectiveness of the Breadth-First Search (BFS) and Depth-First Search (DFS) algorithms in indexing Kumparan content. The results of the research show that BFS consistently indexes more files comprehensively but with longer execution times compared to DFS, which provides faster initial results but with fewer files. For example, at depth 4 BFS indexed 949 files in 886.94 seconds, while DFS indexed 470 files in 233.02 seconds. These findings highlight the balance between precision and speed when selecting a crawling algorithm tailored to the needs of a particular website. This research provides insights into optimizing web crawler technology for complex websites such as Coil and suggests avenues for further research to improve permission efficiency and adaptability across a variety of crawling scenarios.

Mining maximal hyperclique pattern: A hybrid search strategy

Even though a large number of I/O-efficient graph algorithms have been developed, a number of fundamental problems still remain open. For example, no space- and I/O-efficient algorithms are known for depth-first search or breadth-first search in sparse graphs. In this paper we present two new results on I/O-efficient depth-first search in an important class of sparse graphs, namely undirected embedded planar graphs. We develop a new efficient depth-first search algorithm and show how planar depth-first search in general can be reduced to planar breadth-first search. As part of the first result we develop the first I/O-efficient algorithm for finding a simple cycle separator of a biconnected planar graph. Together with other recent reducibility results, the second result provides further evidence that external memory breadth-first search is among the hardest problems on planar graphs.

Even though a large number of I/O-efficient graph algorithms have been developed, a number of fundamental problems still remain open. For example, no space- and I/O-efficient algorithms are known for depth-first search or breadth-first search in sparse graphs. In this paper we present two new results on I/O-efficient depth-first search in an important class of sparse graphs, namely undirected embedded planar graphs. We develop a new efficient depth-first search algorithm and show how planar depth-first search in general can be reduced to planar breadth-first search. As part of the first result we develop the first I/O-efficient algorithm for finding a simple cycle separator of a biconnected planar graph. Together with other recent reducibility results, the second result provides further evidence that external memory breadth-firstsearch is among the hardest problems on planar graphs.KeywordsPlanar GraphExternal MemorySimple CycleOuterplanar GraphBoundary CycleThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Pathfinding is the algorithmic interpretation and implementation of attaining the shortest route(s) from a given source(s) to destination(s). While the paradigm falls under generic graph theory, there has been much research about different heuristic algorithms. The fundamental aspects of choosing the best-fit (least cost) route implies certain heuristics to be followed. In this section we will try to understand the different concepts of heuristic search algorithms, starting from basic Dijkstra Algorithm to variants of A* (A star). The need for different search algorithms is extremely essential since generic exhaustive algorithms such as breadth-first search (BFS) and depth first search (DFS) are not feasible for games, simulations, and robotics. As we proceed into the depths of each heuristic algorithm, we will encounter different trade-off metrics being employed, from time complexity to space complexity. We will also explore the fundamental aspects of navigation meshes and how to create an intelligent pathfinding agent that gets rewards when it reaches and finds the target object.

The Water Jug problem is a famous problem in Artificial Intelligence, Problem solving, Recreational, Computer Programming and Psychology. The solution of the problem mainly based on heuristic approach or some search methods such as Breadth First Search (BFS) or Depth First Search (DFS) or Diophantine approach or Extended Euclidean approach. The existing methods of solutions are often non-algorithmic in nature. In this paper, we present an algorithmic approach to solve this problem and describe its implementation in Excel. Illustrative examples are provided.

This review identifies graph traversal methods as fundamental steps in network analysis that facilitate easy examination of relations within the network. In this review, we plan to discuss multiple graph traversal approaches like depth first search (DFS), breadth first search (BFS), their varieties and indicate how these techniques can be used in practice when analyzing networks. The following is a review methodology covering 10 articles for years 2019 – 2024. The study responds to the question of how to select algorithms for various types of networks with reference to their computational cost and speed. Thus, the authors describe the advantages and drawbacks of the reported techniques, and the topics serve as recommendations for the further advancement of technology. In this respect, the present review also serves to help to close the divide between theory and practice.

• Rooted rules are essential for fast rule-based graph algorithms. • Cycle graphs, trees, binary DAGs can be recognised by graph reduction in linear time. • Topological sorting has a linear-time implementation in the rule-based language GP 2. • Depth-first search and 2-colouring have linear-time implementations in GP 2. Implementing graph algorithms efficiently in a rule-based language is challenging because graph pattern matching is expensive. In this paper, we present a number of linear-time implementations of graph algorithms in GP 2, an experimental programming language based on graph transformation rules which aims to facilitate program analysis and verification. We focus on two classes of rule-based graph programs: graph reduction programs which check some graph property, and programs using a depth-first search to test some property or perform an operation such as producing a 2-colouring or a topological sorting. Programs of the first type run in linear time without any constraints on input graphs while programs of the second type require input graphs of bounded degree to run in linear time. Essential for achieving the linear time complexity are so-called rooted rules in GP 2, which, in many situations, can be matched in constant time. For each of our programs, we prove both correctness and complexity, and also give empirical evidence for their runtime.

This paper proposes a new algorithm for detecting and generating simple circuits within a directed graph. Before generating all simple circuits in a directed graph, the algorithm first detects whether there is a simple circuit in directed graph, and the detection can divide the directed graph into trivial graphs or strongly connected components. In the process of detecting the existence of simple circuit, the algorithm repeatedly reduces the number of vertices in vertex set along with edge pruning. Based on depth-first traversal, we can get all simple circuits of the directed graph. Especially, instead of proceeding depth-first traversals based on all vertices, the algorithm starts with a random vertex in a strongly connected component to reduce the number of depth-first traversals, and obtain all simple circuits of this strongly connected component. The difficulty of the algorithm is to detect and delete the repeated circuits in the process of generating all simple circuits, which can reduce both the storage space and time complexity. As a result, the output of the algorithm does not contain any repeated circuits. The algorithm simplifies the edge set of directed graphs and greatly reduces the number of depth-first traversals, thereby reducing the computational complexity and improving the computational efficiency.