Results 1  10
of
50
On graph problems in a semistreaming model
 In 31st International Colloquium on Automata, Languages and Programming
, 2004
"... Abstract. We formalize a potentially rich new streaming model, the semistreaming model, that we believe is necessary for the fruitful study of efficient algorithms for solving problems on massive graphs whose edge sets cannot be stored in memory. In this model, the input graph, G = (V, E), is prese ..."
Abstract

Cited by 60 (12 self)
 Add to MetaCart
Abstract. We formalize a potentially rich new streaming model, the semistreaming model, that we believe is necessary for the fruitful study of efficient algorithms for solving problems on massive graphs whose edge sets cannot be stored in memory. In this model, the input graph, G = (V, E), is presented as a stream of edges (in adversarial order), and the storage space of an algorithm is bounded by O(n · polylog n), where n = V . We are particularly interested in algorithms that use only one pass over the input, but, for problems where this is provably insufficient, we also look at algorithms using constant or, in some cases, logarithmically many passes. In the course of this general study, we give semistreaming constant approximation algorithms for the unweighted and weighted matching problems, along with a further algorithm improvement for the bipartite case. We also exhibit log n / log log n semistreaming approximations to the diameter and the problem of computing the distance between specified vertices in a weighted graph. These are complemented by Ω(log (1−ɛ) n) lower bounds. 1
Selective Memoization
"... We present a framework for applying memoization selectively. The framework provides programmer control over equality, space usage, and identification of precise dependences so that memoization can be applied according to the needs of an application. Two key properties of the framework are that it ..."
Abstract

Cited by 44 (19 self)
 Add to MetaCart
We present a framework for applying memoization selectively. The framework provides programmer control over equality, space usage, and identification of precise dependences so that memoization can be applied according to the needs of an application. Two key properties of the framework are that it is efficient and yields programs whose performance can be analyzed using standard techniques. We describe the framework in the context of a functional language and an implementation as an SML library. The language is based on a modal type system and allows the programmer to express programs that reveal their true data dependences when executed. The SML implementation cannot support this modal type system statically, but instead employs runtime checks to ensure correct usage of primitives.
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 35 (19 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.
Fully dynamic algorithms for chordal graphs
 In Proceedings of the 10th Annual ACMSIAM Symposium on Discrete Algorithms (SODA'99
, 1999
"... We present the rst dynamic algorithm that maintains a clique tree representation of a chordal graph and supports the following operations: (1) query whether deleting or inserting an arbitrary edge preserves chordality, (2) delete or insert an arbitrary edge, provided it preserves chordality. Wegivet ..."
Abstract

Cited by 30 (1 self)
 Add to MetaCart
We present the rst dynamic algorithm that maintains a clique tree representation of a chordal graph and supports the following operations: (1) query whether deleting or inserting an arbitrary edge preserves chordality, (2) delete or insert an arbitrary edge, provided it preserves chordality. Wegivetwo implementations. In the rst, each operation runs in O(n) time, where n is the numberofvertices. In the second, an insertion query runs in O(log 2 n) time, an insertion in O(n) time, a deletion query in O(n) time, and a deletion in O(n log n) time. We also present a data structure that allows a deletion query to run in O ( p m) time in either implementation, where m is the current number of edges. Updating this data structure after a deletion or insertion requires O(m) time. We also present avery simple dynamic algorithm that supports each of the following operations in O(1) time on a general graph: (1) query whether the graph is split, (2) delete or insert an arbitrary edge. 1
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 21 (13 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.
A Dynamic Algorithm for Topologically Sorting Directed Acyclic Graphs
, 2004
"... We consider how to maintain the topological order of a directed acyclic graph (DAG) in the presence of edge insertions and deletions. We present a new algorithm and, although this has marginally inferior time complexity compared with the best previously known result, we find that its simplicity lead ..."
Abstract

Cited by 15 (1 self)
 Add to MetaCart
We consider how to maintain the topological order of a directed acyclic graph (DAG) in the presence of edge insertions and deletions. We present a new algorithm and, although this has marginally inferior time complexity compared with the best previously known result, we find that its simplicity leads to better performance in practice. In addition, we provide an empirical comparison against three alternatives over a large number of random DAG's. The results show our algorithm is the best for sparse graphs and, surprisingly, that an alternative with poor theoretical complexity performs marginally better on dense graphs.
CEAL: a Cbased language for selfadjusting computation
 In ACM SIGPLAN Conference on Programming Language Design and Implementation
, 2009
"... Selfadjusting computation offers a languagecentric approach to writing programs that can automatically respond to modifications to their data (e.g., inputs). Except for several domainspecific implementations, however, all previous implementations of selfadjusting computation assume mostly functi ..."
Abstract

Cited by 15 (8 self)
 Add to MetaCart
Selfadjusting computation offers a languagecentric approach to writing programs that can automatically respond to modifications to their data (e.g., inputs). Except for several domainspecific implementations, however, all previous implementations of selfadjusting computation assume mostly functional, higherorder languages such as Standard ML. Prior to this work, it was not known if selfadjusting computation can be made to work with lowlevel, imperative languages such as C without placing undue burden on the programmer. We describe the design and implementation of CEAL: a Cbased language for selfadjusting computation. The language is fully general and extends C with a small number of primitives to enable writing selfadjusting programs in a style similar to conventional C programs. We present efficient compilation techniques for translating CEAL programs into C that can be compiled with existing C compilers using primitives supplied by a runtime library for selfadjusting computation. We implement the proposed compiler and evaluate its effectiveness. Our experiments show that CEAL is effective in practice: compiled selfadjusting programs respond to small modifications to their data by orders of magnitude faster than recomputing from scratch while slowing down a fromscratch run by a moderate constant factor. Compared to previous work, we
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
General Compact Labeling Schemes for Dynamic Trees
 In Proc. 19th Int. Symp. on Distributed Computing
, 2005
"... Let F be a function on pairs of vertices. An F labeling scheme is composed of a marker algorithm for labeling the vertices of a graph with short labels, coupled with a decoder algorithm allowing one to compute F (u, v) of any two vertices u and v directly from their labels. As applications for labe ..."
Abstract

Cited by 13 (9 self)
 Add to MetaCart
Let F be a function on pairs of vertices. An F labeling scheme is composed of a marker algorithm for labeling the vertices of a graph with short labels, coupled with a decoder algorithm allowing one to compute F (u, v) of any two vertices u and v directly from their labels. As applications for labeling schemes concern mainly large and dynamically changing networks, it is of interest to study distributed dynamic labeling schemes. This paper investigates labeling schemes for dynamic trees. We consider two dynamic tree models, namely, the leafdynamic tree model in which at each step a leaf can be added to or removed from the tree and the leafincreasing tree model in which the only topological event that may occur is that a leaf joins the tree. A general method for constructing labeling schemes for dynamic trees (under the above mentioned dynamic tree models) was previously developed in [29]. This method is based on extending an existing static tree labeling scheme to the dynamic setting. This approach fits many natural functions on trees, such as distance, separation level, ancestry relation, routing (in both the adversary and the designer port models), nearest common ancestor etc.. Their