Revert "chore: use iwyu on graph/**.cpp"

This reverts commit dabd6d2.

Author: realstealthninja

graph/bidirectional_dijkstra.cpp

@@ -13,14 +13,13 @@
  * https://www.youtube.com/watch?v=DINCL5cd_w0&t=24s
  */
 
-#include <cassert>     // for assert
-#include <cstdint>     // for uint64_t, int64_t
-#include <iostream>    // for basic_ostream, operator<<, char_traits, cout
-#include <limits>      // for numeric_limits
-#include <queue>       // for priority_queue
-#include <utility>     // for pair, make_pair
-#include <vector>      // for vector
-#include <functional>  // for greater
+#include <cassert>   /// for assert
+#include <cstdint>   /// for integral typedefs
+#include <iostream>  /// for io operations
+#include <limits>    /// for variable INF
+#include <queue>     /// for the priority_queue of distances
+#include <utility>   /// for make_pair function
+#include <vector>    /// for store the graph, the distances, and the path
 
 constexpr int64_t INF = std::numeric_limits<int64_t>::max();
 

graph/breadth_first_search.cpp

@@ -45,14 +45,14 @@
  *         push that element into the queue and mark this as visited
  *
  */
-#include <cassert>     // for assert
-#include <cstddef>     // for size_t
-#include <functional>  // for less
-#include <iostream>    // for basic_ostream, operator<<, cout, basic_istream...
-#include <list>        // for list
-#include <map>         // for map, operator==
-#include <queue>       // for queue
-#include <string>      // for basic_string, operator<, char_traits, allocator
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <list>
+#include <map>
+#include <queue>
+#include <string>
+#include <vector>
 
 /**
  * \namespace graph

graph/connected_components.cpp

@@ -25,9 +25,10 @@
  *
  */
 
-#include <cassert>   // for assert
-#include <iostream>  // for basic_ostream, char_traits, operator<<, basic_is...
-#include <vector>    // for vector
+#include <algorithm>
+#include <cassert>
+#include <iostream>
+#include <vector>
 
 /**
  * @namespace graph

graph/connected_components_with_dsu.cpp

@@ -17,11 +17,10 @@
  * @author Unknown author
  * @author [Sagar Pandya](https://github.com/sagarpandyansit)
  */
-#include <cstdint>   // for int64_t, uint32_t
-#include <iostream>  // for char_traits, basic_istream, cin, basic_ostream
-#include <set>       // for set
-#include <vector>    // for vector
-#include <utility>   // for swap
+#include <cstdint>   /// for integer typedefs
+#include <iostream>  /// for IO operations
+#include <set>       /// for std::set
+#include <vector>    /// for std::vector
 
 /**
  * @namespace graph

graph/cycle_check_directed_graph.cpp

@@ -7,15 +7,14 @@
  *
  */
 
-#include <cstdint>           // for uint8_t
-#include <iostream>          // for char_traits, basic_ostream, operator<<
-#include <map>               // for map, operator!=, _Rb_tree_iterator
-#include <queue>             // for queue
-#include <stdexcept>         // for range_error
-#include <type_traits>       // for remove_reference
-#include <utility>           // for move, pair
-#include <vector>            // for vector
-#include <initializer_list>  // for initializer_list
+#include <cstdint>      /// for integral typedefs
+#include <iostream>     // for std::cout
+#include <map>          // for std::map
+#include <queue>        // for std::queue
+#include <stdexcept>    // for throwing errors
+#include <type_traits>  // for std::remove_reference
+#include <utility>      // for std::move
+#include <vector>       // for std::vector
 
 /**
  * Implementation of non-weighted directed edge of a graph.

graph/depth_first_search.cpp

@@ -32,9 +32,9 @@
  *
  */
 
-#include <cstddef>   // for size_t
-#include <iostream>  // for char_traits, basic_ostream, operator<<, cout
-#include <vector>    // for vector
+#include <algorithm>
+#include <iostream>
+#include <vector>
 
 /**
  *

graph/depth_first_search_with_stack.cpp

@@ -2,8 +2,7 @@
  *
  * @file
  * @brief [Depth First Search Algorithm using Stack
- * (Depth First Search
- * Algorithm)](https://en.wikipedia.org/wiki/Depth-first_search)
+ * (Depth First Search Algorithm)](https://en.wikipedia.org/wiki/Depth-first_search)
  *
  * @author [Ayaan Khan](http://github.com/ayaankhan98)
  * @author [Saurav Uppoor](https://github.com/sauravUppoor)
@@ -25,35 +24,31 @@
  * <h4>Working</h4>
  * 1. Mark all vertices as unvisited (colour it WHITE).
  * 2. Push starting vertex into the stack and colour it GREY.
- * 3. Once a node is popped out of the stack and is coloured GREY, we colour it
- * BLACK.
+ * 3. Once a node is popped out of the stack and is coloured GREY, we colour it BLACK.
  * 4. Push all its neighbours which are not coloured BLACK.
  * 5. Repeat steps 4 and 5 until the stack is empty.
  */
 
-#include <stdint.h>  // for int16_t, int64_t
+#include <iostream> 	 /// for IO operations
+#include <stack>    	 /// header for std::stack
+#include <vector>   	 /// header for std::vector
+#include <cassert>  	 /// header for preprocessor macro assert() 
+#include <limits>   	 /// header for limits of integral types
 
-#include <cassert>   // for assert
-#include <cstddef>   // for size_t
-#include <iostream>  // for basic_ostream, operator<<, char_traits, cout, endl
-#include <limits>    // for numeric_limits
-#include <stack>     // for stack
-#include <vector>    // for vector, operator==
-
-constexpr int WHITE = 0;  /// indicates the node hasn't been explored
-constexpr int GREY = 1;   /// indicates node is in stack waiting to be explored
-constexpr int BLACK = 2;  /// indicates node has already been explored
+constexpr int WHITE = 0; /// indicates the node hasn't been explored
+constexpr int GREY = 1;	 /// indicates node is in stack waiting to be explored
+constexpr int BLACK = 2; /// indicates node has already been explored
 constexpr int64_t INF = std::numeric_limits<int16_t>::max();
 
+
 /**
  * @namespace graph
  * @brief Graph algorithms
  */
 namespace graph {
 /**
  * @namespace depth_first_search
- * @brief Functions for [Depth First
- * Search](https://en.wikipedia.org/wiki/Depth-first_search) algorithm
+ * @brief Functions for [Depth First Search](https://en.wikipedia.org/wiki/Depth-first_search) algorithm
  */
 namespace depth_first_search {
 /**
@@ -67,14 +62,14 @@ namespace depth_first_search {
  *
  */
 void addEdge(std::vector<std::vector<size_t>> *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);
+	/*
+	*
+	* 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);
 }
 
 /**
@@ -89,8 +84,7 @@ void addEdge(std::vector<std::vector<size_t>> *adj, size_t u, size_t v) {
  * @return vector with nodes stored in the order of DFS traversal
  *
  */
-std::vector<size_t> dfs(const std::vector<std::vector<size_t>> &graph,
-                        size_t start) {
+std::vector<size_t> dfs(const std::vector<std::vector<size_t> > &graph, size_t start) {
     /// checked[i] stores the status of each node
     std::vector<size_t> checked(graph.size(), WHITE), traversed_path;
 
@@ -127,51 +121,49 @@ std::vector<size_t> dfs(const std::vector<std::vector<size_t>> &graph,
  * @returns none
  */
 static void tests() {
-    size_t start_pos;
-
-    /// Test 1
-    std::cout << "Case 1: " << std::endl;
-    start_pos = 1;
-    std::vector<std::vector<size_t>> g1(3, std::vector<size_t>());
-
-    graph::depth_first_search::addEdge(&g1, 1, 2);
-    graph::depth_first_search::addEdge(&g1, 2, 3);
-    graph::depth_first_search::addEdge(&g1, 3, 1);
-
-    std::vector<size_t> expected1{
-        1, 2, 3};  /// for the above sample data, this is the expected output
-    assert(graph::depth_first_search::dfs(g1, start_pos - 1) == expected1);
-    std::cout << "Passed" << std::endl;
-
-    /// Test 2
-    std::cout << "Case 2: " << std::endl;
-    start_pos = 1;
-    std::vector<std::vector<size_t>> g2(4, std::vector<size_t>());
-
-    graph::depth_first_search::addEdge(&g2, 1, 2);
-    graph::depth_first_search::addEdge(&g2, 1, 3);
-    graph::depth_first_search::addEdge(&g2, 2, 4);
-    graph::depth_first_search::addEdge(&g2, 4, 1);
-
-    std::vector<size_t> expected2{
-        1, 3, 2, 4};  /// for the above sample data, this is the expected output
-    assert(graph::depth_first_search::dfs(g2, start_pos - 1) == expected2);
-    std::cout << "Passed" << std::endl;
-
-    /// Test 3
-    std::cout << "Case 3: " << std::endl;
-    start_pos = 2;
-    std::vector<std::vector<size_t>> g3(4, std::vector<size_t>());
-
-    graph::depth_first_search::addEdge(&g3, 1, 2);
-    graph::depth_first_search::addEdge(&g3, 1, 3);
-    graph::depth_first_search::addEdge(&g3, 2, 4);
-    graph::depth_first_search::addEdge(&g3, 4, 1);
-
-    std::vector<size_t> expected3{
-        2, 4, 1, 3};  /// for the above sample data, this is the expected output
-    assert(graph::depth_first_search::dfs(g3, start_pos - 1) == expected3);
-    std::cout << "Passed" << std::endl;
+	size_t start_pos;
+
+	/// Test 1
+	std::cout << "Case 1: " << std::endl;
+	start_pos = 1;
+	std::vector<std::vector<size_t> > g1(3, std::vector<size_t>());
+
+	graph::depth_first_search::addEdge(&g1, 1, 2);
+	graph::depth_first_search::addEdge(&g1, 2, 3);
+	graph::depth_first_search::addEdge(&g1, 3, 1);
+
+	std::vector<size_t> expected1 {1, 2, 3}; /// for the above sample data, this is the expected output
+	assert(graph::depth_first_search::dfs(g1, start_pos - 1) == expected1);
+	std::cout << "Passed" << std::endl;
+
+	/// Test 2
+	std::cout << "Case 2: " << std::endl;
+	start_pos = 1;
+	std::vector<std::vector<size_t> > g2(4, std::vector<size_t>());
+
+	graph::depth_first_search::addEdge(&g2, 1, 2);
+	graph::depth_first_search::addEdge(&g2, 1, 3);
+	graph::depth_first_search::addEdge(&g2, 2, 4);
+	graph::depth_first_search::addEdge(&g2, 4, 1);
+
+	std::vector<size_t> expected2 {1, 3, 2, 4}; /// for the above sample data, this is the expected output
+	assert(graph::depth_first_search::dfs(g2, start_pos - 1) == expected2);
+	std::cout << "Passed" << std::endl;
+
+	/// Test 3
+	std::cout << "Case 3: " << std::endl;
+	start_pos = 2;
+	std::vector<std::vector<size_t> > g3(4, std::vector<size_t>());
+
+	graph::depth_first_search::addEdge(&g3, 1, 2);
+	graph::depth_first_search::addEdge(&g3, 1, 3);
+	graph::depth_first_search::addEdge(&g3, 2, 4);
+	graph::depth_first_search::addEdge(&g3, 4, 1);
+
+	std::vector<size_t> expected3 {2, 4, 1, 3}; /// for the above sample data, this is the expected output
+	assert(graph::depth_first_search::dfs(g3, start_pos - 1) == expected3);
+	std::cout << "Passed" << std::endl;
+
 }
 
 /**
@@ -182,35 +174,34 @@ int main() {
     tests();  // execute the tests
 
     size_t vertices = 0, edges = 0, start_pos = 1;
-    std::vector<size_t> traversal;
+	std::vector<size_t> traversal;
 
     std::cout << "Enter the Vertices : ";
-    std::cin >> vertices;
-    std::cout << "Enter the Edges : ";
-    std::cin >> edges;
+	std::cin >> vertices;
+	std::cout << "Enter the Edges : ";
+	std::cin >> edges;
 
     /// creating a graph
-    std::vector<std::vector<size_t>> adj(vertices, std::vector<size_t>());
+    std::vector<std::vector<size_t> > adj(vertices, std::vector<size_t>());
 
     /// taking input for the edges
-    std::cout << "Enter the vertices which have edges between them : "
-              << std::endl;
-    while (edges--) {
-        size_t u = 0, v = 0;
-        std::cin >> u >> v;
-        graph::depth_first_search::addEdge(&adj, u, v);
-    }
+    std::cout << "Enter the vertices which have edges between them : " << std::endl;
+	while (edges--) {
+		size_t u = 0, v = 0;
+		std::cin >> u >> v;
+		graph::depth_first_search::addEdge(&adj, u, v);
+	}
 
     /// taking input for the starting position
     std::cout << "Enter the starting vertex [1,n]: " << std::endl;
-    std::cin >> start_pos;
-    start_pos -= 1;
-    traversal = graph::depth_first_search::dfs(adj, start_pos);
+	std::cin >> start_pos;
+	start_pos -= 1;
+	traversal = graph::depth_first_search::dfs(adj, start_pos);
 
     /// Printing the order of traversal
     for (auto x : traversal) {
-        std::cout << x << ' ';
-    }
+		std::cout << x << ' ';
+	}
 
     return 0;
 }

graph/dijkstra.cpp

@@ -23,14 +23,13 @@
  * at the code below to understand in better way.
  *
  */
-#include <stdint.h>    // for int64_t
-#include <cassert>     // for assert
-#include <iostream>    // for basic_ostream, char_traits, operator<<, basic_...
-#include <limits>      // for numeric_limits
-#include <queue>       // for priority_queue
-#include <utility>     // for pair, make_pair
-#include <vector>      // for vector
-#include <functional>  // for greater
+#include <cassert>
+#include <iostream>
+#include <limits>
+#include <memory>
+#include <queue>
+#include <utility>
+#include <vector>
 
 constexpr int64_t INF = std::numeric_limits<int64_t>::max();
 

graph/hamiltons_cycle.cpp

@@ -15,10 +15,9 @@
  * @author [vakhokoto](https://github.com/vakhokoto)
  * @author [Krishna Vedala](https://github.com/kvedala)
  */
-#include <cassert>   // for assert
-#include <cstddef>   // for size_t
-#include <iostream>  // for operator<<, basic_ostream, cout
-#include <vector>    // for vector
+#include <cassert>
+#include <iostream>
+#include <vector>
 
 /**
  * The function determines if there is a hamilton's cycle in the graph