apply OOP principles to LCA

Author: Mohamed Ayman

include/LCA.h

@@ -0,0 +1,38 @@
+/*******************************************************************************
+ *
+ *
+ * /\ | _ _ ._ o _|_ |_ ._ _ _
+ * /--\ | (_| (_) | | |_ | | | | | _>
+ * _|
+ *
+ * LCA Finding using Binary Lifting and Dynamic Programming
+ *
+ * Features:
+ * 1. Answers Query about LCA of two nodes in O(log N)
+ * where N is the total number of nodes in a tree.
+ *
+ * https://en.wikipedia.org/wiki/Lowest_common_ancestor
+ * http://www.csegeek.com/csegeek/view/tutorials/algorithms/trees/tree_part12.php
+ ******************************************************************************/
+
+#ifndef LCA_H
+#define LCA_H
+#include <vector>
+
+class LCA
+{
+ public:
+ LCA(std::vector< std::pair<int,int> > edges);
+ int lcaQuery(int a, int b);
+
+ private:
+ int getMaxLog();
+ void initDP();
+ void dfs(int currentNode, int currentParent);
+ std::vector< std::vector<int> > adjList, binaryLiftDp;
+ std::vector<int> parent, nodeHeight;
+ std::vector<bool> visited;
+ int _numberOfNodes, _maxLog;
+};
+
+#endif // LCA_H

src/lca_demo.cpp

@@ -1,16 +1,36 @@
+#include "LCA.h"
 #include <cstdio>
 #include <vector>
+#include <iostream>
+/**
+*Constructor is initialized with a Adjacency List that
+*describe a tree and If It doesn't describe a tree it asserts failure.
+*/
 
-const int MAX_NODE = 5000;
-const int MAX_LOG = 20;
-
-int numberOfNodes, maxLog;
-std::vector< std::vector<int> > adjList;
-int parent[MAX_NODE], nodeHeight[MAX_NODE];
-bool visited[MAX_NODE];
-int binaryLiftDp[MAX_NODE][MAX_LOG];
+LCA::LCA(std::vector< std::pair<int,int> > edges): _numberOfNodes(edges.size() + 1), _maxLog(getMaxLog())
+{
+ //First we initialize the needed vectors
+ parent.resize(_numberOfNodes);
+ nodeHeight.resize(_numberOfNodes);
+ visited.resize(_numberOfNodes);
+ adjList.resize(_numberOfNodes);
+ binaryLiftDp = std::vector< std::vector<int> >(_numberOfNodes, std::vector<int>(_maxLog));
+ /**Construction of the Adjacency List to increase
+ *The efficiency of the tree traversal to O(V + E).
+ */
+ for(auto edge : edges){
+ adjList[edge.first].push_back(edge.second);
+ adjList[edge.second].push_back(edge.first);
+ }
+ //Initialize the Dynamic programming Vector.
+ initDP();
+}
 
-void dfs(int currentNode, int currentParent)
+/**
+*DFS is used to find the parent and the height of each node
+*allowing the use of Binary Lifting.
+*/
+void LCA::dfs(int currentNode, int currentParent)
 {
  visited[currentNode] = true;
  parent[currentNode] = currentParent;
@@ -25,79 +45,73 @@ void dfs(int currentNode, int currentParent)
  }
 }
 
-int getMaxLog(){
+/**
+*Used to Calculate the Log to the base of two
+*for the number of the nodes to create the sparse table
+*used in binary Lifting.
+*/
+int LCA::getMaxLog(){
  int curValue = 1;
  int curLog = 1;
- while(curValue < numberOfNodes) curValue *= 2, curLog++;
+ while(curValue < _numberOfNodes) curValue *= 2, curLog++;
  return curLog;
 }
 
-void initializeDP()
+void LCA::initDP()
 {
- nodeHeight[-1] = -1;
- maxLog = getMaxLog();
  dfs(0, -1);
- for(int i = 0; i < numberOfNodes; i++) binaryLiftDp[i][0] = parent[i];
- for(int i = 1; i <= maxLog; i++)
+ for(int i = 0; i < _numberOfNodes; i++) binaryLiftDp[i][0] = parent[i];
+ for(int i = 1; i <= _maxLog; i++)
  {
- for(int j = 0; j < numberOfNodes; j++)
+ for(int j = 0; j < _numberOfNodes; j++)
  {
- if(binaryLiftDp[j][i - 1] + 1)
+ /**
+ * Since the ith parent of the current node is equal to
+ * the ith / 2 parent to the ith /2 parent of the current node
+ * That's why the Recurrence relation is described as follow
+ */
+ if(binaryLiftDp[j][i - 1] != -1)
  binaryLiftDp[j][i] = binaryLiftDp[binaryLiftDp[j][i - 1]][i - 1];
  else binaryLiftDp[j][i] = -1;
  }
  }
 }
 
-int LCA(int a, int b)
+int LCA::lcaQuery(int a, int b)
 {
+ /**
+ * First Both nodes must have same height
+ * So we will rise the node with the deeper height up in
+ * the tree to where they're equal.
+ */
  if(nodeHeight[a] < nodeHeight[b]) std::swap(a,b);
- for(int i = maxLog; i >= 0; i--)
+ for(int i = _maxLog; i >= 0; i--)
  {
  if(binaryLiftDp[a][i] + 1 && nodeHeight[binaryLiftDp[a][i]] >= nodeHeight[b])
  a = binaryLiftDp[a][i];
  }
- if(!(a - b)) return a;
- for(int i = maxLog; i >= 0; i--)
+ /**
+ * If the node Lower is the LCA then return it.
+ * Else keep moving both nodes up as much as they aren't the same
+ * until it's only 1 node left which is the direct parent of both of them
+ */
+ if(a == b) return a;
+ for(int i = _maxLog; i >= 0; i--)
  {
  if(binaryLiftDp[a][i] + 1 && binaryLiftDp[a][i] - binaryLiftDp[b][i])
  a = binaryLiftDp[a][i], b = binaryLiftDp[b][i];
  }
  return parent[a];
 }
 
-void buildTree()
-{
- printf("Enter number of nodes of the tree: ");
- scanf("%d", &numberOfNodes);
- adjList.resize(numberOfNodes, std::vector<int> ());
- for(int i = 0; i < numberOfNodes - 1; i++)
- {
- int firstNode, secondNode;
- printf("Enter the two nodes to be connected: ");
- scanf("%d %d", &firstNode, &secondNode);
- adjList[firstNode].push_back(secondNode);
- adjList[secondNode].push_back(firstNode);
- }
-}
-
-void answerQueries()
-{
- int queryCount;
- printf("Enter the number of queries: ");
- scanf("%d", &queryCount);
- for(int i = 0; i < queryCount; i++)
- {
- int firstNode, secondNode;
- printf("Enter the two nodes : ");
- scanf("%d %d", &firstNode, &secondNode);
- printf("%d\n", LCA(firstNode, secondNode));
- }
-}
-
-int main()
-{
- buildTree();
- initializeDP();
- answerQueries();
+int main(){
+ std::vector< std::pair<int,int> > edges;
+ edges.push_back({0,1});
+ edges.push_back({1,2});
+ edges.push_back({2,3});
+ edges.push_back({1,4});
+ LCA* l = new LCA(v);
+ std::cout << l->lcaQuery(0,1) << endl;
+ std::cout << l->lcaQuery(3,4) << endl;
+ std::cout << l->lcaQuery(3,2) << endl;
 }