Проложить если возможно маршрут между противолежащими углами

///////////////////////////////////////////////////////////////////////////////
//Двумерный квадратный массив заполнен нулями и единицами.
//Проложить если возможно маршрут между противолежащими углами.
//Переход от клетки в клетку осуществим через общее ребро
//по клеткам с одинаковыми значениями.
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <iostream>
#include <list>
#include <random>
#include <set>
#include <utility>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
const   char    SPACE_SYMB  =   ' ';
///////////////////////////////////////////////////////////////////////////////
typedef int                                         T_val;
typedef std::vector     < T_val     >               T_row;
typedef std::vector     < T_row     >               T_matr;
typedef int                                         T_coord;
typedef std::pair       < T_coord,  T_coord     >   T_cell;
typedef std::vector     < T_cell    >               T_route;
typedef std::set        < T_cell    >               T_cells;
typedef std::list       < T_cells   >               T_waves;
///////////////////////////////////////////////////////////////////////////////
class   T_route_maker
{
    //-------------------------------------------------------------------------
    T_matr              board_;
    T_coord             rows_total_;
    T_coord             cols_total_;
 
    T_val               board_front_val_;
    T_val               board_back_val_;
 
    T_cell              board_front_cell_;
    T_cell              board_back_cell_;
 
    T_cells             good_cells_;
    T_route             route_;
    T_waves             waves_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    bool    successfully_calc_route( T_matr  const   &   board )
    {
        board_              =   board;
        rows_total_         =   board.size();
        cols_total_         =   board.front().size();
 
        board_front_val_    =   board_  [0][0];
 
        board_back_val_     =   board_  [ rows_total_ - 1 ]
                                        [ cols_total_ - 1 ];
 
        bool    bool_res    =       board_front_val_
                                ==  board_back_val_;
 
        if( bool_res )
        {
            board_front_cell_   =   {0, 0};
 
            board_back_cell_    =   {
                                        rows_total_     -   1,
                                        cols_total_     -   1
                                    };
 
            fill_good_cells();
 
            bool_res    =   successfully_fill_waves();
 
            if( bool_res )
            {
                make_route();
            }
        }//if
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    void    print_route()
    {
        std::cout   <<  std::endl;
 
        for( int i{}; i < rows_total_; ++i )
        {
            for( int j{}; j < cols_total_; ++j )
            {
                auto    it  =   std::find
                                    (
                                        route_.begin    (),
                                        route_.end      (),
                                        T_cell          { i, j }
                                    );
 
                if  (
                        it  ==  route_.end()
                    )
                {
                    std::cout   <<  SPACE_SYMB;
                }
                else if (
                            it  ==  route_.end() - 1
                        )
                {
                    std::cout   <<  '+';
                }
                else
                {
                    auto    it_next     =   it + 1;
 
                    std::cout   <<  (
                                            it      ->first
                                        ==  it_next ->first
 
                                            ?       it      ->second
                                                <   it_next ->second
                                                    ?   '>'
                                                    :   '<'
 
                                            :       it      ->first
                                                <   it_next ->first
                                                    ?   'V'
                                                    :   '^'
                                    );
                }//else
 
                std::cout   <<  SPACE_SYMB;
            }//for
 
            std::cout   <<  std::endl;
        }//for
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    void    fill_good_cells()
    {
        for( int  i{}; i < rows_total_; ++i )
        {
            for( int  j{}; j < cols_total_; ++j )
            {
                if  (
                            board_[i][j]
                        ==  board_front_val_
                    )
                {
                    good_cells_.insert
                        (
                            {i, j}
                        );
                }
            }//for
        }//for
    }
    //-------------------------------------------------------------------------
    bool    successfully_fill_waves()
    {
        waves_.emplace_back();
        waves_.back()   .insert     ( board_front_cell_ );
        good_cells_     .erase      ( board_front_cell_ );
 
        for(;;)
        {
            auto    &   cells_cur   =   waves_.back();
 
            if  (
                    cells_cur.count( board_back_cell_ )
                )
            {
                return  true;
            }
 
            waves_.emplace_back();
            auto    &   cells_next  =   waves_.back();
            T_cells     adj_cells;
 
            for( auto   cell    :   cells_cur )
            {
                auto    adj_cells_of_cell   =   get_adj_cells_of_cell( cell );
 
                adj_cells.insert
                    (
                        adj_cells_of_cell.begin     (),
                        adj_cells_of_cell.end       ()
                    );
            }//for
 
            if  (
                    adj_cells.empty()
                )
            {
                return  false;
            }
 
            move_cells_from_to
                (
                    adj_cells,
                    good_cells_,
                    cells_next
                );
        }//for w
    }
    //-------------------------------------------------------------------------
    T_cells     get_adj_cells_of_cell( T_cell   cell )
    {
        T_cells     res;
 
        T_coord     i{ cell.first   };
        T_coord     j{ cell.second  };
 
        if( j > 0 )
        {
            res.insert  (   { i,        j - 1 }   );
        }
 
        if( j < cols_total_ - 1 )
        {
            res.insert  (   { i,        j + 1 }   );
        }
 
        if( i > 0 )
        {
            res.insert  (   { i - 1,    j   }   );
        }
 
        if( i < rows_total_ - 1 )
        {
            res.insert  (   { i + 1,    j   }   );
        }
 
        return  res;
    }
    //-------------------------------------------------------------------------
    void    move_cells_from_to
        (
            T_cells     const   &   cells,
            T_cells             &   cells_from,
            T_cells             &   cells_to
        )
    {
        for( auto   cell    :   cells )
        {
            if  (
                    cells_from.count( cell )
                )
            {
                cells_from.erase    ( cell );
                cells_to.insert     ( cell );
            }//if
        }//for
    }
    //-------------------------------------------------------------------------
    void    make_route()
    {
        route_.push_back    ( board_back_cell_ );
        waves_.pop_back     ();
 
        while   (
                    !waves_.empty()
                )
        {
            auto    route_adj_cells     =   get_adj_cells_of_cell
                                                (
                                                    route_.back()
                                                );
 
            for( auto   adj_cell    :   route_adj_cells )
            {
                if  (
                        waves_.back().count( adj_cell )
                    )
                {
                    route_.push_back    ( adj_cell );
                    waves_.pop_back     ();
                    break;
                }
            }//for
        }//while
 
        std::reverse
            (
                route_.begin    (),
                route_.end      ()
            );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
void    rand_fill_board( T_matr     &   board )
{
    static  std::random_device      rd;
 
    static  std::mt19937            gen (
                                            rd()
                                        );
 
    std::discrete_distribution<>    dicr_distr  (   {60, 40}    );
 
    for( auto   &   row     :   board )
    {
        for( auto   &   cell    :   row )
        {
            cell    =   dicr_distr( gen );
        }
    }//for
}
///////////////////////////////////////////////////////////////////////////////
void    print_board( T_matr     const   &   board )
{
    std::cout   <<  std::endl;
 
    for( auto   const   &   row     :   board )
    {
        for( auto   cell    :   row )
        {
            std::cout   <<  cell
                        <<  SPACE_SYMB;
        }//for
 
        std::cout   <<  std::endl;
    }//for
}
///////////////////////////////////////////////////////////////////////////////
bool    printed_version_has_route()
{
    const   T_coord     ROWS_TOTAL  =   20;
    const   T_coord     COLS_TOTAL  =   20;
 
    T_matr  board   (
                        ROWS_TOTAL,
                        T_row( COLS_TOTAL )
                    );
 
    rand_fill_board     ( board );
    print_board         ( board );
 
    T_route_maker   route_maker;
 
    bool    bool_res    =   route_maker.successfully_calc_route( board );
 
    if( bool_res )
    {
        route_maker.print_route();
    }
    else
    {
        std::cout   <<  "Route not exist"
                    <<  std::endl;
    }//else
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        while   (
                    !printed_version_has_route()
                );
 
        system("pause");
    }//for
}