Module org.jgrapht.core
Package org.jgrapht.alg.lca

Class HeavyPathLCAFinder<V,E>

java.lang.Object
org.jgrapht.alg.lca.HeavyPathLCAFinder<V,E>
Type Parameters:
V - the graph vertex type
E - the graph edge type
All Implemented Interfaces:
LowestCommonAncestorAlgorithm<V>
public class HeavyPathLCAFinder<V,E> extends Object implements LowestCommonAncestorAlgorithm<V>
Algorithm for computing lowest common ancestors in rooted trees and forests based on HeavyPathDecomposition.

Preprocessing Time complexity: $O(|V|)$
Preprocessing Space complexity: $O(|V|)$
Query Time complexity: $O(log(|V|))$
Query Space complexity: $O(1)$

For small (i.e. less than 100 vertices) trees or forests, all implementations behave similarly. For larger trees/forests with less than 50,000 queries you can use either BinaryLiftingLCAFinder, HeavyPathLCAFinder or EulerTourRMQLCAFinder. Fo more than that use EulerTourRMQLCAFinder since it provides $O(1)$ per query.
Space-wise, HeavyPathLCAFinder and TarjanLCAFinder only use a linear amount while BinaryLiftingLCAFinder and EulerTourRMQLCAFinder require linearithmic space.
For DAGs, use NaiveLCAFinder.

  • Field Details

    • graph

      private final Graph<V,E> graph

    • roots

      private final Set<V> roots

    • parent

      private int[] parent

    • depth

      private int[] depth

    • path

      private int[] path

    • positionInPath

      private int[] positionInPath

    • component

      private int[] component

    • firstNodeInPath

      private int[] firstNodeInPath

    • vertexMap

      private Map<V,Integer> vertexMap

    • indexList

      private List<V> indexList

  • Constructor Details

    • HeavyPathLCAFinder

      public HeavyPathLCAFinder(Graph<V,E> graph, V root)
      Construct a new instance of the algorithm.

      Note: The constructor will NOT check if the input graph is a valid tree.

      Parameters:
      graph - the input graph
      root - the root of the graph

    • HeavyPathLCAFinder

      public HeavyPathLCAFinder(Graph<V,E> graph, Set<V> roots)
      Construct a new instance of the algorithm.

      Note: If two roots appear in the same tree, an error will be thrown.

      Note: The constructor will NOT check if the input graph is a valid forest.

      Parameters:
      graph - the input graph
      roots - the set of roots of the graph

  • Method Details

    • computeHeavyPathDecomposition

      private void computeHeavyPathDecomposition()
      Compute the heavy path decomposition and get the corresponding arrays from the internal state.

    • getLCA

      public V getLCA(V a, V b)
      Return the LCA of a and b
      Specified by:
      getLCA in interface LowestCommonAncestorAlgorithm<V>
      Parameters:
      a - the first element to find LCA for
      b - the other element to find the LCA for
      Returns:
      the LCA of a and b, or null if there is no LCA.

    • getLCASet

      public Set<V> getLCASet(V a, V b)
      Note: This operation is not supported.
      Return the computed set of LCAs of a and b
      Specified by:
      getLCASet in interface LowestCommonAncestorAlgorithm<V>
      Parameters:
      a - the first element to find LCA for
      b - the other element to find the LCA for
      Returns:
      the set LCAs of a and b, or empty set if there is no LCA computed.
      Throws:
      UnsupportedOperationException - if the method is called