2,149 research outputs found
Incremental Cycle Detection, Topological Ordering, and Strong Component Maintenance
We present two on-line algorithms for maintaining a topological order of a
directed -vertex acyclic graph as arcs are added, and detecting a cycle when
one is created. Our first algorithm handles arc additions in
time. For sparse graphs (), this bound improves the best previous
bound by a logarithmic factor, and is tight to within a constant factor among
algorithms satisfying a natural {\em locality} property. Our second algorithm
handles an arbitrary sequence of arc additions in time. For
sufficiently dense graphs, this bound improves the best previous bound by a
polynomial factor. Our bound may be far from tight: we show that the algorithm
can take time by relating its performance to a
generalization of the -levels problem of combinatorial geometry. A
completely different algorithm running in time was given
recently by Bender, Fineman, and Gilbert. We extend both of our algorithms to
the maintenance of strong components, without affecting the asymptotic time
bounds.Comment: 31 page
Incremental -Edge-Connectivity in Directed Graphs
In this paper, we initiate the study of the dynamic maintenance of
-edge-connectivity relationships in directed graphs. We present an algorithm
that can update the -edge-connected blocks of a directed graph with
vertices through a sequence of edge insertions in a total of time.
After each insertion, we can answer the following queries in asymptotically
optimal time: (i) Test in constant time if two query vertices and are
-edge-connected. Moreover, if and are not -edge-connected, we can
produce in constant time a "witness" of this property, by exhibiting an edge
that is contained in all paths from to or in all paths from to .
(ii) Report in time all the -edge-connected blocks of . To the
best of our knowledge, this is the first dynamic algorithm for -connectivity
problems on directed graphs, and it matches the best known bounds for simpler
problems, such as incremental transitive closure.Comment: Full version of paper presented at ICALP 201
Incremental Dead State Detection in Logarithmic Time
Identifying live and dead states in an abstract transition system is a
recurring problem in formal verification; for example, it arises in our recent
work on efficiently deciding regex constraints in SMT. However,
state-of-the-art graph algorithms for maintaining reachability information
incrementally (that is, as states are visited and before the entire state space
is explored) assume that new edges can be added from any state at any time,
whereas in many applications, outgoing edges are added from each state as it is
explored. To formalize the latter situation, we propose guided incremental
digraphs (GIDs), incremental graphs which support labeling closed states
(states which will not receive further outgoing edges). Our main result is that
dead state detection in GIDs is solvable in amortized time per edge
for edges, improving upon per edge due to Bender, Fineman,
Gilbert, and Tarjan (BFGT) for general incremental directed graphs.
We introduce two algorithms for GIDs: one establishing the logarithmic time
bound, and a second algorithm to explore a lazy heuristics-based approach. To
enable an apples-to-apples experimental comparison, we implemented both
algorithms, two simpler baselines, and the state-of-the-art BFGT baseline using
a common directed graph interface in Rust. Our evaluation shows -x
speedups over BFGT for the largest input graphs over a range of graph classes,
random graphs, and graphs arising from regex benchmarks.Comment: 22 pages + reference
An improved algorithm for incremental cycle detection and topological ordering in sparse graphs
We consider the problem of incremental cycle detection and topological ordering in a directed graph G = (V, E) with |V| = n nodes. In this setting, initially the edge-set E of the graph is empty. Subsequently, at each time-step an edge gets inserted into G. After every edge-insertion, we have to report if the current graph contains a cycle, and as long as the graph remains acyclic, we have to maintain a topological ordering of the node-set V. Let m be the total number of edges that get inserted into G. We present a randomized algorithm for this problem with Õ(m4/3) total expected update time.
Our result improves the Õ(m • min(m1/2, n2/3)) total update time bound of [5, 9, 10, 7]. In particular, for m = O(n), our result breaks the longstanding barrier on the total update time. Furthermore, whenever m = o(n3/2), our result improves upon the recently obtained total update time bound of [6]. We note that if m = Ω(n3/2), then the algorithm of [5, 4, 7], which has Õ(n2) total update time, beats the performance of the time algorithm of [6]. It follows that we improve upon the total update time of the algorithm of [6] in the “interesting” range of sparsity where m = o(n3/2).
Our result also happens to be the first one that breaks the lower bound of [9] on the total update time of any local algorithm for a nontrivial range of sparsity. Specifically, the total update time of our algorithm is whenever . From a technical perspective, we obtain our result by combining the algorithm of [6] with the balanced search framework of [10]
Sampling-Based Temporal Logic Path Planning
In this paper, we propose a sampling-based motion planning algorithm that
finds an infinite path satisfying a Linear Temporal Logic (LTL) formula over a
set of properties satisfied by some regions in a given environment. The
algorithm has three main features. First, it is incremental, in the sense that
the procedure for finding a satisfying path at each iteration scales only with
the number of new samples generated at that iteration. Second, the underlying
graph is sparse, which guarantees the low complexity of the overall method.
Third, it is probabilistically complete. Examples illustrating the usefulness
and the performance of the method are included.Comment: 8 pages, 4 figures; extended version of the paper presented at IROS
201
Connectivity in the presence of an opponent
The paper introduces two player connectivity games played on finite bipartite
graphs. Algorithms that solve these connectivity games can be used as
subroutines for solving M\"uller games. M\"uller games constitute a well
established class of games in model checking and verification. In connectivity
games, the objective of one of the players is to visit every node of the game
graph infinitely often. The first contribution of this paper is our proof that
solving connectivity games can be reduced to the incremental strongly connected
component maintenance (ISCCM) problem, an important problem in graph algorithms
and data structures. The second contribution is that we non-trivially adapt two
known algorithms for the ISCCM problem to provide two efficient algorithms that
solve the connectivity games problem. Finally, based on the techniques
developed, we recast Horn's polynomial time algorithm that solves explicitly
given M\"uller games and provide an alternative proof of its correctness. Our
algorithms are more efficient than that of Horn's algorithm. Our solution for
connectivity games is used as a subroutine in the algorithm
- …