293,698 research outputs found
Fast and simple unrooted dynamic forests
A dynamic forest data structure maintains a forest (and associated data like
edge weights) under edge insertions and deletions. Dynamic forests are widely
used to solve online and offline graph problems. Well-known examples of dynamic
forest data structures are link-cut trees [Sleator and Tarjan '83] and top
trees [Alstrup, Holm, de Lichtenberg, and Thorup '05], both of which need O(log
n) time per operation. While top trees are more flexible and arguably easier to
use, link-cut trees are faster in practice [Tarjan and Werneck '10].
In this paper, we propose an alternative to link-cut trees. Our data
structure is based on search trees on trees (STTs, also known as elimination
trees) and an STT algorithm [Berendsohn and Kozma '22] based on the classical
Splay trees [Sleator and Tarjan '85]. While link-cut trees maintain a hierarchy
of binary search trees, we maintain a single STT. Most of the complexity of our
data structure lies in the implementation of the STT rotation primitive, which
can easily be reused, simplifying the development of new STT-based approaches.
We implement several variants of our data structure in the Rust programming
language, along with an implementation of link-cut trees for comparison.
Experimental evaluation suggests that our algorithms are faster when the
dynamic forest is unrooted, while link-cut trees are faster for rooted dynamic
forests
Task-based Augmented Contour Trees with Fibonacci Heaps
This paper presents a new algorithm for the fast, shared memory, multi-core
computation of augmented contour trees on triangulations. In contrast to most
existing parallel algorithms our technique computes augmented trees, enabling
the full extent of contour tree based applications including data segmentation.
Our approach completely revisits the traditional, sequential contour tree
algorithm to re-formulate all the steps of the computation as a set of
independent local tasks. This includes a new computation procedure based on
Fibonacci heaps for the join and split trees, two intermediate data structures
used to compute the contour tree, whose constructions are efficiently carried
out concurrently thanks to the dynamic scheduling of task parallelism. We also
introduce a new parallel algorithm for the combination of these two trees into
the output global contour tree. Overall, this results in superior time
performance in practice, both in sequential and in parallel thanks to the
OpenMP task runtime. We report performance numbers that compare our approach to
reference sequential and multi-threaded implementations for the computation of
augmented merge and contour trees. These experiments demonstrate the run-time
efficiency of our approach and its scalability on common workstations. We
demonstrate the utility of our approach in data segmentation applications
Modelling, reduction and analysis of Markov automata (extended version)
Markov automata (MA) constitute an expressive continuous-time compositional modelling formalism. They appear as semantic backbones for engineering frameworks including dynamic fault trees, Generalised Stochastic Petri Nets, and AADL. Their expressive power has thus far precluded them from effective analysis by probabilistic (and statistical) model checkers, stochastic game solvers, or analysis tools for Petri net-like formalisms. This paper presents the foundations and underlying algorithms for efficient MA modelling, reduction using static analysis, and most importantly, quantitative analysis. We also discuss implementation pragmatics of supporting tools and present several case studies demonstrating feasibility and usability of MA in practice
FPT-Algorithms for Computing Gromov-Hausdorff and Interleaving Distances Between Trees
The Gromov-Hausdorff distance is a natural way to measure the distortion between two metric spaces. However, there has been only limited algorithmic development to compute or approximate this distance. We focus on computing the Gromov-Hausdorff distance between two metric trees. Roughly speaking, a metric tree is a metric space that can be realized by the shortest path metric on a tree. Any finite tree with positive edge weight can be viewed as a metric tree where the weight is treated as edge length and the metric is the induced shortest path metric in the tree. Previously, Agarwal et al. showed that even for trees with unit edge length, it is NP-hard to approximate the Gromov-Hausdorff distance between them within a factor of 3. In this paper, we present a fixed-parameter tractable (FPT) algorithm that can approximate the Gromov-Hausdorff distance between two general metric trees within a multiplicative factor of 14.
Interestingly, the development of our algorithm is made possible by a connection between the Gromov-Hausdorff distance for metric trees and the interleaving distance for the so-called merge trees. The merge trees arise in practice naturally as a simple yet meaningful topological summary (it is a variant of the Reeb graphs and contour trees), and are of independent interest. It turns out that an exact or approximation algorithm for the interleaving distance leads to an approximation algorithm for the Gromov-Hausdorff distance. One of the key contributions of our work is that we re-define the interleaving distance in a way that makes it easier to develop dynamic programming approaches to compute it. We then present a fixed-parameter tractable algorithm to compute the interleaving distance between two merge trees exactly, which ultimately leads to an FPT-algorithm to approximate the Gromov-Hausdorff distance between two metric trees. This exact FPT-algorithm to compute the interleaving distance between merge trees is of interest itself, as it is known that it is NP-hard to approximate it within a factor of 3, and previously the best known algorithm has an approximation factor of O(sqrt{n}) even for trees with unit edge length
On the Implementation of Purely Functional Data Structures for the Linearisation case of Dynamic Trees
Dynamic trees, originally described by Sleator and Tarjan, have been studied in detail for non persistent structures providing O(log n) time for update and lookup operations as shown in theory and practice by Werneck.
However, there are two gaps in current theory. First, how the most common dynamic tree operations (link and cut) are computed over a purely functional data structure has not been studied in detail. Second, even in the imperative case, when checking whether two vertices u and v are connected (i.e. in the same component), it is taken for granted that the corresponding location indices (i.e. pointers, which are not allowed in purely functional programming) are known a priori and do not need to be computed, yet this is rarely the case in practice.
In this thesis we address these omissions by formally introducing two new data structures, Full and Top, which we use to represent trees in a functionally efficient manner. Based on a primitive version of finger trees – the de facto sequence data structure for the purely lazy-evaluation programming language Haskell – they are augmented with collection (i.e. set-based) data structures in order to manage efficiently k-ary trees for the so-called linearisation case of the dynamic trees problem. Different implementations are discussed, and their performance is measured.
Our results suggest that relative timings for our proposed structures perform sublinear time per operation once the forest is generated. Furthermore, Full and Top implementations show simplicity and preserve purity under a common interface
Semantics of Attack-Defense Trees for Dynamic Countermeasures and a New Hierarchy of Star-free Languages
We present a mathematical setting for attack-defense trees, a classic
graphical model to specify attacks and countermeasures. We equip attack-defense
trees with (trace) language semantics allowing to have an original dynamic
interpretation of countermeasures. Interestingly, the expressiveness of
attack-defense trees coincides with star-free languages, and the nested
countermeasures impact the expressiveness of attack-defense trees. With an
adequate notion of countermeasure-depth, we exhibit a strict hierarchy of the
star-free languages that does not coincides with the classic one. Additionally,
driven by the use of attack-defense trees in practice, we address the decision
problems of trace membership and of non-emptiness, and study their
computational complexities parameterized by the countermeasure-depth
A distributed spanning tree algorithm for topology-aware networks
Abstract. A topology-aware network is a dynamic network in which the nodes can detect whether locally topology changes occur. Many modern networks, like IEEE 1394.1, are topology-aware networks. We present a distributed algorithm for computing and maintaining an arbitrary spanning tree in such a topology-aware network. Although usually minimal spanning trees are studied, in practice arbitrary spanning trees are often sufficient. Since our algorithm is not involved in the detection of topology changes, it performs better than the spanning tree algorithms in standards like IEEE 802.1. Because reasoning about distributed algorithms is rather tricky, we use a systematic approach to prove our algorithm
- …