Results 11 
15 of
15
An optimaltime algorithm for shortest paths on a convex polytope in three dimensions
 IN PROC. 22ND ACM SYMPOS. COMPUT. GEOM
, 2006
"... We present an optimaltime algorithm for computing (an implicit representation of) the shortestpath map from a fixed source s on the surface of a convex polytope P in three dimensions. Our algorithm runs in O(n log n) time and requires O(n log n) space, where n is the number of edges of P. The algo ..."
Abstract

Cited by 7 (0 self)
 Add to MetaCart
We present an optimaltime algorithm for computing (an implicit representation of) the shortestpath map from a fixed source s on the surface of a convex polytope P in three dimensions. Our algorithm runs in O(n log n) time and requires O(n log n) space, where n is the number of edges of P. The algorithm is based on the O(n log n) algorithm of Hershberger and Suri for shortest paths in the plane [22], and similarly follows the continuous Dijkstra paradigm, which propagates a “wavefront” from s along ∂P. This is effected by generalizing the concept of conforming subdivision of the free space used in [22], and by adapting it for the case of a convex polytope in R³, allowing the algorithm to accomplish the propagation in discrete steps, between the “transparent” edges of the subdivision. The algorithm constructs a dynamic version of Mount’s data structure [32] that implicitly encodes the shortest paths from s to all other points of the surface. This structure allows us to answer singlesource shortestpath queries, where the length of the path, as well as its combinatorial type, can be reported in O(log n) time; the actual path can be reported in additional O(k) time, where k is the number
Amortization, Lazy Evaluation, and Persistence: Lists with Catenation via Lazy Linking
 Pages 646654 of: IEEE Symposium on Foundations of Computer Science
, 1995
"... Amortization has been underutilized in the design of persistent data structures, largely because traditional accounting schemes break down in a persistent setting. Such schemes depend on saving "credits" for future use, but a persistent data structure may have multiple "futures", each competing for ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
Amortization has been underutilized in the design of persistent data structures, largely because traditional accounting schemes break down in a persistent setting. Such schemes depend on saving "credits" for future use, but a persistent data structure may have multiple "futures", each competing for the same credits. We describe how lazy evaluation can often remedy this problem, yielding persistent data structures with good amortized efficiency. In fact, such data structures can be implemented purely functionally in any functional language supporting lazy evaluation. As an example of this technique, we present a purely functional (and therefore persistent) implementation of lists that simultaneously support catenation and all other usual list primitives in constant amortized time. This data structure is much simpler than the only existing data structure with comparable bounds, the recently discovered catenable lists of Kaplan and Tarjan, which support all operations in constant worstca...
Dynamic State Restoration Using Versioning Exceptions
"... We explore the semantics and analysis of a new kind of control structure called a versioning exception that ensures the state of the program, at the point when an exception handler is invoked, reflects the program state at the point when the handler is installed. Versioning exceptions provide a tran ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We explore the semantics and analysis of a new kind of control structure called a versioning exception that ensures the state of the program, at the point when an exception handler is invoked, reflects the program state at the point when the handler is installed. Versioning exceptions provide a transactionlike versioning semantics to the code protected by a handler: modifications performed within the dynamic context of the corresponding handler are versioned, and committed to the store only if the computation completes normally. Similar to the role of backtracking in logic programming, this facility allows unwanted effects of computations to be discarded when exceptional or undesirable conditions are detected. We define a novel pointsto analysis to efficiently track changes to the store within handlerprotected scopes. The role of the analysis is to facilitate optimizations that minimize the number of locations which must be restored when a versioning exception is raised. The analysis is defined by a reachability approximation over locations that indicates which objects have been potentially modified within a handler scope. The analysis is defined for programs which support firstclass procedures, locations, and exceptions. 1.
Confluently Persistent Tries for Efficient Version Control
"... Abstract. We consider a datastructural problem motivated by version control of a hierarchical directory structure in a system like Subversion. The model is that directories and files can be moved and copied between two arbitrary versions in addition to being added or removed in an arbitrary version ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. We consider a datastructural problem motivated by version control of a hierarchical directory structure in a system like Subversion. The model is that directories and files can be moved and copied between two arbitrary versions in addition to being added or removed in an arbitrary version. Equivalently, we wish to maintain a confluently persistent trie (where internal nodes represent directories, leaves represent files, and edge labels represent path names), subject to copying a subtree between two arbitrary versions, adding a new child to an existing node, and deleting an existing subtree in an arbitrary version. Our first data structure represents an nnode degree ∆ trie with O(1) “fingers ” in each version while supporting finger movement (navigation) and modifications near the fingers (including subtree copy) in O(lg ∆) time and space per operation. This data structure is essentially a localitysensitive version of the standard practice—path copying— costing O(d lg ∆) time and space for modification of a node at depth d, which is expensive when performing many deep but nearby updates. Our second data structure supporting finger movement in O(lg ∆) time and no space, while modifications take O(lg n) time and space. This data structure is substantially faster for deep updates, i.e., unbalanced tries. Both of these data structures are functional, which is a stronger property than confluent persistence. Without this stronger property, we show how both data structures can be sped up to support movement in O(lg lg ∆), which is essentially optimal. Along the way, we present a general technique for global rebuilding of fully persistent data structures, which is nontrivial because amortization and persistence do not usually mix. In particular, this technique improves the best previous result for fully persistent arrays and obtains the first efficient fully persistent hash table. 1
Persistence, Offline Algorithms, and Space Compaction
, 1991
"... We consider dynamic data structures in which updates rebuild a static solution. Space bounds for persistent versions of these structures can often be reduced by using an offline persistent data structure in place of the static solution. We apply this technique to decomposable search problems, to dyn ..."
Abstract
 Add to MetaCart
We consider dynamic data structures in which updates rebuild a static solution. Space bounds for persistent versions of these structures can often be reduced by using an offline persistent data structure in place of the static solution. We apply this technique to decomposable search problems, to dynamic linear programming, and to maintaining the minimum spanning tree in a dynamic graph. Our algorithms admit tradeoffs of update time vs. query time, and of time vs. space.