Написать программу, описывающую класс "граф"

#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
 
using namespace std;
 
class Graph {
private:
    vector<vector<int>> adjList;
 
public:
    void readGraphFromFile(const string& filename) {
        ifstream file(filename);
        if (!file.is_open()) {
            cout << "Error opening file." << endl;
            return;
        }
 
        int value;
        while (file >> value) {
            if (adjList.empty()) {
                adjList.push_back(vector<int>{value});
            } 
            else {
                adjList.back().push_back(value);
            }
        }
 
        file.close();
    }
 
    void printAdjList() {
        int n = adjList.size();
            for (int i = 0; i < n; ++i) {
            cout << "Vertex " << i << " is adjacent to: ";
            for (int j = 0; j < n; ++j) {
                if (adjList[i][j] == 1) {
                    cout << j << " ";
                //cout << adjList[i][j] << " ";
                }
            }
            cout << endl;
        }
    }
    
    void BFS(int start) {
        
        vector<bool> visited(adjList.size(), false);
        queue<int> q;
        vector<int> visitedNodes;
 
        q.push(start);
        visited[start] = true;
 
         while (!q.empty()) {
            int current = q.front();
            q.pop();
           
            if (!visited[current]) {
                visitedNodes.push_back(current);
                visited[current] = true;
            //visitedNodes.push_back(current);
 
                for (int i : adjList[current]) {
                    if (!visited[i]) {
                         q.push(i);
                        visited[i] = true;
                    }
                }
            }
         }
    }
    cout << "Visited nodes: ";
    for (int node : visitedNodes) {
        cout << node << " ";
    }
    cout << endl;
    
};
 
int main() {
    Graph graph;
    graph.readGraphFromFile("graph.txt");
    graph.printAdjList();
    cout << "BFS traversal starting from vertex 0: ";
    graph.BFS(0);
 
    return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
int GetAdjMatrixSize(std::string filename){
    std::ifstream fin(filename);
    std::string line;
    if (getline(fin, line) && !line.empty()){
        std::istringstream iss(line);
        int size = 0, e;
        while( iss >> e && ++size)
            ;
        return size;
    }
    return 0;
}
 
void PrintAsAdjList(std::string filename, int n){
    std::ifstream fin(filename);
    for(int v = 0, e = 0; v != n; ++v){
        std::cout << (v + 1) << " : ";
        for(int w = 0; w != n; ++w){
            fin >> e;
            if (e)
                std::cout << (w + 1) << ' ';
        }
        std::cout << std::endl;
    }
}
int main(){
    int n = 0;
    if (n = GetAdjMatrixSize("input.txt")){
        PrintAsAdjList("input.txt", n);
    }else{
        std::cout << "Somthing wrong";
    }
 
}

#include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <optional>
#include <queue>
#include <vector>
#include <valarray>
 
template<typename Vertex = int, typename Weight = double>
class WeightedAdjacencyList {
public:
    WeightedAdjacencyList() : data() {}
 
    void setEdge(const Vertex &from, const Vertex &to, const Weight weight) {
        data[from][to] = weight;
        data.insert({to, {}});
    }
 
    const Weight &getEdge(const Vertex &from, const Vertex &to) const {
        return data[from][to];
    }
 
    bool removeEdge(const Vertex &from, const Vertex &to) {
        if (!data.contains(from)) {
            return false;
        }
        return data.at(from).erase(to) != 0;
    }
 
    bool hasEdge(const Vertex &from, const Vertex &to) const {
        return data.contains(from) && data.at(from).contains(to);
    }
 
    bool addVertex(const Vertex &vertex) {
        return data.insert(vertex, {});
    }
 
    void removeVertex(const Vertex &vertex) {
        for (auto &v : data) {
            v.second.erase(vertex);
        }
        if (data.contains(vertex)) {
            data.erase(vertex);
        }
    }
 
    std::optional<Weight> operator()(const Vertex &from, const Vertex &to) const {
        if (data.contains(from) && data.at(from).contains(to)) {
            return data.at(from).at(to);
        }
        return {};
    }
 
    const std::unordered_map<Vertex, Weight> &getNeighbours(const Vertex &vertex) const {
        return data.at(vertex);
    }
 
private:
    std::unordered_map<Vertex, std::unordered_map<Vertex, Weight>> data;
};
 
template<typename T>
std::ostream &operator<<(std::ostream &out, const std::optional<T> &optional) {
    if (optional.has_value()) {
        out << "{" << optional.value() << "}";
    } else {
        out << "{NONE}";
    }
    return out;
}
 
template<typename Vertex, typename Weight, typename Callback>
void bfs(const WeightedAdjacencyList<Vertex, Weight> &graph, Vertex start, Callback visit) {
    std::unordered_set<Vertex> visited;
    std::queue<Vertex> queue;
 
    visited.insert(start);
    queue.push(start);
    while (!queue.empty()) {
        Vertex current = queue.front();
        queue.pop();
 
        visit(current);
        for (const auto &v : graph.getNeighbours(current)) {
            if (!visited.contains(v.first)) {
                visited.insert(v.first);
                queue.push(v.first);
            }
        }
    }
}
 
template<typename Vertex, typename Weight>
std::istream &operator>>(std::istream &in, WeightedAdjacencyList<Vertex, Weight> &graph) {
    std::vector<Weight> matrix;
    for (Weight i; in >> i;) {
        matrix.push_back(i);
    }
    size_t vertexCount = std::sqrt(matrix.size()); // ближайший кореньи будет количество вершин
    for (size_t i = 0; i < vertexCount; ++i) {
        for (size_t j = 0; j < vertexCount; ++j) {
            size_t vertexId = i * vertexCount + j;
            if (matrix[vertexId] != 0) {
                graph.setEdge(i, j, matrix[vertexId]);
            }
        }
    }
    return in;
}
 
int main() {
    WeightedAdjacencyList<> a;
 
    std::cin >> a;
 
    bfs(a, 0, [](auto v) { std::cout << v << " ";});
 
    return 0;
}