Applications of Path Compression on Balanced Trees

@article{Tarjan1979ApplicationsOP,
  title={Applications of Path Compression on Balanced Trees},
  author={Robert E. Tarjan},
  journal={J. ACM},
  year={1979},
  volume={26},
  pages={690-715}
}
  • R. Tarjan
  • Published 1 October 1979
  • Computer Science
  • J. ACM
We devise a method for computing functions defined on paths in trees. The method is based on tree manipulation techniques first used for efficiently representing equivalence relations. It has an almost-linear running time. We apply the method to give O(m $\alpha$(m,n)) algorithms for two problems. A. Verifying a minimum spanning tree in an undirected graph (best previous bound: O(m log log n) ). B. Finding dominators in a directed graph (best previous bound: O(n log n + m) ). Here n is the… 

Figures from this paper

A Shortest Path Algorithm for Real-Weighted Undirected Graphs

TLDR
The algorithm takes the hierarchy-based approach invented by Thorup, and, if the ratio between the maximum and minimum edge lengths is bounded by n(log n)O(1), it can solve the single-source problem in O(m + n log log n) time.

Efficient algorithms for finding minimum spanning trees in undirected and directed graphs

TLDR
This paper uses F-heaps to obtain fast algorithms for finding minimum spanning trees in undirected and directed graphs and can be extended to allow a degree constraint at one vertex.

A linear algorithm for finding dominators in flow graphs and related problems

  • D. Harel
  • Computer Science, Mathematics
    STOC '85
  • 1985
TLDR
The notions of pseudo and external dominators which are both computable in linear time are introduced and made applicable for finding immediate dominators and an algorithm for a limited class of graphs which includes cycle free graphs is given which can be used to find dominators in reducible flow graphs.

Parallel algorithms for verification and sensitivity analysis of minimum spanning trees

TLDR
An efficient algorithm for sensitivity analysis of minimum spanning trees which requires O(log n) time and O(max{m, n/sup 2//log n}) processors is presented and has better performance when G is sparse.

LCA Queries in Directed Acyclic Graphs

TLDR
The first method is surprisingly natural and solves the all-pairs LCA problem for the input dag on n vertices and m edges in time O(nm), and an O(n2)-time algorithm is obtained for finding genealogical distances considerably improving the previously known O( n2.575) time-bound for this problem.

A Path Cover Technique for LCAs in Dags

TLDR
The algorithm attains the best known upper time bound for this problem of O(n2.575) and performs better on a vast amount of input dags, i.e. dags that do not have an almost linear-sized subdag of extremely regular structure.

A data structure for dynamic trees

TLDR
An O(mn log n)-time algorithm is obtained to find a maximum flow in a network of n vertices and m edges, beating by a factor of log n the fastest algorithm previously known for sparse graphs.

A scaling algorithm for weighted matching on general graphs

  • H. Gabow
  • Computer Science
    26th Annual Symposium on Foundations of Computer Science (sfcs 1985)
  • 1985
TLDR
An algorithm for maximum matching on general graphs with integral edge weights, running in time O(n3/4m lg N), where n, m and N are the number of vertices, number of edges, and largest edge weight magnitude, respectively.

Finding Path Minima in Incremental Unrooted Trees ∗

TLDR
Using the data structure and data structure suggested, an optimal data structure is obtained for a restricted version of the mergeable trees problem and a simpler data structures are suggested for the case where trees are rooted and the link operation always adds an edge between the root of one tree and an arbitrary vertex of another tree.

Fast Algorithms for Solving Path Problems

TLDR
A method to compute path expressions by dividing G into components, computing path expressions on the components by Gaussian elimination, and combining the solutions is described, which requires O(m $\alpha$(m,n) time on a reducible flow graph.
...

References

SHOWING 1-10 OF 48 REFERENCES

Finding Dominators in Directed Graphs

  • R. Tarjan
  • Computer Science, Mathematics
    SIAM J. Comput.
  • 1974
This paper describes an algorithm for finding dominators in an arbitrary directed graph. The algorithm uses depth-first search and efficient algorithms for computing disjoint set unions and

Finding Minimum Spanning Trees

TLDR
This paper studies methods for finding minimum spanning trees in graphs and results include relationships with other problems which might lead general lower bound for the complexity of the minimum spanning tree problem.

Algorithms for Updating Minimal Spanning Trees

Testing flow graph reducibility

  • R. Tarjan
  • Computer Science
    J. Comput. Syst. Sci.
  • 1974
TLDR
An algorithm for testing whether a flow graph is reducible is described, which uses depth-first search to reveal the structure of the flow graph and a good method for computing disjoint set unions to determine reducibility from the search information.

A Fast and Usually Linear Algorithm for Global Flow Analysis

TLDR
A new algorithm for global flow analysis on reducible graphs which has a worst-case time bound of O(e log e) function operations and a restriction to one-entry one-exit control structures guarantees linearity.

Depth-First Search and Linear Graph Algorithms

The value of depth-first search or “backtracking” as a technique for solving problems is illustrated by two examples. An improved version of an algorithm for finding the strongly connected components

Node listings for reducible flow graphs

TLDR
It is shown that for all reducible flow graphs such a sequence of nodes of length O(nlogn) such that all acyclic paths are subsequences thereof does exist, even if the number of edges is much larger than n.

A Fast Algorithm for the Elimination of Common Subexpressions

TLDR
An O(n log n) bit vecter step algorithm is given to determine "available expressions" and this information is essential for global elimination of common subexpressions.

A fast algorithm for finding dominators in a flowgraph

TLDR
A fast algorithm for finding dominators in a flowgraph is presented, which beat the straightforward algorithm and the bit vector algorithm on all but the smallest graphs tested.