main.cpp

#include "Graph.hpp"
#include <string>

int main() {
    // Create a graph using the example from Graph.hpp comments:
    //
    // [a]-----------[c]
    // |  \            \
    // |   \            \
    // [b]  [d]----[g]---[h]
    // |          /  \
    // |         /    \
    // |        /      \
    // |     [f]--------[i]
    // |    /   \       /
    // |   /     \     /
    // |  /       \   /
    // [e]         [j]

    Graph<char> g;

    // Add all vertices
    g.addVertex('a');
    g.addVertex('b');
    g.addVertex('c');
    g.addVertex('d');
    g.addVertex('e');
    g.addVertex('f');
    g.addVertex('g');
    g.addVertex('h');
    g.addVertex('i');
    g.addVertex('j');

    // Add edges (bidirectional, so add both directions)
    // a -- b
    g.addEdge('a', 'b');
    g.addEdge('b', 'a');
    // a -- c
    g.addEdge('a', 'c');
    g.addEdge('c', 'a');
    // a -- d
    g.addEdge('a', 'd');
    g.addEdge('d', 'a');
    // b -- e
    g.addEdge('b', 'e');
    g.addEdge('e', 'b');
    // c -- h
    g.addEdge('c', 'h');
    g.addEdge('h', 'c');
    // d -- g
    g.addEdge('d', 'g');
    g.addEdge('g', 'd');
    // e -- f
    g.addEdge('e', 'f');
    g.addEdge('f', 'e');
    // f -- g
    g.addEdge('f', 'g');
    g.addEdge('g', 'f');
    // f -- i
    g.addEdge('f', 'i');
    g.addEdge('i', 'f');
    // f -- j
    g.addEdge('f', 'j');
    g.addEdge('j', 'f');
    // g -- h
    g.addEdge('g', 'h');
    g.addEdge('h', 'g');
    // g -- i
    g.addEdge('g', 'i');
    g.addEdge('i', 'g');
    // i -- j
    g.addEdge('i', 'j');
    g.addEdge('j', 'i');

    // Display the graph
    cout << "=== Graph Structure ===" << endl;
    cout << g << endl;

    // Test path finding
    cout << "=== Path Finding ===" << endl;
    
    // Find path from 'a' to 'f'
    std::deque<char> path1;
    g.getPath(path1, 'a', 'f');
    cout << "Path from 'a' to 'f': ";
    for (size_t i = 0; i < path1.size(); i++) {
        if (i > 0) cout << " -> ";
        cout << path1[i];
    }
    cout << endl;

    // Find path from 'a' to 'j'
    std::deque<char> path2;
    g.getPath(path2, 'a', 'j');
    cout << "Path from 'a' to 'j': ";
    for (size_t i = 0; i < path2.size(); i++) {
        if (i > 0) cout << " -> ";
        cout << path2[i];
    }
    cout << endl;

    // Find path from 'c' to 'e'
    std::deque<char> path3;
    g.getPath(path3, 'c', 'e');
    cout << "Path from 'c' to 'e': ";
    for (size_t i = 0; i < path3.size(); i++) {
        if (i > 0) cout << " -> ";
        cout << path3[i];
    }
    cout << endl;

    // Demonstrate with a different type (string)
    cout << "\n=== String Graph Example ===" << endl;
    Graph<std::string> cityGraph(10);

    cityGraph.addVertex("New York");
    cityGraph.addVertex("Los Angeles");
    cityGraph.addVertex("Chicago");
    cityGraph.addVertex("Houston");
    cityGraph.addVertex("Phoenix");

    // Add some routes
    cityGraph.addEdge("New York", "Chicago");
    cityGraph.addEdge("Chicago", "Houston");
    cityGraph.addEdge("Houston", "Phoenix");
    cityGraph.addEdge("Phoenix", "Los Angeles");
    cityGraph.addEdge("New York", "Los Angeles");

    cout << cityGraph << endl;

    // Find path between cities
    std::deque<std::string> cityPath;
    cityGraph.getPath(cityPath, "New York", "Los Angeles");
    cout << "Path from New York to Los Angeles: ";
    for (size_t i = 0; i < cityPath.size(); i++) {
        if (i > 0) cout << " -> ";
        cout << cityPath[i];
    }
    cout << endl;

    // Test utility functions
    cout << "\n=== Utility Functions ===" << endl;
    cout << "Number of vertices in char graph: " << g.getNumVertices() << endl;
    cout << "Number of vertices in city graph: " << cityGraph.getNumVertices() << endl;
    cout << "Does 'a' exist in char graph? " << (g.vertexExists('a') ? "Yes" : "No") << endl;
    cout << "Does 'z' exist in char graph? " << (g.vertexExists('z') ? "Yes" : "No") << endl;
    cout << "Does 'Chicago' exist in city graph? " << (cityGraph.vertexExists("Chicago") ? "Yes" : "No") << endl;

    return 0;
}