Results 1  10
of
24
Polylogarithmic deterministic fullydynamic graph algorithms I: connectivity and minimum spanning tree
 JOURNAL OF THE ACM
, 1997
"... Deterministic fully dynamic graph algorithms are presented for connectivity and minimum spanning forest. For connectivity, starting with no edges, the amortized cost for maintaining a spanning forest is O(log² n) per update, i.e. per edge insertion or deletion. Deciding connectivity between any two ..."
Abstract

Cited by 122 (6 self)
 Add to MetaCart
Deterministic fully dynamic graph algorithms are presented for connectivity and minimum spanning forest. For connectivity, starting with no edges, the amortized cost for maintaining a spanning forest is O(log² n) per update, i.e. per edge insertion or deletion. Deciding connectivity between any two given vertices is done in O(log n= log log n) time. This matches the previous best randomized bounds. The previous best deterministic bound was O( 3 p n log n) amortized time per update but constant time for connectivity queries. For minimum spanning trees, first a deletionsonly algorithm is presented supporting deletes in amortized time O(log² n). Applying a general reduction from Henzinger and King, we then get a fully dynamic algorithm such that starting with no edges, the amortized cost for maintaining a minimum spanning forest is O(log^4 n) per update. The previous best deterministic bound was O( 3 p n log n) amortized time per update, and no better randomized bounds were ...
Marked Ancestor Problems
, 1998
"... Consider a rooted tree whose nodes can be marked or unmarked. Given a node, we want to find its nearest marked ancestor. This generalises the wellknown predecessor problem, where the tree is a path. ..."
Abstract

Cited by 50 (6 self)
 Add to MetaCart
Consider a rooted tree whose nodes can be marked or unmarked. Given a node, we want to find its nearest marked ancestor. This generalises the wellknown predecessor problem, where the tree is a path.
Improved Labeling Scheme for Ancestor Queries
, 2001
"... We present a labeling scheme for rooted trees that supports ancestor queries. Given a tree, the scheme assigns to each node a label which is a binary string. Given the labels of any two nodes u and v, it can in constant time be determined whether u is ancestor to v alone from these labels. For tr ..."
Abstract

Cited by 48 (7 self)
 Add to MetaCart
We present a labeling scheme for rooted trees that supports ancestor queries. Given a tree, the scheme assigns to each node a label which is a binary string. Given the labels of any two nodes u and v, it can in constant time be determined whether u is ancestor to v alone from these labels. For trees of size n our scheme assigns labels of size bounded by log n + O( p log n) bits to each node. This improves a recent result of Abiteboul, Kaplan and Milo at SODA'01, where a labeling scheme with labels of size 3=2 log n+ O(log log n) was presented. The problem is among other things motivated in connection with ecient representation of information for XMLbased search engines for the internet.
An experimental analysis of selfadjusting computation
 In Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI
, 2006
"... Selfadjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a r ..."
Abstract

Cited by 34 (18 self)
 Add to MetaCart
Selfadjusting computation uses a combination of dynamic dependence graphs and memoization to efficiently update the output of a program as the input changes incrementally or dynamically over time. Related work showed various theoretical results, indicating that the approach can be effective for a reasonably broad range of applications. In this article, we describe algorithms and implementation techniques to realize selfadjusting computation and present an experimental evaluation of the proposed approach on a variety of applications, ranging from simple list primitives to more sophisticated computational geometry algorithms. The results of the experiments show that the approach is effective in practice, often offering orders of magnitude speedup from recomputing the output from scratch. We believe this is the first experimental evidence that incremental computation of any type is effective in practice for a reasonably broad set of applications.
An Experimental Analysis of Change Propagation in Dynamic Trees
, 2005
"... Change propagation is a technique for automatically adjusting the output of an algorithm to changes in the input. The idea behind change propagation is to track the dependences between data and function calls, so that, when the input changes, functions affected by that change can be reexecuted to u ..."
Abstract

Cited by 20 (12 self)
 Add to MetaCart
Change propagation is a technique for automatically adjusting the output of an algorithm to changes in the input. The idea behind change propagation is to track the dependences between data and function calls, so that, when the input changes, functions affected by that change can be reexecuted to update the computation and the output. Change propagation makes it possible for a compiler to dynamize static algorithms. The practical effectiveness of change propagation, however, is not known. In particular, the cost of dependence tracking and change propagation may seem significant. The contributions of the paper are twofold. First, we present some experimental evidence that change propagation performs well when compared to direct implementations of dynamic algorithms. We implement change propagation on treecontraction as a solution to the dynamic trees problem and present an experimental evaluation of the approach. As a second contribution, we present a library for dynamictrees that support a general interface and present an experimental evaluation by considering a broad set of applications. The dynamictrees library relies on change propagation to handle edge insertions/deletions. The applications that we consider include path queries, subtree queries, leastcommonancestor queries, maintenance of centers and medians of trees, nearestmarkedvertex queries, semidynamic minimum spanning trees, and the maxflow algorithm of Sleator and Tarjan.
Maintaining Center and Median in Dynamic Trees
, 2000
"... We show how to maintain centers and medians for a collection of dynamic trees where edges may be inserted and deleted and node and edge weights may be changed. All updates are supported in O(log n) time, where n is the size of the tree(s) involved in the update. ..."
Abstract

Cited by 17 (4 self)
 Add to MetaCart
We show how to maintain centers and medians for a collection of dynamic trees where edges may be inserted and deleted and node and edge weights may be changed. All updates are supported in O(log n) time, where n is the size of the tree(s) involved in the update.
Improved Algorithms for Finding Level Ancestors in Dynamic Trees
 Automata, Languages and Programming, 27th International Colloquium, ICALP 2000, number 1853 in LNCS
, 2000
"... Given a node x at depth d in a rooted tree LevelAncestor(x; i) returns the ancestor to x in depth d i. We show how to maintain a tree under addition of new leaves so that updates and level ancestor queries are being performed in worst case constant time. Given a forest of trees with n nodes wher ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
Given a node x at depth d in a rooted tree LevelAncestor(x; i) returns the ancestor to x in depth d i. We show how to maintain a tree under addition of new leaves so that updates and level ancestor queries are being performed in worst case constant time. Given a forest of trees with n nodes where edges can be added, m queries and updates take O(m(m;n)) time. This solves two open problems (P.F.
Dynamic parallel tree contraction
 In Proceedings 5th Annual ACM Symp. on Parallel Algorithms and Architectures
, 1994
"... Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of problems with incremental changes in the data. In dynamic tree contraction problems, we are ..."
Abstract

Cited by 16 (2 self)
 Add to MetaCart
Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of problems with incremental changes in the data. In dynamic tree contraction problems, we are given an initial tree T, and then an online algorithm processes requests regarding T. Requests may be either incremental changes to T or requests for certain values computed using the tree. A simple example is maintaining the preorder numbering on a tree. The online algorithm would then have to handle incremental changes to the tree, and would also have to quickly answer queries about the preorder number of any tree node. Our dynamic algorithms are based on the prior parallel tree contraction algorithms, and hence we call such algorithms incremental tree contraction algorithms. By maintaining the connection between our incremental algorithms and the parallel tree contraction algorithm, we create incremental algorithms for tree contraction. We consider a dynamic binary tree T of ≤ n nodes and unbounded depth. We describe a procedure, which we call the dynamic parallel tree contraction algorithm, which incrementally processes various parallel modification requests and queries: (1) parallel requests to add or delete leaves of T, or modify labels of internal nodes or leaves of T, and also (2) parallel tree contraction queries which require recomputing values at specified nodes. Each modification or query is with respect to a set of nodes U in T. We make use of a random splitting tree as an aid
Finding All the Best Swaps of a Minimum Diameter Spanning Tree Under Transient Edge Failures
 Journal of Graph Algorithms and Applications
, 1998
"... Abstract. In network communication systems, frequently messages are routed along a minimum diameter spanning tree (MDST) of the network, to minimize the maximum delay in delivering a message. When a transient edge failure occurs, it is important to choose a temporary replacement edge which minimizes ..."
Abstract

Cited by 14 (6 self)
 Add to MetaCart
Abstract. In network communication systems, frequently messages are routed along a minimum diameter spanning tree (MDST) of the network, to minimize the maximum delay in delivering a message. When a transient edge failure occurs, it is important to choose a temporary replacement edge which minimizes the diameter of the new spanning tree. Such an optimal replacement is called the best swap. As a natural extension, the allbestswaps (ABS) problem is the problem of finding the best swap for every edge of the MDST. Given a weighted graph G =(V, E), where V  = n and E  = m,wesolvetheABSprobleminO(n √ m)time and O(m + n) space, thus improving previous bounds for m = o(n 2). 1
Fullydynamic mincut
 Combinatorica
, 2007
"... We show that we can maintain up to polylogarithmic edge connectivity for a fullydynamic graph in ~ O ( p n) time per edge insertion or deletion. Within logarithmic factors, this matches the best time bound for 1edge connectivity. Previously, no o(n) bound was known for edge connectivity above 3, a ..."
Abstract

Cited by 13 (1 self)
 Add to MetaCart
We show that we can maintain up to polylogarithmic edge connectivity for a fullydynamic graph in ~ O ( p n) time per edge insertion or deletion. Within logarithmic factors, this matches the best time bound for 1edge connectivity. Previously, no o(n) bound was known for edge connectivity above 3, and even for 3edge connectivity, the best update time was O(n 2=3), dating back to FOCS’92. Our algorithm maintains a concrete mincut in terms of a pointer to a tree spanning one side of the cut plus ability to list the cut edges in O(log n) time per edge. By dealing with polylogarithmic edge connectivity, we immediately get a sampling based expected factor (1 + o(1)) approximation to general edge connectivity in ~O ( p n) time per edge insertion or deletion. This algorithm also maintains a pointer to one side of a mincut, but if we want to list the cut edges in O(log n) time per edge, the update time increases to ~O ( p m). 1.