Поиск максимальной компоненты связности для каждой вершины неориентированного графа

[Misha2513]

Добрый день.Мне нужно найти для каждой вершины максимальную компоненту связности, которая образовалась бы при удалении этой вершины.Мой код. Как мне это сделать, например в функции bfs?

#include <iostream>
#include <fstream>
#include <queue>
using namespace std;
const int MAXV = 50;
bool processed[MAXV + 1];
bool discovered[MAXV + 1];
int parent[MAXV + 1];
int comp[MAXV + 1];
struct list
{
    int y;
    list *next;
};
struct graph
{
    list *edges[MAXV + 1];
    int degree[MAXV + 1];
    int nvertices;
    int nedges;
    bool directed;
};
void insert_edge(graph *g, int x, int y, bool directed)
{
    list *p = new list;
    p->y = y;
    p->next = g->edges[x];
    g->edges[x] = p;
    g->degree[x] ++;
    if (directed == false)
        insert_edge(g, y, x, true);
    else
        g->nedges++;
 
}
void initilaize_graph(graph *g, bool directed)
{
    int i;
    g->nvertices = 0;
    g->nedges = 0;
    g->directed = directed;
    for (i = 1; i <= MAXV; i++)
    {
        g->edges[i] = NULL;
        comp[i]=g->degree[i] = 0;
 
    }
}
void read_graph(graph *g, bool directed, ifstream &f)
{
    int i, m, x, y;
    initilaize_graph(g, directed);
    f >> g->nvertices;
    m = g->nvertices;
    for (i = 1; i < m; i++)
    {
        f >> x >> y;
        insert_edge(g, x, y, directed);
    }
}
void print_graph(graph *g)
{
    int i;
    list *p;
    for (i = 1; i <= g->nvertices; i++)
    {
        printf("%d: ", i);
        p = g->edges[i];
        while (p != NULL)
        {
            printf(" %d", p->y);
            p = p->next;
        }
        printf("\n");
    }
}
void initiliaze_search(graph *g) 
{
    for (int i = 1; i <= g->nvertices; i++) 
    {
        processed[i] = discovered[i] = false;
        parent[i] = -1;
    }
}
void bfs(graph *g,int start) 
{
    queue <int> q;
    int v, y, max = 0;
    list* p;
    q.push(start);
    discovered[start] = true;
    while (!q.empty()) 
    {
        v = q.front(); q.pop(); max++;
        processed[v] = true;
        p = g->edges[v];
        while (p != NULL) 
        {
            y = p->y;
            if (discovered[y] == false) 
            {
                q.push(y);
                discovered[y] = true;
                parent[y] = v;
            }
            else 
            {
                max--;
            }
            p = p->next;
        }
    }
    if (max > comp[start]) comp[start] = max;
    for (int i = 1; i <= g->nvertices; i++)
        if (discovered[i]==false) bfs(g, i);
    
}
void connected_components(graph *g) 
{
    for (int i = 1; i <= g->nvertices; i++) 
    {
        initiliaze_search(g);
        bfs(g, i);
        
    }
    int min = comp[1];
    for (int i = 2; i <= g->nvertices; i++)
    {
        if (min > comp[i]) min = comp[i];
    }
    for (int z = 1; z <= g->nvertices; z++)
    {
        if (comp[z] == min) cout << z << " " << comp[z]  <<  " ";
        if (comp[z] == 0) continue;
    }
}
int main()
{
    ifstream f("jok.txt");                  // на вход  
                                            // 6
                                            //1 2
                                            //2 3
                                            //2 5
                                            //3 4
                                            //3 6
    if (f) {
        graph *g = new graph;
        read_graph(g, false, f);
        print_graph(g);
        connected_components(g);
    }
    else cout << "Error";
    
    return 0;
 
}