From 7adb0d8d5e534324f9f713b3f0dd19823b6ed768 Mon Sep 17 00:00:00 2001 From: Ayaan Khan Date: Thu, 16 Jul 2020 21:04:29 +0530 Subject: [PATCH 01/11] improved connected components --- graph/connected_components.cpp | 174 ++++++++++++++++++--------------- 1 file changed, 97 insertions(+), 77 deletions(-) diff --git a/graph/connected_components.cpp b/graph/connected_components.cpp index e53dbf424..8b2ce9944 100644 --- a/graph/connected_components.cpp +++ b/graph/connected_components.cpp @@ -15,9 +15,9 @@ * 
  * Example - Here is graph with 3 connected components
  *
- *      3   9           6               8
+ *      1   4           5               8
  *     / \ /           / \             / \
- *    2---4           2   7           3   7
+ *    2---3           6   7           9   10
  *
  *    first          second           third
  *    component      component        component
@@ -28,95 +28,115 @@
 #include 
 #include 
 #include 
-
-using std::vector;
+#include 
 
 /**
- * Class for representing graph as a adjacency list.
+ * @namespace graph
+ * @brief Graph Algorithms
  */
-class graph {
- private:
-    /** \brief adj stores adjacency list representation of graph */
-    vector> adj;
 
-    /** \brief keep track of connected components */
-    int connected_components;
+namespace graph {
+  /**
+   * @brief Function that add edge between two nodes or vertices of graph
+   *
+   * @param u any node or vertex of graph
+   * @param v any node or vertex of graph
+   */
+  void addEdge(std::vector> *adj, int u, int v) {
+    (*adj)[u - 1].push_back(v - 1);
+    (*adj)[v - 1].push_back(u - 1);
+  }
 
-    void depth_first_search();
-    void explore(int, vector &);
-
- public:
-    /**
-     * \brief Constructor that intiliazes the graph on creation and set
-     * the connected components to 0
-     */
-    explicit graph(int n) : adj(n, vector()) { connected_components = 0; }
-
-    void addEdge(int, int);
-
-    /**
-     * \brief Function the calculates the connected compoents in the graph
-     * by performing the depth first search on graph
-     *
-     * @return connected_components total connected components in graph
-     */
-    int getConnectedComponents() {
-        depth_first_search();
-        return connected_components;
+  /**
+   * @brief Utility function for depth first seach algorithm
+   * this function explores the vertex which is passed into.
+   *
+   * @param u vertex or node to be explored
+   * @param visited already visited vertices
+   */
+  void explore(const std::vector> *adj, int u,
+      std::vector &visited) {
+    visited[u] = true;
+    for (auto v : (*adj)[u]) {
+      if (!visited[v]) {
+        explore(adj, v, visited);
+      }
     }
-};
+  }
 
-/**
- * \brief Function that add edge between two nodes or vertices of graph
- *
- * @param u any node or vertex of graph
- * @param v any node or vertex of graph
- */
-void graph::addEdge(int u, int v) {
-    adj[u - 1].push_back(v - 1);
-    adj[v - 1].push_back(u - 1);
-}
-
-/**
- * \brief Function that perfoms depth first search algorithm on graph
- */
-void graph::depth_first_search() {
-    int n = adj.size();
-    vector visited(n, false);
+  /**
+   * @brief Function that perfoms depth first search algorithm on graph
+   * and calculated the number of connected components.
+   */
+  int getConnectedComponents(const std::vector> *adj) {
+    int n = adj->size();
+    int connected_components = 0;
+    std::vector visited(n, false);
 
     for (int i = 0; i < n; i++) {
-        if (!visited[i]) {
-            explore(i, visited);
-            connected_components++;
-        }
-    }
-}
-/**
- * \brief Utility function for depth first seach algorithm
- * this function explores the vertex which is passed into.
- *
- * @param u vertex or node to be explored
- * @param visited already visited vertex
- */
-void graph::explore(int u, vector &visited) {
-    visited[u] = true;
-    for (auto v : adj[u]) {
-        if (!visited[v]) {
-            explore(v, visited);
-        }
+      if (!visited[i]) {
+        explore(adj, i, visited);
+        connected_components++;
+      }
     }
+    return connected_components;
+  }
+} // namespace graph
+
+/** Function to test the algorithm */
+void tests() {
+  std::cout << "Running predefined tests..." << std::endl;
+  std::cout << "Initiating Test 1..." << std::endl;
+  std::vector> adj1(9, std::vector());
+  graph::addEdge(&adj1, 1, 2); 
+  graph::addEdge(&adj1, 1, 3); 
+  graph::addEdge(&adj1, 3, 4); 
+  graph::addEdge(&adj1, 5, 7); 
+  graph::addEdge(&adj1, 5, 6); 
+  graph::addEdge(&adj1, 8, 9);
+  
+  assert(graph::getConnectedComponents(&adj1) == 3);
+  std::cout << "Test 1 Passed..." << std::endl;
+
+  std::cout << "Innitiating Test 2..." << std::endl;
+  std::vector> adj2(10, std::vector());
+  graph::addEdge(&adj2, 1, 2);
+  graph::addEdge(&adj2, 1, 3);
+  graph::addEdge(&adj2, 1, 4);
+  graph::addEdge(&adj2, 2, 3);
+  graph::addEdge(&adj2, 3, 4);
+  graph::addEdge(&adj2, 4, 8);
+  graph::addEdge(&adj2, 4, 10);
+  graph::addEdge(&adj2, 8, 10);
+  graph::addEdge(&adj2, 8, 9);
+  graph::addEdge(&adj2, 5, 7);
+  graph::addEdge(&adj2, 5, 6);
+  graph::addEdge(&adj2, 6, 7);
+
+  assert(graph::getConnectedComponents(&adj2) == 2);
+  std::cout << "Test 2 Passed..." << std::endl;
 }
 
 /** Main function */
 int main() {
-    /// creating a graph with 4 vertex
-    graph g(4);
+  /// running predefined tests
+  tests();
+  
+  int vertices, edges;
+  std::cout << "Enter the number of vertices : ";
+  std::cin >> vertices;
+  std::cout << "Enter the number of edges : ";
+  std::cin >> edges;
 
-    /// Adding edges between vertices
-    g.addEdge(1, 2);
-    g.addEdge(3, 2);
+  std::vector> adj(vertices, std::vector());
 
-    /// printing the connected components
-    std::cout << g.getConnectedComponents();
-    return 0;
+  while (edges--) {
+    int u, v;
+    std::cin >> u >> v;
+    graph::addEdge(&adj, u, v);
+  }
+
+  int cc = graph::getConnectedComponents(&adj);
+  std::cout << cc << std::endl;
+  return 0;
 }

From 117c8362bea8568ebd27bc52bc980461e06a560a Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Thu, 16 Jul 2020 15:35:37 +0000
Subject: [PATCH 02/11] formatting source-code for
 7adb0d8d5e534324f9f713b3f0dd19823b6ed768

---
 graph/connected_components.cpp | 156 ++++++++++++++++-----------------
 1 file changed, 78 insertions(+), 78 deletions(-)

diff --git a/graph/connected_components.cpp b/graph/connected_components.cpp
index 8b2ce9944..bfb92c7c8 100644
--- a/graph/connected_components.cpp
+++ b/graph/connected_components.cpp
@@ -26,9 +26,9 @@
  */
 
 #include 
+#include 
 #include 
 #include 
-#include 
 
 /**
  * @namespace graph
@@ -36,107 +36,107 @@
  */
 
 namespace graph {
-  /**
-   * @brief Function that add edge between two nodes or vertices of graph
-   *
-   * @param u any node or vertex of graph
-   * @param v any node or vertex of graph
-   */
-  void addEdge(std::vector> *adj, int u, int v) {
+/**
+ * @brief Function that add edge between two nodes or vertices of graph
+ *
+ * @param u any node or vertex of graph
+ * @param v any node or vertex of graph
+ */
+void addEdge(std::vector> *adj, int u, int v) {
     (*adj)[u - 1].push_back(v - 1);
     (*adj)[v - 1].push_back(u - 1);
-  }
+}
 
-  /**
-   * @brief Utility function for depth first seach algorithm
-   * this function explores the vertex which is passed into.
-   *
-   * @param u vertex or node to be explored
-   * @param visited already visited vertices
-   */
-  void explore(const std::vector> *adj, int u,
-      std::vector &visited) {
+/**
+ * @brief Utility function for depth first seach algorithm
+ * this function explores the vertex which is passed into.
+ *
+ * @param u vertex or node to be explored
+ * @param visited already visited vertices
+ */
+void explore(const std::vector> *adj, int u,
+             std::vector &visited) {
     visited[u] = true;
     for (auto v : (*adj)[u]) {
-      if (!visited[v]) {
-        explore(adj, v, visited);
-      }
+        if (!visited[v]) {
+            explore(adj, v, visited);
+        }
     }
-  }
+}
 
-  /**
-   * @brief Function that perfoms depth first search algorithm on graph
-   * and calculated the number of connected components.
-   */
-  int getConnectedComponents(const std::vector> *adj) {
+/**
+ * @brief Function that perfoms depth first search algorithm on graph
+ * and calculated the number of connected components.
+ */
+int getConnectedComponents(const std::vector> *adj) {
     int n = adj->size();
     int connected_components = 0;
     std::vector visited(n, false);
 
     for (int i = 0; i < n; i++) {
-      if (!visited[i]) {
-        explore(adj, i, visited);
-        connected_components++;
-      }
+        if (!visited[i]) {
+            explore(adj, i, visited);
+            connected_components++;
+        }
     }
     return connected_components;
-  }
-} // namespace graph
+}
+}  // namespace graph
 
 /** Function to test the algorithm */
 void tests() {
-  std::cout << "Running predefined tests..." << std::endl;
-  std::cout << "Initiating Test 1..." << std::endl;
-  std::vector> adj1(9, std::vector());
-  graph::addEdge(&adj1, 1, 2); 
-  graph::addEdge(&adj1, 1, 3); 
-  graph::addEdge(&adj1, 3, 4); 
-  graph::addEdge(&adj1, 5, 7); 
-  graph::addEdge(&adj1, 5, 6); 
-  graph::addEdge(&adj1, 8, 9);
-  
-  assert(graph::getConnectedComponents(&adj1) == 3);
-  std::cout << "Test 1 Passed..." << std::endl;
+    std::cout << "Running predefined tests..." << std::endl;
+    std::cout << "Initiating Test 1..." << std::endl;
+    std::vector> adj1(9, std::vector());
+    graph::addEdge(&adj1, 1, 2);
+    graph::addEdge(&adj1, 1, 3);
+    graph::addEdge(&adj1, 3, 4);
+    graph::addEdge(&adj1, 5, 7);
+    graph::addEdge(&adj1, 5, 6);
+    graph::addEdge(&adj1, 8, 9);
 
-  std::cout << "Innitiating Test 2..." << std::endl;
-  std::vector> adj2(10, std::vector());
-  graph::addEdge(&adj2, 1, 2);
-  graph::addEdge(&adj2, 1, 3);
-  graph::addEdge(&adj2, 1, 4);
-  graph::addEdge(&adj2, 2, 3);
-  graph::addEdge(&adj2, 3, 4);
-  graph::addEdge(&adj2, 4, 8);
-  graph::addEdge(&adj2, 4, 10);
-  graph::addEdge(&adj2, 8, 10);
-  graph::addEdge(&adj2, 8, 9);
-  graph::addEdge(&adj2, 5, 7);
-  graph::addEdge(&adj2, 5, 6);
-  graph::addEdge(&adj2, 6, 7);
+    assert(graph::getConnectedComponents(&adj1) == 3);
+    std::cout << "Test 1 Passed..." << std::endl;
 
-  assert(graph::getConnectedComponents(&adj2) == 2);
-  std::cout << "Test 2 Passed..." << std::endl;
+    std::cout << "Innitiating Test 2..." << std::endl;
+    std::vector> adj2(10, std::vector());
+    graph::addEdge(&adj2, 1, 2);
+    graph::addEdge(&adj2, 1, 3);
+    graph::addEdge(&adj2, 1, 4);
+    graph::addEdge(&adj2, 2, 3);
+    graph::addEdge(&adj2, 3, 4);
+    graph::addEdge(&adj2, 4, 8);
+    graph::addEdge(&adj2, 4, 10);
+    graph::addEdge(&adj2, 8, 10);
+    graph::addEdge(&adj2, 8, 9);
+    graph::addEdge(&adj2, 5, 7);
+    graph::addEdge(&adj2, 5, 6);
+    graph::addEdge(&adj2, 6, 7);
+
+    assert(graph::getConnectedComponents(&adj2) == 2);
+    std::cout << "Test 2 Passed..." << std::endl;
 }
 
 /** Main function */
 int main() {
-  /// running predefined tests
-  tests();
-  
-  int vertices, edges;
-  std::cout << "Enter the number of vertices : ";
-  std::cin >> vertices;
-  std::cout << "Enter the number of edges : ";
-  std::cin >> edges;
+    /// running predefined tests
+    tests();
 
-  std::vector> adj(vertices, std::vector());
+    int vertices, edges;
+    std::cout << "Enter the number of vertices : ";
+    std::cin >> vertices;
+    std::cout << "Enter the number of edges : ";
+    std::cin >> edges;
 
-  while (edges--) {
-    int u, v;
-    std::cin >> u >> v;
-    graph::addEdge(&adj, u, v);
-  }
+    std::vector> adj(vertices, std::vector());
 
-  int cc = graph::getConnectedComponents(&adj);
-  std::cout << cc << std::endl;
-  return 0;
+    while (edges--) {
+        int u, v;
+        std::cin >> u >> v;
+        graph::addEdge(&adj, u, v);
+    }
+
+    int cc = graph::getConnectedComponents(&adj);
+    std::cout << cc << std::endl;
+    return 0;
 }

From f5a35eb8cd8d650a5c1c9a6e50fcdf818055d07b Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Fri, 17 Jul 2020 19:52:16 +0530
Subject: [PATCH 03/11] fix: dijkstra.cpp

---
 graph/connected_components.cpp |  24 ++--
 graph/dijkstra.cpp             | 219 ++++++++++++++++++++++++++-------
 2 files changed, 184 insertions(+), 59 deletions(-)

diff --git a/graph/connected_components.cpp b/graph/connected_components.cpp
index 8b2ce9944..55bdccbc7 100644
--- a/graph/connected_components.cpp
+++ b/graph/connected_components.cpp
@@ -55,10 +55,10 @@ namespace graph {
    * @param visited already visited vertices
    */
   void explore(const std::vector> *adj, int u,
-      std::vector &visited) {
-    visited[u] = true;
+      std::vector *visited) {
+    (*visited)[u] = true;
     for (auto v : (*adj)[u]) {
-      if (!visited[v]) {
+      if (!(*visited)[v]) {
         explore(adj, v, visited);
       }
     }
@@ -75,26 +75,26 @@ namespace graph {
 
     for (int i = 0; i < n; i++) {
       if (!visited[i]) {
-        explore(adj, i, visited);
+        explore(adj, i, &visited);
         connected_components++;
       }
     }
     return connected_components;
   }
-} // namespace graph
+}  // namespace graph
 
 /** Function to test the algorithm */
 void tests() {
   std::cout << "Running predefined tests..." << std::endl;
   std::cout << "Initiating Test 1..." << std::endl;
   std::vector> adj1(9, std::vector());
-  graph::addEdge(&adj1, 1, 2); 
-  graph::addEdge(&adj1, 1, 3); 
-  graph::addEdge(&adj1, 3, 4); 
-  graph::addEdge(&adj1, 5, 7); 
-  graph::addEdge(&adj1, 5, 6); 
+  graph::addEdge(&adj1, 1, 2);
+  graph::addEdge(&adj1, 1, 3);
+  graph::addEdge(&adj1, 3, 4);
+  graph::addEdge(&adj1, 5, 7);
+  graph::addEdge(&adj1, 5, 6);
   graph::addEdge(&adj1, 8, 9);
-  
+
   assert(graph::getConnectedComponents(&adj1) == 3);
   std::cout << "Test 1 Passed..." << std::endl;
 
@@ -121,7 +121,7 @@ void tests() {
 int main() {
   /// running predefined tests
   tests();
-  
+
   int vertices, edges;
   std::cout << "Enter the number of vertices : ";
   std::cin >> vertices;
diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index 650f0cd51..357ecf843 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -1,52 +1,177 @@
-#include 
+/**
+ * @file
+ * @brief [Graph Dijkstras Shortest Path Algorithm
+ * (Dijkstra's Shortest Path)]
+ * (https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
+ *
+ * @author [Ayaan Khan](http://github.com/ayaankhan98)
+ *
+ * @details
+ * Dijkstra's Algorithm is used to find the shortest path from a source
+ * vertex to all other reachable vertex in the graph.
+ * The algorithm initially assumes all the nodes are unreachable from the
+ * given source vertex so we mark the distances of all vertices as INF
+ * (infinity) from source vertex (INF / infinity denotes unable to reach).
+ *
+ * in similar fashion with BFS we assume the distance of source vertex as 0
+ * and pushes the vertex in a priority queue with it's distance.
+ * we maintain the priority queue as a min heap so that we can get the
+ * minimum element at the top of heap
+ *
+ * Basically what we do in this algorithm is that we try to minimize the
+ * distances of all the reachable vertices from the current vertex, look
+ * at the code below to understand in better way.
+ *
+ */
+#include 
 #include 
 #include 
+#include 
 #include 
-using namespace std;
-#define INF 10000010
-vector> graph[5 * 100001];
-int dis[5 * 100001];
-int dij(vector> *v, int s, int *dis) {
-    priority_queue, vector>,
-                   greater>>
-        pq;
-    // source distance to zero.
-    pq.push(make_pair(0, s));
-    dis[s] = 0;
-    int u;
-    while (!pq.empty()) {
-        u = (pq.top()).second;
-        pq.pop();
-        for (vector>::iterator it = v[u].begin();
-             it != v[u].end(); it++) {
-            if (dis[u] + it->first < dis[it->second]) {
-                dis[it->second] = dis[u] + it->first;
-                pq.push(make_pair(dis[it->second], it->second));
-            }
-        }
-    }
-}
-int main() {
-    int m, n, l, x, y, s;
-    // n--> number of nodes , m --> number of edges
-    cin >> n >> m;
-    for (int i = 0; i < m; i++) {
-        // input edges.
-        scanf("%d%d%d", &x, &y, &l);
-        graph[x].push_back(make_pair(l, y));
-        graph[y].push_back(
-            make_pair(l, x));  // comment this line for directed graph
-    }
-    // start node.
-    scanf("%d", &s);
-    // intialise all distances to infinity.
-    for (int i = 1; i <= n; i++) dis[i] = INF;
-    dij(graph, s, dis);
 
-    for (int i = 1; i <= n; i++)
-        if (dis[i] == INF)
-            cout << "-1 ";
-        else
-            cout << dis[i] << " ";
-    return 0;
+constexpr long long INF = 1000000000;
+
+/**
+ * @namespace graph
+ * @brief Graph Algorithms
+ */
+
+namespace graph {
+  /**
+   * @brief Function that add edge between two nodes or vertices of graph
+   *
+   * @param u any node or vertex of graph
+   * @param v any node or vertex of graph
+   */
+  void addEdge(std::vector>> *adj, int u, int v,
+      int w) {
+    (*adj)[u - 1].push_back(std::make_pair(v - 1, w));
+    // (*adj)[v - 1].push_back(std::make_pair(u - 1, w));
+  }
+  
+  /**
+   * @brief Function runs the dijkstra algorithm for some source vertex and
+   * target vertex in the graph and returns the shortest distance of target
+   * from the source.
+   *
+   * @param adj input graph
+   * @param s source vertex
+   * @param t target vertex
+   * 
+   * @return shortest distance if target is reachable from source else -1 in
+   * case if target is not reachable from source.
+   */
+  int dijkstra(std::vector>> *adj, int s, int t) {
+    /// n denotes the number of vertices in graph
+    int n = adj->size();
+
+    /// setting all the distances initially to INF
+    std::vector dist(n, INF);
+
+    /// creating a min heap using priority queue
+    /// first element of pair contains the distance
+    /// second element of pair contains the vertex
+    std::priority_queue, std::vector>,
+      std::greater>>
+        pq;
+    
+    /// pushing the source vertex 's' with 0 distance in min heap
+    pq.push(std::make_pair(0, s));
+
+    /// marking the distance of source as 0
+    dist[s] = 0;
+
+    while (!pq.empty()) {
+      /// second element of pair denotes the node / vertex
+      int currentNode = pq.top().second;
+
+      /// first element of pair denotes the distance
+      int currentDist = pq.top().first;
+
+      pq.pop();
+
+      /// for all the reachable vertex from the currently exploring vertex
+      /// we will try to minimize the distance
+      for (std::pair edge : (*adj)[currentNode]) {
+
+        /// minimizing distances
+        if (currentDist + edge.second < dist[edge.first]) {
+          dist[edge.first] = currentDist + edge.second;
+          pq.push(std::make_pair(dist[edge.first], edge.first));
+        }
+      }
+    }
+    if (dist[t] != INF) {
+      return dist[t];
+    }
+    return -1;
+  }
+} // namespace graph
+
+/** Function to test the Algorithm */
+void tests() {
+  std::cout << "Initiatinig Predefined Tests..." << std::endl;
+  std::cout << "Initiating Test 1..." << std::endl;
+  std::vector>> adj1(4, std::vector>());
+  graph::addEdge(&adj1, 1, 2, 1);
+  graph::addEdge(&adj1, 4, 1, 2);
+  graph::addEdge(&adj1, 2, 3, 2);
+  graph::addEdge(&adj1, 1, 3, 5);
+
+  int s = 1, t = 3;
+  assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
+  std::cout << "Test 1 Passed..." << std::endl;
+
+  s = 4, t = 3;
+  std::cout << "Initiating Test 2..." << std::endl;
+  assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
+  std::cout << "Test 2 Passed..." << std::endl;
+
+  std::vector>> adj2(5, std::vector>());
+  graph::addEdge(&adj2, 1, 2, 4);
+  graph::addEdge(&adj2, 1, 3, 2);
+  graph::addEdge(&adj2, 2, 3, 2);
+  graph::addEdge(&adj2, 3, 2, 1);
+  graph::addEdge(&adj2, 2, 4, 2);
+  graph::addEdge(&adj2, 3, 5, 4);
+  graph::addEdge(&adj2, 5, 4, 1);
+  graph::addEdge(&adj2, 2, 5, 3);
+  graph::addEdge(&adj2, 3, 4, 4);
+
+  s = 1, t = 5;
+  std::cout << "Initiating Test 3..." << std::endl;
+  assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
+  std::cout << "Test 3 Passed..." << std::endl;
+  std::cout << "All Test Passed..." << std::endl << std::endl;
+}
+
+/** Main function */
+int main(){
+  // running predefined tests
+  tests();
+
+  int vertices, edges;
+  std::cout << "Enter the number of vertices : ";
+  std::cin >> vertices;
+  std::cout << "Enter the number of edges : ";
+  std::cin >> edges;
+
+  std::vector>> adj(
+      vertices, std::vector>());
+
+  int u, v, w;
+  while (edges--) {
+    std::cin >> u >> v >> w;
+    graph::addEdge(&adj, u, v, w);
+  }
+
+  int s, t;
+  std::cin >> s >> t;
+  int dist = graph::dijkstra(&adj, s-1, t-1);
+  if (dist == -1) {
+    std::cout << "Target not reachable from source" << std::endl;
+  } else {
+    std::cout << "Shortest Path Distance : " << dist << std::endl;
+  }
+  return 0;
 }

From 541d3bfbcff70bbb81aad2b0080d8afd426e0da9 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 17 Jul 2020 14:27:01 +0000
Subject: [PATCH 04/11] formatting source-code for
 56556a81fbb1ff545f80cdf204e4bdfc3223d55c

---
 graph/dijkstra.cpp | 191 +++++++++++++++++++++++----------------------
 1 file changed, 96 insertions(+), 95 deletions(-)

diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index 357ecf843..3dca9e64a 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -37,31 +37,31 @@ constexpr long long INF = 1000000000;
  */
 
 namespace graph {
-  /**
-   * @brief Function that add edge between two nodes or vertices of graph
-   *
-   * @param u any node or vertex of graph
-   * @param v any node or vertex of graph
-   */
-  void addEdge(std::vector>> *adj, int u, int v,
-      int w) {
+/**
+ * @brief Function that add edge between two nodes or vertices of graph
+ *
+ * @param u any node or vertex of graph
+ * @param v any node or vertex of graph
+ */
+void addEdge(std::vector>> *adj, int u, int v,
+             int w) {
     (*adj)[u - 1].push_back(std::make_pair(v - 1, w));
     // (*adj)[v - 1].push_back(std::make_pair(u - 1, w));
-  }
-  
-  /**
-   * @brief Function runs the dijkstra algorithm for some source vertex and
-   * target vertex in the graph and returns the shortest distance of target
-   * from the source.
-   *
-   * @param adj input graph
-   * @param s source vertex
-   * @param t target vertex
-   * 
-   * @return shortest distance if target is reachable from source else -1 in
-   * case if target is not reachable from source.
-   */
-  int dijkstra(std::vector>> *adj, int s, int t) {
+}
+
+/**
+ * @brief Function runs the dijkstra algorithm for some source vertex and
+ * target vertex in the graph and returns the shortest distance of target
+ * from the source.
+ *
+ * @param adj input graph
+ * @param s source vertex
+ * @param t target vertex
+ *
+ * @return shortest distance if target is reachable from source else -1 in
+ * case if target is not reachable from source.
+ */
+int dijkstra(std::vector>> *adj, int s, int t) {
     /// n denotes the number of vertices in graph
     int n = adj->size();
 
@@ -72,9 +72,9 @@ namespace graph {
     /// first element of pair contains the distance
     /// second element of pair contains the vertex
     std::priority_queue, std::vector>,
-      std::greater>>
+                        std::greater>>
         pq;
-    
+
     /// pushing the source vertex 's' with 0 distance in min heap
     pq.push(std::make_pair(0, s));
 
@@ -82,96 +82,97 @@ namespace graph {
     dist[s] = 0;
 
     while (!pq.empty()) {
-      /// second element of pair denotes the node / vertex
-      int currentNode = pq.top().second;
+        /// second element of pair denotes the node / vertex
+        int currentNode = pq.top().second;
 
-      /// first element of pair denotes the distance
-      int currentDist = pq.top().first;
+        /// first element of pair denotes the distance
+        int currentDist = pq.top().first;
 
-      pq.pop();
+        pq.pop();
 
-      /// for all the reachable vertex from the currently exploring vertex
-      /// we will try to minimize the distance
-      for (std::pair edge : (*adj)[currentNode]) {
-
-        /// minimizing distances
-        if (currentDist + edge.second < dist[edge.first]) {
-          dist[edge.first] = currentDist + edge.second;
-          pq.push(std::make_pair(dist[edge.first], edge.first));
+        /// for all the reachable vertex from the currently exploring vertex
+        /// we will try to minimize the distance
+        for (std::pair edge : (*adj)[currentNode]) {
+            /// minimizing distances
+            if (currentDist + edge.second < dist[edge.first]) {
+                dist[edge.first] = currentDist + edge.second;
+                pq.push(std::make_pair(dist[edge.first], edge.first));
+            }
         }
-      }
     }
     if (dist[t] != INF) {
-      return dist[t];
+        return dist[t];
     }
     return -1;
-  }
-} // namespace graph
+}
+}  // namespace graph
 
 /** Function to test the Algorithm */
 void tests() {
-  std::cout << "Initiatinig Predefined Tests..." << std::endl;
-  std::cout << "Initiating Test 1..." << std::endl;
-  std::vector>> adj1(4, std::vector>());
-  graph::addEdge(&adj1, 1, 2, 1);
-  graph::addEdge(&adj1, 4, 1, 2);
-  graph::addEdge(&adj1, 2, 3, 2);
-  graph::addEdge(&adj1, 1, 3, 5);
+    std::cout << "Initiatinig Predefined Tests..." << std::endl;
+    std::cout << "Initiating Test 1..." << std::endl;
+    std::vector>> adj1(
+        4, std::vector>());
+    graph::addEdge(&adj1, 1, 2, 1);
+    graph::addEdge(&adj1, 4, 1, 2);
+    graph::addEdge(&adj1, 2, 3, 2);
+    graph::addEdge(&adj1, 1, 3, 5);
 
-  int s = 1, t = 3;
-  assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
-  std::cout << "Test 1 Passed..." << std::endl;
+    int s = 1, t = 3;
+    assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
+    std::cout << "Test 1 Passed..." << std::endl;
 
-  s = 4, t = 3;
-  std::cout << "Initiating Test 2..." << std::endl;
-  assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
-  std::cout << "Test 2 Passed..." << std::endl;
+    s = 4, t = 3;
+    std::cout << "Initiating Test 2..." << std::endl;
+    assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
+    std::cout << "Test 2 Passed..." << std::endl;
 
-  std::vector>> adj2(5, std::vector>());
-  graph::addEdge(&adj2, 1, 2, 4);
-  graph::addEdge(&adj2, 1, 3, 2);
-  graph::addEdge(&adj2, 2, 3, 2);
-  graph::addEdge(&adj2, 3, 2, 1);
-  graph::addEdge(&adj2, 2, 4, 2);
-  graph::addEdge(&adj2, 3, 5, 4);
-  graph::addEdge(&adj2, 5, 4, 1);
-  graph::addEdge(&adj2, 2, 5, 3);
-  graph::addEdge(&adj2, 3, 4, 4);
+    std::vector>> adj2(
+        5, std::vector>());
+    graph::addEdge(&adj2, 1, 2, 4);
+    graph::addEdge(&adj2, 1, 3, 2);
+    graph::addEdge(&adj2, 2, 3, 2);
+    graph::addEdge(&adj2, 3, 2, 1);
+    graph::addEdge(&adj2, 2, 4, 2);
+    graph::addEdge(&adj2, 3, 5, 4);
+    graph::addEdge(&adj2, 5, 4, 1);
+    graph::addEdge(&adj2, 2, 5, 3);
+    graph::addEdge(&adj2, 3, 4, 4);
 
-  s = 1, t = 5;
-  std::cout << "Initiating Test 3..." << std::endl;
-  assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
-  std::cout << "Test 3 Passed..." << std::endl;
-  std::cout << "All Test Passed..." << std::endl << std::endl;
+    s = 1, t = 5;
+    std::cout << "Initiating Test 3..." << std::endl;
+    assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
+    std::cout << "Test 3 Passed..." << std::endl;
+    std::cout << "All Test Passed..." << std::endl << std::endl;
 }
 
 /** Main function */
-int main(){
-  // running predefined tests
-  tests();
+int main() {
+    // running predefined tests
+    tests();
 
-  int vertices, edges;
-  std::cout << "Enter the number of vertices : ";
-  std::cin >> vertices;
-  std::cout << "Enter the number of edges : ";
-  std::cin >> edges;
+    int vertices, edges;
+    std::cout << "Enter the number of vertices : ";
+    std::cin >> vertices;
+    std::cout << "Enter the number of edges : ";
+    std::cin >> edges;
 
-  std::vector>> adj(
-      vertices, std::vector>());
+    std::vector>> adj(
+        vertices, std::vector>());
 
-  int u, v, w;
-  while (edges--) {
-    std::cin >> u >> v >> w;
-    graph::addEdge(&adj, u, v, w);
-  }
+    int u, v, w;
+    while (edges--) {
+        std::cin >> u >> v >> w;
+        graph::addEdge(&adj, u, v, w);
+    }
 
-  int s, t;
-  std::cin >> s >> t;
-  int dist = graph::dijkstra(&adj, s-1, t-1);
-  if (dist == -1) {
-    std::cout << "Target not reachable from source" << std::endl;
-  } else {
-    std::cout << "Shortest Path Distance : " << dist << std::endl;
-  }
-  return 0;
+    int s, t;
+    std::cin >> s >> t;
+    int dist = graph::dijkstra(&adj, s - 1, t - 1);
+    if (dist == -1) {
+        std::cout << "Target not reachable from source" << std::endl;
+    } else {
+        std::cout << "Shortest Path Distance : " << dist << std::endl;
+    }
+    return 0;
 }

From 54fd71569f935df6ad53a74a94745e3d01ec2611 Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Fri, 17 Jul 2020 20:32:32 +0530
Subject: [PATCH 05/11] Added CMakeLists.txt

---
 CMakeLists.txt       |  2 +-
 graph/CMakeLists.txt | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 graph/CMakeLists.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 712c3db42..8f860eb11 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -76,7 +76,7 @@ add_subdirectory(probability)
 add_subdirectory(data_structures)
 add_subdirectory(machine_learning)
 add_subdirectory(numerical_methods)
-
+add_subdirectory(graph)
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
 include(CPack)
diff --git a/graph/CMakeLists.txt b/graph/CMakeLists.txt
new file mode 100644
index 000000000..e00516075
--- /dev/null
+++ b/graph/CMakeLists.txt
@@ -0,0 +1,20 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES
+        LINKER_LANGUAGE CXX
+        CXX_STANDARD 14)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/graph")
+
+endforeach( testsourcefile ${APP_SOURCES} )

From 530da97aec01cfc1a1a0132a4875ea62a746858e Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Fri, 17 Jul 2020 20:49:00 +0530
Subject: [PATCH 06/11] fix: infinity

---
 graph/dijkstra.cpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index 3dca9e64a..9b47e446f 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -28,8 +28,9 @@
 #include 
 #include 
 #include 
+#include 
 
-constexpr long long INF = 1000000000;
+constexpr long long INF = std::numeric_limits::max();
 
 /**
  * @namespace graph
@@ -66,7 +67,7 @@ int dijkstra(std::vector>> *adj, int s, int t) {
     int n = adj->size();
 
     /// setting all the distances initially to INF
-    std::vector dist(n, INF);
+    std::vector dist(n, INF);
 
     /// creating a min heap using priority queue
     /// first element of pair contains the distance

From eb10e84a15243a4ed5463b6d268dd5c013f71e68 Mon Sep 17 00:00:00 2001
From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Date: Fri, 17 Jul 2020 15:20:20 +0000
Subject: [PATCH 07/11] formatting source-code for
 530da97aec01cfc1a1a0132a4875ea62a746858e

---
 graph/dijkstra.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index 9b47e446f..620c0215c 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -25,10 +25,10 @@
  */
 #include 
 #include 
+#include 
 #include 
 #include 
 #include 
-#include 
 
 constexpr long long INF = std::numeric_limits::max();
 

From d141abaeb895377dc72dd5b19e486e1e2afe05af Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Fri, 17 Jul 2020 21:42:28 +0530
Subject: [PATCH 08/11] Update graph/CMakeLists.txt

Co-authored-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
---
 graph/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/graph/CMakeLists.txt b/graph/CMakeLists.txt
index e00516075..02b8f4840 100644
--- a/graph/CMakeLists.txt
+++ b/graph/CMakeLists.txt
@@ -11,7 +11,7 @@ foreach( testsourcefile ${APP_SOURCES} )
 
     set_target_properties(${testname} PROPERTIES
         LINKER_LANGUAGE CXX
-        CXX_STANDARD 14)
+    )
     if(OpenMP_CXX_FOUND)
         target_link_libraries(${testname} OpenMP::OpenMP_CXX)
     endif()

From 483e00c67e462f4d8b1ad9eb5a069da976a3dfa0 Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Fri, 17 Jul 2020 21:46:17 +0530
Subject: [PATCH 09/11] Update CMakeLists.txt

Co-authored-by: David Leal 
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index da75802a5..29e8c2783 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -87,4 +87,4 @@ endif()
 
 set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
-include(CPack)
\ No newline at end of file
+include(CPack)

From 00233391820855bd63f4b9db98c57df4ce6a8463 Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Fri, 17 Jul 2020 22:40:58 +0530
Subject: [PATCH 10/11] fix: clang-tidy errors

---
 graph/connected_components.cpp | 26 ++++++++++++++++----------
 graph/dijkstra.cpp             | 13 +++++++------
 2 files changed, 23 insertions(+), 16 deletions(-)

diff --git a/graph/connected_components.cpp b/graph/connected_components.cpp
index bfb92c7c8..06bb1ee50 100644
--- a/graph/connected_components.cpp
+++ b/graph/connected_components.cpp
@@ -39,8 +39,9 @@ namespace graph {
 /**
  * @brief Function that add edge between two nodes or vertices of graph
  *
- * @param u any node or vertex of graph
- * @param v any node or vertex of graph
+ * @param adj adjacency list of graph.
+ * @param u any node or vertex of graph.
+ * @param v any node or vertex of graph.
  */
 void addEdge(std::vector> *adj, int u, int v) {
     (*adj)[u - 1].push_back(v - 1);
@@ -51,14 +52,15 @@ void addEdge(std::vector> *adj, int u, int v) {
  * @brief Utility function for depth first seach algorithm
  * this function explores the vertex which is passed into.
  *
- * @param u vertex or node to be explored
- * @param visited already visited vertices
+ * @param adj adjacency list of graph.
+ * @param u vertex or node to be explored.
+ * @param visited already visited vertices.
  */
 void explore(const std::vector> *adj, int u,
-             std::vector &visited) {
-    visited[u] = true;
+             std::vector *visited) {
+    (*visited)[u] = true;
     for (auto v : (*adj)[u]) {
-        if (!visited[v]) {
+        if (!(*visited)[v]) {
             explore(adj, v, visited);
         }
     }
@@ -67,6 +69,10 @@ void explore(const std::vector> *adj, int u,
 /**
  * @brief Function that perfoms depth first search algorithm on graph
  * and calculated the number of connected components.
+ *
+ * @param adj adjacency list of graph.
+ *
+ * @return connected_components number of connected components in graph.
  */
 int getConnectedComponents(const std::vector> *adj) {
     int n = adj->size();
@@ -75,7 +81,7 @@ int getConnectedComponents(const std::vector> *adj) {
 
     for (int i = 0; i < n; i++) {
         if (!visited[i]) {
-            explore(adj, i, visited);
+            explore(adj, i, &visited);
             connected_components++;
         }
     }
@@ -122,7 +128,7 @@ int main() {
     /// running predefined tests
     tests();
 
-    int vertices, edges;
+    int vertices = int(), edges = int();
     std::cout << "Enter the number of vertices : ";
     std::cin >> vertices;
     std::cout << "Enter the number of edges : ";
@@ -130,8 +136,8 @@ int main() {
 
     std::vector> adj(vertices, std::vector());
 
+    int u = int(), v = int();
     while (edges--) {
-        int u, v;
         std::cin >> u >> v;
         graph::addEdge(&adj, u, v);
     }
diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index 620c0215c..90fb0ec4f 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -29,8 +29,9 @@
 #include 
 #include 
 #include 
+#include 
 
-constexpr long long INF = std::numeric_limits::max();
+constexpr int64_t INF = std::numeric_limits::max();
 
 /**
  * @namespace graph
@@ -67,13 +68,13 @@ int dijkstra(std::vector>> *adj, int s, int t) {
     int n = adj->size();
 
     /// setting all the distances initially to INF
-    std::vector dist(n, INF);
+    std::vector dist(n, INF);
 
     /// creating a min heap using priority queue
     /// first element of pair contains the distance
     /// second element of pair contains the vertex
     std::priority_queue, std::vector>,
-                        std::greater>>
+                        std::greater<>>
         pq;
 
     /// pushing the source vertex 's' with 0 distance in min heap
@@ -152,7 +153,7 @@ int main() {
     // running predefined tests
     tests();
 
-    int vertices, edges;
+    int vertices = int(), edges = int();
     std::cout << "Enter the number of vertices : ";
     std::cin >> vertices;
     std::cout << "Enter the number of edges : ";
@@ -161,13 +162,13 @@ int main() {
     std::vector>> adj(
         vertices, std::vector>());
 
-    int u, v, w;
+    int u = int(), v = int(), w = int();
     while (edges--) {
         std::cin >> u >> v >> w;
         graph::addEdge(&adj, u, v, w);
     }
 
-    int s, t;
+    int s = int(), t = int();
     std::cin >> s >> t;
     int dist = graph::dijkstra(&adj, s - 1, t - 1);
     if (dist == -1) {

From cbb43c90aa2ebe69c32fcb095d946c350e85f60c Mon Sep 17 00:00:00 2001
From: Ayaan Khan 
Date: Sat, 25 Jul 2020 07:55:30 +0530
Subject: [PATCH 11/11] fix: build

---
 graph/bfs.cpp                                 | 240 +++++++++---
 .../bridge_finding_with_tarjan_algorithm.cpp  |   2 +
 graph/cycle_check_directed_graph.cpp          | 345 +++---------------
 graph/dfs.cpp                                 | 141 ++++++-
 graph/dijkstra.cpp                            | 184 +++++-----
 graph/kosaraju.cpp                            |  30 +-
 graph/kruskal.cpp                             |   2 +
 graph/lca.cpp                                 |  22 +-
 graph/topological_sort.cpp                    |  21 +-
 9 files changed, 494 insertions(+), 493 deletions(-)

diff --git a/graph/bfs.cpp b/graph/bfs.cpp
index 3acee8f80..31f9c0770 100644
--- a/graph/bfs.cpp
+++ b/graph/bfs.cpp
@@ -1,62 +1,196 @@
+/**
+ *
+ * \file
+ * \brief [Breadth First Search Algorithm
+ * (Breadth First Search)](https://en.wikipedia.org/wiki/Breadth-first_search)
+ *
+ * \author [Ayaan Khan](http://github.com/ayaankhan98)
+ *
+ * \details
+ * Breadth First Search also quoted as BFS is a Graph Traversal Algorithm.
+ * Time Complexity O(|V| + |E|) where V are the number of vertices and E
+ * are the number of edges in the graph.
+ *
+ * Applications of Breadth First Search are
+ *
+ * 1. Finding shortest path between two vertices say u and v, with path
+ *    length measured by number of edges (an advantage over depth first
+ *    search algorithm)
+ * 2. Ford-Fulkerson Method for computing the maximum flow in a flow network.
+ * 3. Testing bipartiteness of a graph.
+ * 4. Cheney's Algorithm, Copying garbage collection.
+ *
+ * And there are many more...
+ *
+ * 
working

+ * In the implementation below we first created a graph using the adjacency
+ * list representation of graph.
+ * Breadth First Search Works as follows
+ * it requires a vertex as a start vertex, Start vertex is that vertex
+ * from where you want to start traversing the graph.
+ * we maintain a bool array or a vector to keep track of the vertices
+ * which we have visited so that we do not traverse the visited vertices
+ * again and again and eventually fall into an infinite loop. Along with this
+ * boolen array we use a Queue.
+ *
+ * 1. First we mark the start vertex as visited.
+ * 2. Push this visited vertex in the Queue.
+ * 3. while the queue is not empty we repeat the following steps
+ *
+ *      1. Take out an element from the front of queue
+ *      2. start exploring the adjacency list of this vertex
+ *         if element in the adjacency list is not visited then we
+ *         push that element into the queue and mark this as visited
+ *
+ */
+#include 
+#include 
 #include 
-using namespace std;
-class graph {
-    int v;
-    list *adj;
+#include 
+#include 
 
- public:
-    graph(int v);
-    void addedge(int src, int dest);
-    void printgraph();
-    void bfs(int s);
-};
-graph::graph(int v) {
-    this->v = v;
-    this->adj = new list[v];
+/**
+ * \namespace graph
+ * \brief Graph algorithms
+ */
+namespace graph {
+/**
+ * \brief
+ * Adds and edge between two vertices of graph say u and v in this
+ * case.
+ *
+ * @param adj Adjacency list representation of graph
+ * @param u first vertex
+ * @param v second vertex
+ *
+ */
+void addEdge(std::vector> *adj, int u, int v) {
+    /**
+     * Here we are considering directed graph that's the
+     * reason we are adding v to the adjacency list representation of u
+     * but not adding u to the adjacency list representation of v
+     *
+     * in case of a un-directed graph you can un comment the statement below.
+     */
+    (*adj)[u - 1].push_back(v - 1);
+    // adj[v - 1].push_back(u -1);
 }
-void graph::addedge(int src, int dest) {
-    src--;
-    dest--;
-    adj[src].push_back(dest);
-    // adj[dest].push_back(src);
-}
-void graph::printgraph() {
-    for (int i = 0; i < this->v; i++) {
-        cout << "Adjacency list of vertex " << i + 1 << " is \n";
-        list::iterator it;
-        for (it = adj[i].begin(); it != adj[i].end(); ++it) {
-            cout << *it + 1 << " ";
-        }
-        cout << endl;
-    }
-}
-void graph::bfs(int s) {
-    bool *visited = new bool[this->v + 1];
-    memset(visited, false, sizeof(bool) * (this->v + 1));
-    visited[s] = true;
-    list q;
-    q.push_back(s);
-    list::iterator it;
-    while (!q.empty()) {
-        int u = q.front();
-        cout << u << " ";
-        q.pop_front();
-        for (it = adj[u].begin(); it != adj[u].end(); ++it) {
-            if (visited[*it] == false) {
-                visited[*it] = true;
-                q.push_back(*it);
+
+/**
+ * \brief
+ * Function performs the breadth first search algorithm over the graph
+ *
+ * @param adj Adjacency list representation of graph
+ * @param start vertex from where traversing starts
+ *
+ */
+std::vector beadth_first_search(const std::vector> &adj,
+                                     int start) {
+    size_t vertices = adj.size();
+
+    std::vector result;
+
+    /// vector to keep track of visited vertices
+    std::vector visited(vertices, 0);
+
+    std::queue tracker;
+    /// marking the start vertex as visited
+    visited[start] = true;
+    tracker.push(start);
+    while (!tracker.empty()) {
+        size_t vertex = tracker.front();
+        tracker.pop();
+        result.push_back(vertex + 1);
+        for (auto x : adj[vertex]) {
+            /// if the vertex is not visited then mark this as visited
+            /// and push it to the queue
+            if (!visited[x]) {
+                visited[x] = true;
+                tracker.push(x);
             }
         }
     }
+    return result;
 }
+}  // namespace graph
+
+void tests() {
+    std::cout << "Initiating Tests" << std::endl;
+
+    /// Test 1 Begin
+    std::vector> graphData(4, std::vector());
+    graph::addEdge(&graphData, 1, 2);
+    graph::addEdge(&graphData, 1, 3);
+    graph::addEdge(&graphData, 2, 3);
+    graph::addEdge(&graphData, 3, 1);
+    graph::addEdge(&graphData, 3, 4);
+    graph::addEdge(&graphData, 4, 4);
+
+    std::vector returnedResult = graph::beadth_first_search(graphData, 2);
+    std::vector correctResult = {3, 1, 4, 2};
+
+    assert(std::equal(correctResult.begin(), correctResult.end(),
+                      returnedResult.begin()));
+    std::cout << "Test 1 Passed..." << std::endl;
+
+    /// Test 2 Begin
+    /// clear data from previous test
+    returnedResult.clear();
+    correctResult.clear();
+
+    returnedResult = graph::beadth_first_search(graphData, 0);
+    correctResult = {1, 2, 3, 4};
+
+    assert(std::equal(correctResult.begin(), correctResult.end(),
+                      returnedResult.begin()));
+    std::cout << "Test 2 Passed..." << std::endl;
+
+    /// Test 3 Begins
+    /// clear data from previous test
+    graphData.clear();
+    returnedResult.clear();
+    correctResult.clear();
+
+    graphData.resize(6);
+    graph::addEdge(&graphData, 1, 2);
+    graph::addEdge(&graphData, 1, 3);
+    graph::addEdge(&graphData, 2, 4);
+    graph::addEdge(&graphData, 3, 4);
+    graph::addEdge(&graphData, 2, 5);
+    graph::addEdge(&graphData, 4, 6);
+
+    returnedResult = graph::beadth_first_search(graphData, 0);
+    correctResult = {1, 2, 3, 4, 5, 6};
+
+    assert(std::equal(correctResult.begin(), correctResult.end(),
+                      returnedResult.begin()));
+    std::cout << "Test 3 Passed..." << std::endl;
+}
+
+/** Main function */
 int main() {
-    graph g(4);
-    g.addedge(1, 2);
-    g.addedge(2, 3);
-    g.addedge(3, 4);
-    g.addedge(1, 4);
-    g.addedge(1, 3);
-    // g.printgraph();
-    g.bfs(2);
+    /// running predefined test cases
+    tests();
+
+    size_t vertices, edges;
+    std::cout << "Enter the number of vertices : ";
+    std::cin >> vertices;
+    std::cout << "Enter the number of edges : ";
+    std::cin >> edges;
+
+    /// creating a graph
+    std::vector> adj(vertices, std::vector());
+
+    /// taking input for edges
+    std::cout << "Enter vertices in pair which have edges between them : "
+              << std::endl;
+    while (edges--) {
+        int u, v;
+        std::cin >> u >> v;
+        graph::addEdge(&adj, u, v);
+    }
+
+    /// running Breadth First Search Algorithm on the graph
+    graph::beadth_first_search(adj, 0);
     return 0;
-}
+}
\ No newline at end of file
diff --git a/graph/bridge_finding_with_tarjan_algorithm.cpp b/graph/bridge_finding_with_tarjan_algorithm.cpp
index eec176af5..2b54e1b96 100644
--- a/graph/bridge_finding_with_tarjan_algorithm.cpp
+++ b/graph/bridge_finding_with_tarjan_algorithm.cpp
@@ -7,9 +7,11 @@
 #include   //  for min & max
 #include    //  for cout
 #include      //  for std::vector
+
 using std::cout;
 using std::min;
 using std::vector;
+
 class Solution {
     vector> graph;
     vector in_time, out_time;
diff --git a/graph/cycle_check_directed_graph.cpp b/graph/cycle_check_directed_graph.cpp
index 0f7b84cd3..c991730c0 100644
--- a/graph/cycle_check_directed_graph.cpp
+++ b/graph/cycle_check_directed_graph.cpp
@@ -1,302 +1,57 @@
-/**
- * Copyright 2020
- * @file cycle_check_directed graph.cpp
- *
- * @brief BFS and DFS algorithms to check for cycle in a directed graph.
- *
- * @author Anmol3299
- * contact: mittalanmol22@gmail.com
- *
- */
+#include 
+#include 
+#include 
+using std::vector;
+using std::pair;
 
-#include        // for std::cout
-#include           // for std::queue
-#include       // for throwing errors
-#include     // for std::remove_reference_t
-#include   // for std::unordered_map
-#include         // for std::move
-#include          // for std::vector
-
-/**
- * Implementation of non-weighted directed edge of a graph.
- *
- * The source vertex of the edge is labelled "src" and destination vertex is
- * labelled "dest".
- */
-struct Edge {
-    unsigned int src;
-    unsigned int dest;
-
-    Edge() = delete;
-    ~Edge() = default;
-    Edge(Edge&&) = default;
-    Edge& operator=(Edge&&) = default;
-    Edge(Edge const&) = default;
-    Edge& operator=(Edge const&) = default;
-
-    /** Set the source and destination of the vertex.
-     *
-     * @param source is the source vertex of the edge.
-     * @param destination is the destination vertex of the edge.
-     */
-    Edge(unsigned int source, unsigned int destination)
-        : src(source), dest(destination) {}
+void explore(int i, vector> &adj, int *state)
+{
+  state[i] = 1;
+  for(auto it2 : adj[i])
+  {
+    if (state[it2] == 0)
+    {
+      explore(it2, adj,state);
+    }
+    if (state[it2] == 1)
+    {
+      std::cout<<"1";
+      exit(0);
+    }
+  }
+  state[i] = 2;
 };
+int acyclic(vector > &adj,size_t n) {
+  //write your code here
 
-using AdjList = std::unordered_map>;
+  int state[n]; // permitted states are 0 1 and 2 
 
-/**
- * Implementation of graph class.
- *
- * The graph will be represented using Adjacency List representation.
- * This class contains 2 data members "m_vertices" & "m_adjList" used to
- * represent the number of vertices and adjacency list of the graph
- * respectively. The vertices are labelled 0 - (m_vertices - 1).
- */
-class Graph {
- public:
-    Graph() : m_vertices(0), m_adjList({}) {}
-    ~Graph() = default;
-    Graph(Graph&&) = default;
-    Graph& operator=(Graph&&) = default;
-    Graph(Graph const&) = default;
-    Graph& operator=(Graph const&) = default;
+  // mark the states of all vertices initially to 0
+  for(int i=0;i const& edges)
-        : m_vertices(vertices) {
-        for (auto const& edge : edges) {
-            if (edge.src >= vertices || edge.dest >= vertices) {
-                throw std::range_error(
-                    "Either src or dest of edge out of range");
-            }
-            m_adjList[edge.src].emplace_back(edge.dest);
-        }
+  for(auto it1 = 0; it1 != adj.size(); it1++)
+  {
+    if (state[it1] == 0)
+      explore(it1,adj,state);
+    if (state[it1] == 1)
+    {
+      std::cout<<"1";
+      exit(0);
     }
-
-    /** Return a const reference of the adjacency list.
-     *
-     * @return const reference to the adjacency list
-     */
-    std::remove_reference_t const& getAdjList() const {
-        return m_adjList;
-    }
-
-    /**
-     * @return number of vertices in the graph.
-     */
-    std::remove_reference_t const& getVertices() const {
-        return m_vertices;
-    }
-
-    /** Add vertices in the graph.
-     *
-     * @param num is the number of vertices to be added. It adds 1 vertex by
-     * default.
-     *
-     */
-    void addVertices(unsigned int num = 1) { m_vertices += num; }
-
-    /** Add an edge in the graph.
-     *
-     * @param edge that needs to be added.
-     */
-    void addEdge(Edge const& edge) {
-        if (edge.src >= m_vertices || edge.dest >= m_vertices) {
-            throw std::range_error("Either src or dest of edge out of range");
-        }
-        m_adjList[edge.src].emplace_back(edge.dest);
-    }
-
-    /** Add an Edge in the graph
-     *
-     * @param source is source vertex of the edge.
-     * @param destination is the destination vertex of the edge.
-     */
-    void addEdge(unsigned int source, unsigned int destination) {
-        if (source >= m_vertices || destination >= m_vertices) {
-            throw std::range_error(
-                "Either source or destination of edge out of range");
-        }
-        m_adjList[source].emplace_back(destination);
-    }
-
- private:
-    unsigned int m_vertices;
-    AdjList m_adjList;
-};
-
-class CycleCheck {
- private:
-    enum nodeStates : uint8_t { not_visited = 0, in_stack, visited };
-
-    /** Helper function of "isCyclicDFS".
-     *
-     * @param adjList is the adjacency list representation of some graph.
-     * @param state is the state of the nodes of the graph.
-     * @param node is the node being evaluated.
-     *
-     * @return true if graph has a cycle, else false.
-     */
-    static bool isCyclicDFSHelper(AdjList const& adjList,
-                                  std::vector* state,
-                                  unsigned int node) {
-        // Add node "in_stack" state.
-        (*state)[node] = in_stack;
-
-        // If the node has children, then recursively visit all children of the
-        // node.
-        if (auto const& it = adjList.find(node); it != adjList.end()) {
-            for (auto child : it->second) {
-                // If state of child node is "not_visited", evaluate that child
-                // for presence of cycle.
-                if (auto state_of_child = (*state)[child];
-                    state_of_child == not_visited) {
-                    if (isCyclicDFSHelper(adjList, state, child)) {
-                        return true;
-                    }
-                } else if (state_of_child == in_stack) {
-                    // If child node was "in_stack", then that means that there
-                    // is a cycle in the graph. Return true for presence of the
-                    // cycle.
-                    return true;
-                }
-            }
-        }
-
-        // Current node has been evaluated for the presence of cycle and had no
-        // cycle. Mark current node as "visited".
-        (*state)[node] = visited;
-        // Return that current node didn't result in any cycles.
-        return false;
-    }
-
- public:
-    /** Driver function to check if a graph has a cycle.
-     *
-     * This function uses DFS to check for cycle in the graph.
-     *
-     * @param graph which needs to be evaluated for the presence of cycle.
-     * @return true if a cycle is detected, else false.
-     */
-    static bool isCyclicDFS(Graph const& graph) {
-        /** State of the node.
-         *
-         * It is a vector of "nodeStates" which represents the state node is in.
-         * It can take only 3 values: "not_visited", "in_stack", and "visited".
-         *
-         * Initially, all nodes are in "not_visited" state.
-         */
-        std::vector state(graph.getVertices(), not_visited);
-
-        // Start visiting each node.
-        for (auto node = 0; node < graph.getVertices(); node++) {
-            // If a node is not visited, only then check for presence of cycle.
-            // There is no need to check for presence of cycle for a visited
-            // node as it has already been checked for presence of cycle.
-            if (state[node] == not_visited) {
-                // Check for cycle.
-                if (isCyclicDFSHelper(graph.getAdjList(), &state, node)) {
-                    return true;
-                }
-            }
-        }
-
-        // All nodes have been safely traversed, that means there is no cycle in
-        // the graph. Return false.
-        return false;
-    }
-
-    /** Check if a graph has cycle or not.
-     *
-     * This function uses BFS to check if a graph is cyclic or not.
-     *
-     * @param graph which needs to be evaluated for the presence of cycle.
-     * @return true if a cycle is detected, else false.
-     */
-    static bool isCyclicBFS(Graph const& graph) {
-        AdjList graphAjdList = graph.getAdjList();
-
-        std::vector indegree(graph.getVertices(), 0);
-        // Calculate the indegree i.e. the number of incident edges to the node.
-        for (auto const& [parent, children] : graphAjdList) {
-            for (auto const& child : children) {
-                indegree[child]++;
-            }
-        }
-
-        std::queue can_be_solved;
-        for (auto node = 0; node < graph.getVertices(); node++) {
-            // If a node doesn't have any input edges, then that node will
-            // definately not result in a cycle and can be visited safely.
-            if (!indegree[node]) {
-                can_be_solved.emplace(node);
-            }
-        }
-
-        // Vertices that need to be traversed.
-        auto remain = graph.getVertices();
-        // While there are safe nodes that we can visit.
-        while (!can_be_solved.empty()) {
-            auto front = can_be_solved.front();
-            // Visit the node.
-            can_be_solved.pop();
-            // Decrease number of nodes that need to be traversed.
-            remain--;
-
-            // Visit all the children of the visited node.
-            if (auto it = graphAjdList.find(front); it != graphAjdList.end()) {
-                for (auto child : it->second) {
-                    // Check if we can visited the node safely.
-                    if (--indegree[child] == 0) {
-                        // if node can be visited safely, then add that node to
-                        // the visit queue.
-                        can_be_solved.emplace(child);
-                    }
-                }
-            }
-        }
-
-        // If there are still nodes that we can't visit, then it means that
-        // there is a cycle and return true, else return false.
-        return !(remain == 0);
-    }
-};
-
-/**
- * Main function.
- */
-int main() {
-    // Instantiate the graph.
-    Graph g(7, std::vector{{0, 1}, {1, 2}, {2, 0}, {2, 5}, {3, 5}});
-    // Check for cycle using BFS method.
-    std::cout << CycleCheck::isCyclicBFS(g) << '\n';
-
-    // Check for cycle using DFS method.
-    std::cout << CycleCheck::isCyclicDFS(g) << '\n';
-    return 0;
+  }
+  std::cout<<"0";
+  return 0;
+}
+
+int main() {
+  size_t n, m;
+  std::cin >> n >> m;
+  vector > adj(n, vector());
+  for (size_t i = 0; i < m; i++) {
+    int x, y;
+    std::cin >> x >> y;
+    adj[x - 1].push_back(y - 1);
+  }
+  acyclic(adj,n);
 }
diff --git a/graph/dfs.cpp b/graph/dfs.cpp
index 2d38c8725..f79179045 100644
--- a/graph/dfs.cpp
+++ b/graph/dfs.cpp
@@ -1,26 +1,133 @@
+/**
+ *
+ * \file
+ * \brief [Depth First Search Algorithm
+ * (Depth First Search)](https://en.wikipedia.org/wiki/Depth-first_search)
+ *
+ * \author [Ayaan Khan](http://github.com/ayaankhan98)
+ *
+ * \details
+ * Depth First Search also quoted as DFS is a Graph Traversal Algorithm.
+ * Time Complexity O(|V| + |E|) where V is number of vertices and E
+ * is number of edges in graph.
+ *
+ * Application of Depth First Search are
+ *
+ * 1. Finding connected components
+ * 2. Finding 2-(edge or vertex)-connected components.
+ * 3. Finding 3-(edge or vertex)-connected components.
+ * 4. Finding the bridges of a graph.
+ * 5. Generating words in order to plot the limit set of a group.
+ * 6. Finding strongly connected components.
+ *
+ * And there are many more...
+ *
+ * 
Working

+ * 1. Mark all vertices as unvisited first
+ * 2. start exploring from some starting vertex.
+ *
+ *      While exploring vertex we mark the vertex as visited
+ *      and start exploring the vertices connected to this
+ *      vertex in recursive way.
+ *
+ */
+
+#include 
 #include 
-using namespace std;
-int v = 4;
-void DFSUtil_(int graph[4][4], bool visited[], int s) {
-    visited[s] = true;
-    cout << s << " ";
-    for (int i = 0; i < v; i++) {
-        if (graph[s][i] == 1 && visited[i] == false) {
-            DFSUtil_(graph, visited, i);
+#include 
+
+/**
+ *
+ * \namespace graph
+ * \brief Graph Algorithms
+ *
+ */
+namespace graph {
+/**
+ * \brief
+ * Adds and edge between two vertices of graph say u and v in this
+ * case.
+ *
+ * @param adj Adjacency list representation of graph
+ * @param u first vertex
+ * @param v second vertex
+ *
+ */
+void addEdge(std::vector> *adj, size_t u, size_t v) {
+    /**
+     *
+     * Here we are considering undirected graph that's the
+     * reason we are adding v to the adjacency list representation of u
+     * and also adding u to the adjacency list representation of v
+     *
+     */
+    (*adj)[u - 1].push_back(v - 1);
+    (*adj)[v - 1].push_back(u - 1);
+}
+
+/**
+ *
+ * \brief
+ * Explores the given vertex, exploring a vertex means traversing
+ * over all the vertices which are connected to the vertex that is
+ * currently being explored.
+ *
+ * @param adj garph
+ * @param v vertex to be explored
+ * @param visited already visited vertices
+ *
+ */
+void explore(const std::vector> &adj, size_t v,
+             std::vector *visited) {
+    std::cout << v + 1 << " ";
+    (*visited)[v] = true;
+    for (auto x : adj[v]) {
+        if (!(*visited)[x]) {
+            explore(adj, x, visited);
         }
     }
 }
 
-void DFS_(int graph[4][4], int s) {
-    bool visited[v];
-    memset(visited, 0, sizeof(visited));
-    DFSUtil_(graph, visited, s);
-}
+/**
+ * \brief
+ * initiates depth first search algorithm.
+ *
+ * @param adj adjacency list of graph
+ * @param start vertex from where DFS starts traversing.
+ *
+ */
+void depth_first_search(const std::vector> &adj,
+                        size_t start) {
+    size_t vertices = adj.size();
 
+    std::vector visited(vertices, false);
+    explore(adj, start, &visited);
+}
+}  // namespace graph
+
+/** Main function */
 int main() {
-    int graph[4][4] = {{0, 1, 1, 0}, {0, 0, 1, 0}, {1, 0, 0, 1}, {0, 0, 0, 1}};
-    cout << "DFS: ";
-    DFS_(graph, 2);
-    cout << endl;
+    size_t vertices, edges;
+    std::cout << "Enter the Vertices : ";
+    std::cin >> vertices;
+    std::cout << "Enter the Edges : ";
+    std::cin >> edges;
+
+    /// creating graph
+    std::vector> adj(vertices, std::vector());
+
+    /// taking input for edges
+    std::cout << "Enter the vertices which have edges between them : "
+              << std::endl;
+    while (edges--) {
+        size_t u, v;
+        std::cin >> u >> v;
+        graph::addEdge(&adj, u, v);
+    }
+
+    /// running depth first search over graph
+    graph::depth_first_search(adj, 2);
+
+    std::cout << std::endl;
     return 0;
 }
\ No newline at end of file
diff --git a/graph/dijkstra.cpp b/graph/dijkstra.cpp
index 90fb0ec4f..ac269de18 100644
--- a/graph/dijkstra.cpp
+++ b/graph/dijkstra.cpp
@@ -39,31 +39,31 @@ constexpr int64_t INF = std::numeric_limits::max();
  */
 
 namespace graph {
-/**
- * @brief Function that add edge between two nodes or vertices of graph
- *
- * @param u any node or vertex of graph
- * @param v any node or vertex of graph
- */
-void addEdge(std::vector>> *adj, int u, int v,
-             int w) {
+  /**
+   * @brief Function that add edge between two nodes or vertices of graph
+   *
+   * @param u any node or vertex of graph
+   * @param v any node or vertex of graph
+   */
+  void addEdge(std::vector>> *adj, int u, int v,
+      int w) {
     (*adj)[u - 1].push_back(std::make_pair(v - 1, w));
     // (*adj)[v - 1].push_back(std::make_pair(u - 1, w));
-}
+  }
 
-/**
- * @brief Function runs the dijkstra algorithm for some source vertex and
- * target vertex in the graph and returns the shortest distance of target
- * from the source.
- *
- * @param adj input graph
- * @param s source vertex
- * @param t target vertex
- *
- * @return shortest distance if target is reachable from source else -1 in
- * case if target is not reachable from source.
- */
-int dijkstra(std::vector>> *adj, int s, int t) {
+  /**
+   * @brief Function runs the dijkstra algorithm for some source vertex and
+   * target vertex in the graph and returns the shortest distance of target
+   * from the source.
+   *
+   * @param adj input graph
+   * @param s source vertex
+   * @param t target vertex
+   *
+   * @return shortest distance if target is reachable from source else -1 in
+   * case if target is not reachable from source.
+   */
+  int dijkstra(std::vector>> *adj, int s, int t) {
     /// n denotes the number of vertices in graph
     int n = adj->size();
 
@@ -74,7 +74,7 @@ int dijkstra(std::vector>> *adj, int s, int t) {
     /// first element of pair contains the distance
     /// second element of pair contains the vertex
     std::priority_queue, std::vector>,
-                        std::greater<>>
+      std::greater>>
         pq;
 
     /// pushing the source vertex 's' with 0 distance in min heap
@@ -84,97 +84,97 @@ int dijkstra(std::vector>> *adj, int s, int t) {
     dist[s] = 0;
 
     while (!pq.empty()) {
-        /// second element of pair denotes the node / vertex
-        int currentNode = pq.top().second;
+      /// second element of pair denotes the node / vertex
+      int currentNode = pq.top().second;
 
-        /// first element of pair denotes the distance
-        int currentDist = pq.top().first;
+      /// first element of pair denotes the distance
+      int currentDist = pq.top().first;
 
-        pq.pop();
+      pq.pop();
 
-        /// for all the reachable vertex from the currently exploring vertex
-        /// we will try to minimize the distance
-        for (std::pair edge : (*adj)[currentNode]) {
-            /// minimizing distances
-            if (currentDist + edge.second < dist[edge.first]) {
-                dist[edge.first] = currentDist + edge.second;
-                pq.push(std::make_pair(dist[edge.first], edge.first));
-            }
+      /// for all the reachable vertex from the currently exploring vertex
+      /// we will try to minimize the distance
+      for (std::pair edge : (*adj)[currentNode]) {
+        /// minimizing distances
+        if (currentDist + edge.second < dist[edge.first]) {
+          dist[edge.first] = currentDist + edge.second;
+          pq.push(std::make_pair(dist[edge.first], edge.first));
         }
+      }
     }
     if (dist[t] != INF) {
-        return dist[t];
+      return dist[t];
     }
     return -1;
-}
+  }
 }  // namespace graph
 
 /** Function to test the Algorithm */
 void tests() {
-    std::cout << "Initiatinig Predefined Tests..." << std::endl;
-    std::cout << "Initiating Test 1..." << std::endl;
-    std::vector>> adj1(
-        4, std::vector>());
-    graph::addEdge(&adj1, 1, 2, 1);
-    graph::addEdge(&adj1, 4, 1, 2);
-    graph::addEdge(&adj1, 2, 3, 2);
-    graph::addEdge(&adj1, 1, 3, 5);
+  std::cout << "Initiatinig Predefined Tests..." << std::endl;
+  std::cout << "Initiating Test 1..." << std::endl;
+  std::vector>> adj1(
+      4, std::vector>());
+  graph::addEdge(&adj1, 1, 2, 1);
+  graph::addEdge(&adj1, 4, 1, 2);
+  graph::addEdge(&adj1, 2, 3, 2);
+  graph::addEdge(&adj1, 1, 3, 5);
 
-    int s = 1, t = 3;
-    assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
-    std::cout << "Test 1 Passed..." << std::endl;
+  int s = 1, t = 3;
+  assert(graph::dijkstra(&adj1, s - 1, t - 1) == 3);
+  std::cout << "Test 1 Passed..." << std::endl;
 
-    s = 4, t = 3;
-    std::cout << "Initiating Test 2..." << std::endl;
-    assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
-    std::cout << "Test 2 Passed..." << std::endl;
+  s = 4, t = 3;
+  std::cout << "Initiating Test 2..." << std::endl;
+  assert(graph::dijkstra(&adj1, s - 1, t - 1) == 5);
+  std::cout << "Test 2 Passed..." << std::endl;
 
-    std::vector>> adj2(
-        5, std::vector>());
-    graph::addEdge(&adj2, 1, 2, 4);
-    graph::addEdge(&adj2, 1, 3, 2);
-    graph::addEdge(&adj2, 2, 3, 2);
-    graph::addEdge(&adj2, 3, 2, 1);
-    graph::addEdge(&adj2, 2, 4, 2);
-    graph::addEdge(&adj2, 3, 5, 4);
-    graph::addEdge(&adj2, 5, 4, 1);
-    graph::addEdge(&adj2, 2, 5, 3);
-    graph::addEdge(&adj2, 3, 4, 4);
+  std::vector>> adj2(
+      5, std::vector>());
+  graph::addEdge(&adj2, 1, 2, 4);
+  graph::addEdge(&adj2, 1, 3, 2);
+  graph::addEdge(&adj2, 2, 3, 2);
+  graph::addEdge(&adj2, 3, 2, 1);
+  graph::addEdge(&adj2, 2, 4, 2);
+  graph::addEdge(&adj2, 3, 5, 4);
+  graph::addEdge(&adj2, 5, 4, 1);
+  graph::addEdge(&adj2, 2, 5, 3);
+  graph::addEdge(&adj2, 3, 4, 4);
 
-    s = 1, t = 5;
-    std::cout << "Initiating Test 3..." << std::endl;
-    assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
-    std::cout << "Test 3 Passed..." << std::endl;
-    std::cout << "All Test Passed..." << std::endl << std::endl;
+  s = 1, t = 5;
+  std::cout << "Initiating Test 3..." << std::endl;
+  assert(graph::dijkstra(&adj2, s - 1, t - 1) == 6);
+  std::cout << "Test 3 Passed..." << std::endl;
+  std::cout << "All Test Passed..." << std::endl << std::endl;
 }
 
 /** Main function */
 int main() {
-    // running predefined tests
-    tests();
+  // running predefined tests
+  tests();
 
-    int vertices = int(), edges = int();
-    std::cout << "Enter the number of vertices : ";
-    std::cin >> vertices;
-    std::cout << "Enter the number of edges : ";
-    std::cin >> edges;
+  int vertices = int(), edges = int();
+  std::cout << "Enter the number of vertices : ";
+  std::cin >> vertices;
+  std::cout << "Enter the number of edges : ";
+  std::cin >> edges;
 
-    std::vector>> adj(
-        vertices, std::vector>());
+  std::vector>> adj(
+      vertices, std::vector>());
 
-    int u = int(), v = int(), w = int();
-    while (edges--) {
-        std::cin >> u >> v >> w;
-        graph::addEdge(&adj, u, v, w);
-    }
+  int u = int(), v = int(), w = int();
+  while (edges--) {
+    std::cin >> u >> v >> w;
+    graph::addEdge(&adj, u, v, w);
+  }
 
-    int s = int(), t = int();
-    std::cin >> s >> t;
-    int dist = graph::dijkstra(&adj, s - 1, t - 1);
-    if (dist == -1) {
-        std::cout << "Target not reachable from source" << std::endl;
-    } else {
-        std::cout << "Shortest Path Distance : " << dist << std::endl;
-    }
-    return 0;
+  int s = int(), t = int();
+  std::cin >> s >> t;
+  int dist = graph::dijkstra(&adj, s - 1, t - 1);
+  if (dist == -1) {
+    std::cout << "Target not reachable from source" << std::endl;
+  } else {
+    std::cout << "Shortest Path Distance : " << dist << std::endl;
+  }
+  return 0;
 }
diff --git a/graph/kosaraju.cpp b/graph/kosaraju.cpp
index 00c9d7ca0..a9ef121aa 100644
--- a/graph/kosaraju.cpp
+++ b/graph/kosaraju.cpp
@@ -4,8 +4,8 @@
 
 #include 
 #include 
+#include 
 
-using namespace std;
 
 /**
  * Iterative function/method to print graph:
@@ -13,13 +13,13 @@ using namespace std;
  * @param V : vertices
  * @return void
  **/
-void print(vector a[], int V) {
+void print(std::vector a[], int V) {
     for (int i = 0; i < V; i++) {
         if (!a[i].empty())
-            cout << "i=" << i << "-->";
-        for (int j = 0; j < a[i].size(); j++) cout << a[i][j] << " ";
+            std::cout << "i=" << i << "-->";
+        for (int j = 0; j < a[i].size(); j++) std::cout << a[i][j] << " ";
         if (!a[i].empty())
-            cout << endl;
+            std::cout << std::endl;
     }
 }
 
@@ -31,7 +31,7 @@ void print(vector a[], int V) {
  * @param adj[] : array of vectors to represent graph
  * @return void
  **/
-void push_vertex(int v, stack &st, bool vis[], vector adj[]) {
+void push_vertex(int v, std::stack &st, bool vis[], std::vector adj[]) {
     vis[v] = true;
     for (auto i = adj[v].begin(); i != adj[v].end(); i++) {
         if (vis[*i] == false)
@@ -47,7 +47,7 @@ void push_vertex(int v, stack &st, bool vis[], vector adj[]) {
  * @param grev[] : graph with reversed edges
  * @return void
  **/
-void dfs(int v, bool vis[], vector grev[]) {
+void dfs(int v, bool vis[], std::vector grev[]) {
     vis[v] = true;
     // cout<0)) i.e. it returns the
 count of (number of) strongly connected components (SCCs) in the graph.
 (variable 'count_scc' within function)
 **/
-int kosaraju(int V, vector adj[]) {
+int kosaraju(int V, std::vector adj[]) {
     bool vis[V] = {};
-    stack st;
+    std::stack st;
     for (int v = 0; v < V; v++) {
         if (vis[v] == false)
             push_vertex(v, st, vis, adj);
     }
     // making new graph (grev) with reverse edges as in adj[]:
-    vector grev[V];
+    std::vector grev[V];
     for (int i = 0; i < V + 1; i++) {
         for (auto j = adj[i].begin(); j != adj[i].end(); j++) {
             grev[*j].push_back(i);
@@ -102,20 +102,20 @@ int kosaraju(int V, vector adj[]) {
 // Input your required values: (not hardcoded)
 int main() {
     int t;
-    cin >> t;
+    std::cin >> t;
     while (t--) {
         int a, b;  // a->number of nodes, b->directed edges.
-        cin >> a >> b;
+        std::cin >> a >> b;
         int m, n;
-        vector adj[a + 1];
+        std::vector adj[a + 1];
         for (int i = 0; i < b; i++)  // take total b inputs of 2 vertices each
                                      // required to form an edge.
         {
-            cin >> m >> n;  // take input m,n denoting edge from m->n.
+            std::cin >> m >> n;  // take input m,n denoting edge from m->n.
             adj[m].push_back(n);
         }
         // pass number of nodes and adjacency array as parameters to function:
-        cout << kosaraju(a, adj) << endl;
+        std::cout << kosaraju(a, adj) << std::endl;
     }
     return 0;
 }
diff --git a/graph/kruskal.cpp b/graph/kruskal.cpp
index b7b830668..861b81ae1 100644
--- a/graph/kruskal.cpp
+++ b/graph/kruskal.cpp
@@ -1,4 +1,6 @@
 #include 
+#include 
+#include 
 //#include 
 // using namespace boost::multiprecision;
 const int mx = 1e6 + 5;
diff --git a/graph/lca.cpp b/graph/lca.cpp
index c05cf7b9b..e69be62fa 100644
--- a/graph/lca.cpp
+++ b/graph/lca.cpp
@@ -1,7 +1,9 @@
 //#include
 #include 
-
-using namespace std;
+#include 
+#include 
+#include 
+#include 
 // Find the lowest common ancestor using binary lifting in O(nlogn)
 // Zero based indexing
 // Resource : https://cp-algorithms.com/graph/lca_binary_lifting.html
@@ -9,7 +11,7 @@ const int N = 1005;
 const int LG = log2(N) + 1;
 struct lca {
     int n;
-    vector adj[N];  // Graph
+    std::vector adj[N];  // Graph
     int up[LG][N];       // build this table
     int level[N];        // get the levels of all of them
 
@@ -18,7 +20,7 @@ struct lca {
         memset(level, 0, sizeof(level));
         for (int i = 0; i < n - 1; ++i) {
             int a, b;
-            cin >> a >> b;
+            std::cin >> a >> b;
             a--;
             b--;
             adj[a].push_back(b);
@@ -30,15 +32,15 @@ struct lca {
     }
     void verify() {
         for (int i = 0; i < n; ++i) {
-            cout << i << " : level: " << level[i] << endl;
+            std::cout << i << " : level: " << level[i] << std::endl;
         }
-        cout << endl;
+        std::cout << std::endl;
         for (int i = 0; i < LG; ++i) {
-            cout << "Power:" << i << ": ";
+            std::cout << "Power:" << i << ": ";
             for (int j = 0; j < n; ++j) {
-                cout << up[i][j] << " ";
+                std::cout << up[i][j] << " ";
             }
-            cout << endl;
+            std::cout << std::endl;
         }
     }
 
@@ -65,7 +67,7 @@ struct lca {
         u--;
         v--;
         if (level[v] > level[u]) {
-            swap(u, v);
+            std::swap(u, v);
         }
         // u is at the bottom.
         int dist = level[u] - level[v];
diff --git a/graph/topological_sort.cpp b/graph/topological_sort.cpp
index 9e6c8917b..e7dd7ab63 100644
--- a/graph/topological_sort.cpp
+++ b/graph/topological_sort.cpp
@@ -1,12 +1,11 @@
 #include 
 #include 
 #include 
-using namespace std;
 
 int n, m;  // For number of Vertices (V) and number of edges (E)
-vector> G;
-vector visited;
-vector ans;
+std::vector> G;
+std::vector visited;
+std::vector ans;
 
 void dfs(int v) {
     visited[v] = true;
@@ -27,21 +26,21 @@ void topological_sort() {
     reverse(ans.begin(), ans.end());
 }
 int main() {
-    cout << "Enter the number of vertices and the number of directed edges\n";
-    cin >> n >> m;
+    std::cout << "Enter the number of vertices and the number of directed edges\n";
+    std::cin >> n >> m;
     int x, y;
-    G.resize(n, vector());
+    G.resize(n, std::vector());
     for (int i = 0; i < n; ++i) {
-        cin >> x >> y;
+        std::cin >> x >> y;
         x--, y--;  // to convert 1-indexed to 0-indexed
         G[x].push_back(y);
     }
     topological_sort();
-    cout << "Topological Order : \n";
+    std::cout << "Topological Order : \n";
     for (int v : ans) {
-        cout << v + 1
+        std::cout << v + 1
              << ' ';  // converting zero based indexing back to one based.
     }
-    cout << '\n';
+    std::cout << '\n';
     return 0;
 }