batarra_mondey_graph

#include <iostream>
#include <vector>
#include <queue>
#include <utility>
#include <algorithm>

class Graph {
private:
    int n;
    std::vector<std::vector<int>> G;
    std::vector<bool> color;
public:
    Graph(int n) {
        this->n = n;
        this->G.resize(n);
    }
    void addEdge(int u, int v) {
        G[u].push_back(v);
        G[v].push_back(u);
    }
    std::pair<int, int> most_distant(int u) {
        std::vector<int> dist(n, -1);
        std::queue<int> q;
        dist[u] = 0;
        q.push(u);
        while(!q.empty()) {
            int v = q.front();
            q.pop();
            for(const int &w : G[v]) {
                if(dist[w] == -1) {
                    dist[w] = dist[v] + 1;
                    q.push(w);
                }
            }
        }
        int vertex;
        int dist_val = -1;
        for(int v = 0; v < n; ++v) {
            if(dist[v] > dist_val) {
                dist_val = dist[v];
                vertex = v;
            }
        }
        return std::make_pair(dist_val, vertex);
    }
    void dfs(int u) {
        color[u] = true;
        for(const int &v : G[u]) {
            if(!color[v]) {
                dfs(v);
            }
        }
    }
    int count_components() {
        color.clear();
        color.resize(n, false);
        int count = 0;
        for(int u = 0; u < n; ++u) {
            if(!color[u]) {
                dfs(u);
                ++count;
            }
        }
        return count;
    }
};

int main(){

    std::string edges;
    std::getline(std::cin, edges);

    int pointer = 0;
    std::cout << edges << std::endl;

    auto get_next = [&]() {
        if(pointer >= edges.size()) {
            return '#';
        }
        return edges[pointer];
    };

    auto is_digit = [&]() {
        return get_next() >= '0' and get_next() <= '9';
    };

    auto get_int = [&]() {
        int res = 0;
        while(get_next() != '#' and is_digit() == false)
            ++pointer;
        while(is_digit()) {
            res = res * 10 + get_next() - '0';
            ++pointer;
        }
        return res;
    };

    std::vector<std::pair<int, int>> list_edges;
    int n = 0;

    while(pointer < edges.size()) {
        int u = get_int();
        int v = get_int();
        list_edges.push_back(std::make_pair(u, v));
        n = std::max(u + 1, n);
        n = std::max(v + 1, n);
    }

    Graph graph(n);

    for(const auto&[u, v] : list_edges) {
        graph.addEdge(u, v);
    }

    int max_dist = 0;

    for(int i = 0; i < n; ++i) {
        auto [dist, vertex] = graph.most_distant(i);
        max_dist = std::max(max_dist, dist);
    }

    std::cout << "Max dist: " << max_dist << std::endl;
    std::cout << "Number of compoenents: " << graph.count_components() << std::endl;

    return 0;
}