/*############################################################################## ## Author: Shaun Reed ## ## Legal: All Content (c) 2022 Shaun Reed, all rights reserved ## ## About: Driver program to test weighted graph implementation ## ## ## ## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ## ################################################################################ */ #include "lib-graph.hpp" int main (const int argc, const char * argv[]) { // We could initialize the graph with some localNodes... std::vector localNodes{ {1, {{2, 0}, {5, 0}}}, // Node 1 {2, {{1, 0}, {6, 0}}}, // Node 2 {3, {{4, 0}, {6, 0}, {7, 0}}}, {4, {{3, 0}, {7, 0}, {8, 0}}}, {5, {{1, 0}}}, {6, {{2, 0}, {3, 0}, {7, 0}}}, {7, {{3, 0}, {4, 0}, {6, 0}, {8, 0}}}, {8, {{4, 0}, {6, 0}}}, }; Graph bfsGraphInit(localNodes); std::cout << "\n\n##### Breadth First Search #####\n"; // Or we could use an initializer list... // Initialize a example graph for Breadth First Search Graph bfsGraph( { {1, {{2, 0}, {5, 0}}}, // Node 1 {2, {{1, 0}, {6, 0}}}, // Node 2... {3, {{4, 0}, {6, 0}, {7, 0}}}, {4, {{3, 0}, {7, 0}, {8, 0}}}, {5, {{1, 0}}}, {6, {{2, 0}, {3, 0}, {7, 0}}}, {7, {{3, 0}, {4, 0}, {6, 0}, {8, 0}}}, {8, {{4, 0}, {6, 0}}}, } ); // The graph traversed in this example is seen in MIT Intro to Algorithms // + Chapter 22, Figure 22.3 on BFS bfsGraph.BFS(bfsGraph.GetNodeCopy(2)); std::cout << "\nTesting finding a path between two nodes using BFS...\n"; // Test finding a path between two nodes using BFS auto path = bfsGraph.PathBFS( bfsGraph.GetNodeCopy(1), bfsGraph.GetNodeCopy(7) ); // If we were returned an empty path, it doesn't exist if (path.empty()) std::cout << "No valid path found!\n"; else { // If we were returned a path, print it std::cout << "\nValid path from " << path.front().number << " to " << path.back().number << ": "; for (const auto &node : path) { std::cout << node.number << " "; } std::cout << std::endl; } std::cout << "\n\n##### Depth First Search #####\n"; // Initialize an example graph for Depth First Search Graph dfsGraph( { {1, {{2, 0}, {4, 0}}}, {2, {{5, 0}}}, {3, {{5, 0}, {6, 0}}}, {4, {{2, 0}}}, {5, {{4, 0}}}, {6, {{6, 0}}}, } ); // The graph traversed in this example is seen in MIT Intro to Algorithms // + Chapter 22, Figure 22.4 on DFS dfsGraph.DFS(); std::cout << "\n\n##### Topological Sort #####\n"; // Initialize an example graph for Depth First Search // + The order of initialization is important // + To produce the same result as seen in the book // ++ If the order is changed, other valid topological orders will be found // The book starts on the 'shirt' node (with the number 6, in this example) Graph topologicalGraph ( { {1, {{4, 0}, {5, 0}}}, // undershorts {2, {{5, 0}}}, // socks {3, {}}, // watch {4, {{5, 0}, {7, 0}}}, // pants {5, {}}, // shoes {6, {{8, 0}, {7, 0}}}, // shirt {7, {{9, 0}}}, // belt {8, {{9, 0}}}, // tie {9, {}}, // jacket } ); // The graph traversed in this example is seen in MIT Intro to Algorithms // + Chapter 22, Figure 22.4 on DFS // Unlike the simple-graph example, this final result matches MIT Algorithms // + Aside from the placement of the watch node, which is not connected // + This is because the node is visited after all other nodes are finished std::vector order = topologicalGraph.TopologicalSort(topologicalGraph.GetNodeCopy(6)); std::cout << "\nTopological order: "; while (!order.empty()) { std::cout << order.back().number << " "; order.pop_back(); } std::cout << std::endl << std::endl; // If we want the topological order to match what is seen in the book // + We have to initialize the graph carefully to get this result - Graph topologicalGraph2 ( { {6, {{8, 0}, {7, 0}}}, // shirt {8, {{9, 0}}}, // tie {7, {{9, 0}}}, // belt {9, {}}, // jacket {3, {}}, // watch {1, {{4, 0}, {5, 0}}}, // undershorts {4, {{5, 0}, {7, 0}}}, // pants {5, {}}, // shoes {2, {{5, 0}}}, // socks } ); auto order2 = topologicalGraph2.TopologicalSort(*topologicalGraph2.NodeBegin()); std::cout << "\nTopological order: "; while (!order2.empty()) { std::cout << order2.back().number << " "; order2.pop_back(); } std::cout << std::endl; std::cout << "\n\n##### Minimum Spanning Trees #####\n"; // This example graph is seen in MIT Algorithms chapter 23, figure 23.4 // + The result we produce is the same in total weight // + Differs only in the connection of nodes (2->3) *instead of* (8->1) // ++ Both of these edges have the same weight, and we do not create a cycle Graph graphMST( { {1, {{2, 4}}}, {2, {{3, 8}}}, {3, {{4, 7}}}, {4, {{5, 9}}}, {5, {{6, 10}}}, {6, {{3, 4}, {4, 14}, {7, 2}}}, {7, {{8, 1}}}, {8, {{1, 8}, {2, 11}, {9, 7}}}, {9, {{3, 2}, {7, 6}}} } ); InfoMST resultMST = graphMST.KruskalMST(); std::cout << "Finding MST using Kruskal's...\n\nMST result: \n"; for (const auto &edge : resultMST.edgesMST) { std::cout << "Connected nodes: " << edge.second.first << "->" << edge.second.second << " with weight of " << edge.first << "\n"; } std::cout << "Total MST weight: " << resultMST.weightMST << std::endl; }