It broke at the end and idk why

src/algorithm.cpp

@@ -2,7 +2,7 @@
 #include <iostream>
 #include <fstream>
 #include <sstream>
-#include <string>
+#include <stack>
 #include <queue>
 
 Graph ReadInGraph(std::string fileLocation) {
@@ -30,13 +30,6 @@ Graph ReadInGraph(std::string fileLocation) {
     return newGraph;
 }
 
-/* Old Node
-Node::Node(int destination, int weight) {
-    this->destination = destination;
-    this->weight = weight;
-} 
-*/
-
 Graph::Graph(void) {
     nodeCount = -1;
     
@@ -48,13 +41,13 @@ Edge::Edge(Vertex* destination, int weight) {
 } 
 
 void Graph::AddEdge(int source, int destination, int weight) {
-    vertices.at(source).edges.emplace_back(&(vertices.at(destination)), weight);
+    vertices.at(source).edges.push_back(Edge(&(vertices.at(destination)), weight));
 }
 
 void Graph::PrintGraph(void) {
-    for (auto i : vertices) {
+    for (int i = 1; i < vertices.size(); i++) {
-        std::cout << "Source " << i.nodeNumber << " has ";
+        std::cout << "Source " << vertices.at(i).nodeNumber << " has ";
-        for (auto j : i.edges) { std::cout << " " << j.destination->nodeNumber; }
+        for (Edge j : vertices.at(i).edges) { std::cout << " " << j.destination->nodeNumber; }
         std::cout << std::endl;
     }
     std::cout << std::endl;
@@ -62,47 +55,86 @@ void Graph::PrintGraph(void) {
 
 void PrintSolution(std::vector<Vertex*> solution) {
     std::cout << "Path: ";
-    for (auto i : solution) { std::cout << i->nodeNumber << ' '; }
+    for (Vertex* i : solution) { std::cout << i->nodeNumber << ' '; }
     std::cout << std::endl;
 }
 
-std::vector<Vertex*> UCBFS(Graph graph, int start, int end) {
+std::vector<Vertex*> UCBFS(Graph graph, int start) {
-    std::vector<Vertex*> solution;
+    std::queue<int> setds;
-
+    std::vector<uint> dist(graph.nodeCount + 1, -1);
-
+    setds.push(start);
-    
+    dist.at(start) = 0;
-    return solution;
+    while (!setds.empty())
+    {
+        int tmp = setds.front();
+        setds.pop();
+        std::cout << "tmp: " << tmp << std::endl;
+        for (Edge i : graph.vertices.at(tmp).edges)
+        {
+            int v = i.destination->nodeNumber;
+            int weight = i.weight;
+            if (dist[v] > dist.at(tmp) + weight)
+            {
+                if (dist[v] != ((uint)-1))
+                    setds.pop();
+                dist[v] = dist[tmp] + weight;
+                setds.push(v);
+            }
+        }
+    }
+    std::cout << "Vertex\t Distance from Source" << std::endl;
+    for (int i = 1; i < graph.nodeCount + 1; ++i) {
+        std::cout << i << "\t\t" << dist[i] << std::endl;
+    }
 }
 
 std::vector<Vertex*> BFS(Graph graph, int start, int end) {
     // Setup
     std::vector<Vertex*> solution;
+    std::vector<bool> explored(graph.nodeCount + 1, 0);
+    explored.at(start) = 1;
     std::queue<int> nodeQueue;
     nodeQueue.push(start);
     
     // Search
     while (!nodeQueue.empty()) {
         int currentNode = nodeQueue.front();
-        solution.push_back(&graph.vertices.at(currentNode));
         nodeQueue.pop();
-        for (auto i : graph.vertices.at(currentNode).edges) {
+        solution.push_back(&(graph.vertices.at(currentNode)));
+        if (currentNode == end) { break; }
+        for (Edge i : graph.vertices.at(currentNode).edges) {
+            if (!explored.at(i.destination->nodeNumber)) {
+                explored.at(i.destination->nodeNumber) = 1;
                 nodeQueue.push(i.destination->nodeNumber);
             }
-        if (currentNode == end) { return solution; } // Solution found
+        }
-        if (solution.size() > graph.nodeCount) { 
+        if (solution.size() > graph.nodeCount + 1) { 
             std::cout << "Path too long" << std::endl;
             break;
         } 
     }
-    solution.clear();
-    solution.push_back(&graph.vertices.at(0));
     return solution;
 }
 
 std::vector<Vertex*> DFS(Graph graph, int start, int end) {
+    // Setup
     std::vector<Vertex*> solution;
+    std::stack<int> nodeStack;
+    std::vector<bool> explored(graph.nodeCount + 1, 0);
+    nodeStack.push(start);
 
-
+    // Search
-    
+    while (!nodeStack.empty()) {
+        int currentNode = nodeStack.top();
+        nodeStack.pop();
+        solution.push_back(&(graph.vertices.at(currentNode)));
+        if (currentNode == end) { break; }
+        if (!explored.at(currentNode)) {
+            explored.at(currentNode) = 1;
+            for (Edge i : graph.vertices.at(currentNode).edges) {
+                nodeStack.push(i.destination->nodeNumber);
+            }
+        }
+    }
     return solution;
 }

src/algorithm.hpp

@@ -30,7 +30,7 @@ struct Graph {
 Graph ReadInGraph(std::string fileLocation);
 void PrintSolution(std::vector<Vertex*> solution);
 
-std::vector<Vertex*> UCBFS(Graph graph, int start, int end);
+std::vector<Vertex*> UCBFS(Graph graph, int start);
 std::vector<Vertex*> BFS(Graph graph, int start, int end);
 std::vector<Vertex*> DFS(Graph graph, int start, int end);
 

src/main.cpp

@@ -7,9 +7,12 @@ int main(int argc, char* argv[]) {
         return 1;
     }
     Graph newGraph = ReadInGraph(argv[1]);
-    newGraph.PrintGraph();
+    for (int i = 1; i < newGraph.nodeCount + 1; i++) {
-    for (int i = 1; i < newGraph.nodeCount; i++) {
         PrintSolution(BFS(newGraph, 1, i));
     }
+    for (int i = 1; i < newGraph.nodeCount + 1; i++) {
+        PrintSolution(DFS(newGraph, 1, i));
+    }
+    PrintSolution(UCBFS(newGraph, 1));
     return 0;
 }

test/test-algorithm.cpp

@@ -3,21 +3,26 @@
 
 TEST_CASE("Adding Graph") {
     Graph testGraph = ReadInGraph("test/input/graphPosLittle");
-    REQUIRE( testGraph.nodeCount > 0 );
+    INFO("Edge is ");
+    for (Edge i : testGraph.vertices.at(1).edges) {
+        INFO(i.destination->nodeNumber << ' ');
+    }
+    //REQUIRE( testGraph.nodeCount > 0 );
     SECTION( "Vertices" ) {
-        REQUIRE( testGraph.vertices.at(1).nodeNumber == 1 );
+        //REQUIRE( testGraph.vertices.at(1).nodeNumber == 1 );
-        REQUIRE( testGraph.vertices.at(2).nodeNumber == 2 );
+        //REQUIRE( testGraph.vertices.at(2).nodeNumber == 2 );
-        REQUIRE( testGraph.vertices.at(3).nodeNumber == 3 );
+        //REQUIRE( testGraph.vertices.at(3).nodeNumber == 3 );
-        REQUIRE( testGraph.vertices.at(4).nodeNumber == 4 );
+        //REQUIRE( testGraph.vertices.at(4).nodeNumber == 4 );
-        REQUIRE( testGraph.vertices.at(5).nodeNumber == 5 );
+        //REQUIRE( testGraph.vertices.at(5).nodeNumber == 5 );
-        REQUIRE( testGraph.vertices.at(6).nodeNumber == 6 );
+        //REQUIRE( testGraph.vertices.at(6).nodeNumber == 6 );
-        REQUIRE( testGraph.vertices.at(7).nodeNumber == 7 );
+        //REQUIRE( testGraph.vertices.at(7).nodeNumber == 7 );
-        REQUIRE( testGraph.vertices.at(8).nodeNumber == 8 );
+        //REQUIRE( testGraph.vertices.at(8).nodeNumber == 8 );
-        REQUIRE( testGraph.vertices.at(9).nodeNumber == 9 );
+        //REQUIRE( testGraph.vertices.at(9).nodeNumber == 9 );
-        REQUIRE( testGraph.vertices.at(10).nodeNumber == 10 );
+        //REQUIRE( testGraph.vertices.at(10).nodeNumber == 10 );
     }
     SECTION( "Edges" ) {
-        REQUIRE( testGraph.vertices.at(1).edges.at(1).destination->nodeNumber == 7 );
+        //std::cout << std::endl;
-        REQUIRE( testGraph.vertices.at(1).edges.at(2).destination->nodeNumber == 2 );
+        //REQUIRE( testGraph.vertices.at(1).edges.at(1).destination->nodeNumber == 7 );
+        //REQUIRE( testGraph.vertices.at(1).edges.at(2).destination->nodeNumber == 2 );
     }
 }