Разработать порядок закрытия станций при котором метро всегда будет оставаться связным

#include<iostream>
using namespace std;
int a,b,u,v,n,i,j,ne=1;
int w[10],M,c[10][1001];
main()
{
int p[101];
int p_index=0;
cin>>n;
for(i=1;i<=n;i++)
for(j=0;j<=n;j++)
{
cin>>c[i][j];
if(c[i][j]==0)
c[i][j]=500000;
}
w[1]=1;
while(ne < n)
{
int M=500000;
for(i=1;i<=n;i++)
for(j=0;j<=n;j++)
if(c[i][j]< M)
if(w[i]!=0)
{
M=c[i][j];
a=u=i;
b=v=j;
}
if(w[u]==0 || w[v]==0)
{
p[p_index]=b;
p_index++;
ne++;
w[b]=1;
}
c[a][b]=c[b][a]=500000;
}
cout<<1<<" ";
for (int i=0;i<n-1;i++)
{
cout<<p[i];
if (i<n-2) cout<<" ";
}
}

///////////////////////////////////////////////////////////////////////////////
//3.
///////////////////////////////////////////////////////////////////////////////
//В некотором городе есть метро, состоящее из N (1 ≤ N ≤ 1000) станций
//и M (0 ≤ M ≤ 500 000) линий, соединяющих их. Каждая линия обеспечивает
//проезд между какими-то двумя станциями в обе стороны. Между любой парой
//станций проведено не более одной линии. Сеть метро построена таким образом,
//чтобы с каждой станции можно было проехать на каждую (возможно, через
//промежуточные станции). Назовем это свойство связностью метро.
//В связи с изобретением принципиально нового вида транспорта метро стало
//убыточным, и его работу решили прекратить. На заседании мэрии города было
//постановлено закрывать каждый год по одной станции, но так, чтобы связность
//метро каждый раз сохранялась. При закрытии какой-либо станции линии,
//ведущие от этой станции к другим, естественно, тоже перестают функционировать.
//По введенной информации о сети метро разработать какой-либо порядок
//закрытия станций, при котором метро всегда будет оставаться связным.
//Например, пусть метро выглядит так, как показано в примере ввода. Тогда
//станции можно закрывать, например, в порядке 1,2,4,3,5. А порядок 3,1,2,4,5 –
//не подходит, так как после закрытия 3-й станции метро распадется на четыре
//не связных части.
//Первая строка входного файла будет содержать числа N и M. В следующих M
//строках находится информация о линиях. Каждая из этих строк содержит
//через пробел числа Ai и Bi – две станции, которые соединяет i-я линия.
//Выходной файл должен состоять из N строк. Каждая строка должна содержать
//одно число – номер станции. Вывести станции нужно в порядке их закрытия.
//Пример ввода
//5 4
//3 1
//3 2
//3 4
//3 5
//Пример вывода
//1
//2
//4
//3
//5
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <list>
#include <map>
#include <set>
///////////////////////////////////////////////////////////////////////////////
typedef int                                             T_station;
typedef int                                             T_ind;
typedef std::multimap   < T_station,    T_station   >   T_lines_block;
typedef std::list       < T_lines_block     >           T_lines_blocks;
typedef std::set        < T_station         >           T_stations;
///////////////////////////////////////////////////////////////////////////////
template < typename     TT_cont >
TT_cont     &   operator+=
    (
        TT_cont             &   L,
        TT_cont     const   &   R
    )
{
    L.insert
        (
            R.begin     (),
            R.end       ()
        );
 
    return  L;
}
///////////////////////////////////////////////////////////////////////////////
class   T_blocks
{
    //-------------------------------------------------------------------------
    T_stations      existing_stations_;
    T_lines_blocks  lines_blocks_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_blocks( int   N_stations_total )
    {
        for( T_station  i{1}; i <= N_stations_total; ++i )
        {
            existing_stations_.insert( i );
        }
    }
    //-------------------------------------------------------------------------
    void    check_line
        (
            T_station     L_station,
            T_station     R_station
        )
    {
        T_lines_block   new_block   {
                                        { L_station,    R_station },
                                        { R_station,    L_station },
                                    };
 
        auto    L_it    =   find_block_it_of_station( L_station );
        auto    R_it    =   find_block_it_of_station( R_station );
 
        if  (
                    L_it   ==  lines_blocks_.end()
                &&  R_it   ==  lines_blocks_.end()
            )
        {
            lines_blocks_.emplace_back( new_block );
        }
        else if (
                        L_it   !=  lines_blocks_.end()
                    &&  R_it   !=  lines_blocks_.end()
                )
        {
            if  (
                        L_it
                    !=  R_it
                )
            {
                *L_it   +=  *R_it
                        +=  new_block;
 
                lines_blocks_.erase( R_it );
            }//if
        }
        else
        {
                L_it   ==  lines_blocks_.end()
                    ?   *R_it
                    :   *L_it
 
            +=  new_block;
        }
    }
    //-------------------------------------------------------------------------
    void    output_deleted_stations_list()
    {
        auto    &    block  =   lines_blocks_.front();
 
        while   (
                    !block.empty()
                )
        {
            auto    leaf_it  =   std::find_if
                                        (
                                            existing_stations_.begin    (),
                                            existing_stations_.end      (),
 
                                            [&]                         ( auto  station )
                                            {
                                                return      block.count( station )
                                                        ==  1;
                                            }
                                        );
 
            auto    it_1        =   block.find( *leaf_it );
            auto    L_station   =   it_1->first;
            auto    R_station   =   it_1->second;
 
            auto    it_2    =   std::find_if
                                    (
                                        block.lower_bound   ( R_station ),
                                        block.end           (),
 
                                        [&]                 ( auto  const   &   line )
                                        {
                                            return      line.first      ==  R_station
                                                    &&  line.second     ==  L_station;
                                        }
                                    );
 
            std::cout   <<  L_station
                        <<  std::endl;
 
            existing_stations_  .erase( L_station );
            block               .erase( it_1 );
            block               .erase( it_2 );
 
            if  (
                    block.empty()
                )
            {
                std::cout   <<  R_station
                            <<  std::endl;
            }
        }//while
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    T_lines_blocks::iterator    find_block_it_of_station( T_station    station )
    {
        return  std::find_if
                    (
                        lines_blocks_.begin     (),
                        lines_blocks_.end       (),
 
                        [=]                     ( auto  const   &   block )
                        {
                            return  block.count( station );
                        }
                    );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::ios::sync_with_stdio   ( false );
    int     N_stations_total    {};
    int     M_lines_total       {};
 
    std::cin    >>  N_stations_total
                >>  M_lines_total;
 
    T_blocks    blocks( N_stations_total );
 
    for( T_ind  i{}; i < M_lines_total; ++i )
    {
        T_station     L_station{};
        T_station     R_station{};
 
        std::cin    >>  L_station
                    >>  R_station;
 
        blocks.check_line
            (
                L_station,
                R_station
            );
    }//for
 
    blocks.output_deleted_stations_list();
}