Расстановка игральных костей

/////////////////////////////////////////////////////////////////////////////////////////
//Программа играющая в игру «Расстановка игральных костей».
//
//Задана частичная двумерная сетка. В некоторых позициях сетки расставлены 
//игральные кости. Расставить кости в остальных позициях сетки, причём кости 
//могут касаться друг друга только одинаковыми гранями.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <set>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
const int  FIELD_DIM           = 5;
const int  DIE_VAL_MAX         = 6;
const int  POSITIONS_TOTAL     = 24;
const int  EMPTY_POSITION_IND  = -1;
/////////////////////////////////////////////////////////////////////////////////////////
enum  T_pos_ind
{
    VAL_IND,
    SIDE_LEFT_IND,
    SIDE_TOP_IND,
    SIDE_RIGHT_IND,
    SIDE_BOTTOM_IND,
    POS_INDEXES_TOTAL
};
/////////////////////////////////////////////////////////////////////////////////////////
int  positions[POSITIONS_TOTAL][POS_INDEXES_TOTAL] =
    {
        {1, 2, 4, 5, 3},
        {1, 3, 2, 4, 5},
        {1, 4, 5, 3, 2},
        {1, 5, 3, 2, 4},
 
        {2, 1, 3, 6, 4},
        {2, 3, 6, 4, 1},
        {2, 4, 1, 3, 6},
        {2, 6, 4, 1, 3},
 
        {3, 1, 5, 6, 2},
        {3, 2, 1, 5, 6},
        {3, 5, 6, 2, 1},
        {3, 6, 2, 1, 5},
 
        {4, 1, 2, 6, 5},
        {4, 2, 6, 5, 1},
        {4, 5, 1, 2, 6},
        {4, 6, 5, 1, 2},
 
        {5, 1, 4, 6, 3},
        {5, 3, 1, 4, 6},
        {5, 4, 6, 3, 1},
        {5, 6, 3, 1, 4},
 
        {6, 2, 3, 5, 4},
        {6, 3, 5, 4, 2},
        {6, 4, 2, 3, 5},
        {6, 5, 4, 2, 3}
    };
/////////////////////////////////////////////////////////////////////////////////////////
class  T_cell
{
    enum  T_cell_state
    {
        NOT_NET_CELL,
        NET_CELL_NOT_SPECIFIED,
        NET_CELL_SPECIFIED    
    };
    //-----------------------------------------------------------------------------------
    typedef std::deque<bool>  T_possible_positions;    
    typedef std::set<int>     T_side_values_set;    
    //-----------------------------------------------------------------------------------
    T_cell_state          state_;   
    T_possible_positions  possible_positions_functional_;
    T_possible_positions  possible_positions_cur_;
    int                   position_ind_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_cell()
    {   
        state_                          = NOT_NET_CELL;
        possible_positions_functional_  = T_possible_positions(POSITIONS_TOTAL, true);
        clear();        
    }
    //-----------------------------------------------------------------------------------
    void  set_net_cell_not_specified_state()
    {
        set_state(NET_CELL_NOT_SPECIFIED);
    }
    //-----------------------------------------------------------------------------------
    void  set_net_cell_specified_state()
    {
        set_state(NET_CELL_SPECIFIED);
    }    
    //-----------------------------------------------------------------------------------
    bool  set_side_left_functional_efficiently(int  side_left)
    {
        return  set_side_functional_efficiently(SIDE_LEFT_IND, side_left);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_top_functional_efficiently(int  side_top)
    {
        return  set_side_functional_efficiently(SIDE_TOP_IND, side_top);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_right_functional_efficiently(int  side_right)
    {
        return  set_side_functional_efficiently(SIDE_RIGHT_IND, side_right);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_bottom_functional_efficiently(int  side_bottom)
    {
        return  set_side_functional_efficiently(SIDE_BOTTOM_IND, side_bottom);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_left_cur(int  side_left)
    {
        return  set_side_cur(SIDE_LEFT_IND, side_left);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_top_cur(int  side_top)
    {
        return  set_side_cur(SIDE_TOP_IND, side_top);
    }
    //-----------------------------------------------------------------------------------
    bool  get_side_right_functional(int&  side_right) const
    {
        return  get_side_val_functional(SIDE_RIGHT_IND, side_right);
    }
    //-----------------------------------------------------------------------------------
    bool  get_side_left_functional(int&  side_left) const
    {
        return  get_side_val_functional(SIDE_LEFT_IND, side_left);
    }
    //-----------------------------------------------------------------------------------
    bool  get_side_bottom_functional(int&  side_bottom) const
    {
        return  get_side_val_functional(SIDE_BOTTOM_IND, side_bottom);
    }
    //-----------------------------------------------------------------------------------
    bool  get_side_top_functional(int&  side_top) const
    {
        return  get_side_val_functional(SIDE_TOP_IND, side_top);
    }
    //-----------------------------------------------------------------------------------
    int  get_side_right_cur() const
    {
        return  positions[position_ind_][SIDE_RIGHT_IND];
    }
    //-----------------------------------------------------------------------------------
    int  get_side_left_cur() const
    {
        return  positions[position_ind_][SIDE_LEFT_IND];
    }
    //-----------------------------------------------------------------------------------
    int  get_side_bottom_cur() const
    {
        return  positions[position_ind_][SIDE_BOTTOM_IND];
    }
    //-----------------------------------------------------------------------------------
    int  get_side_top_cur() const
    {
        return  positions[position_ind_][SIDE_TOP_IND];
    }
    //-----------------------------------------------------------------------------------
    bool  set_rand_pos()
    {
        bool  bool_res = get_positions_count_true_functional() != 0;
        
        if(bool_res)
        {
            int  position_ind_cur = 0;
            do
            {
                position_ind_cur = rand() % possible_positions_functional_.size();
            }while(!possible_positions_functional_[position_ind_cur]);
 
            possible_positions_functional_  = T_possible_positions(POSITIONS_TOTAL, false);
            possible_positions_functional_[position_ind_cur] = true;
            set_min_pos();
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  set_min_pos()
    {
        bool  bool_res = get_positions_count_true_functional() != 0;
 
        if(bool_res)
        {
            clear();
            do
            {
                ++position_ind_;                
            }while(!possible_positions_cur_[position_ind_]);
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  empty() const 
    {
        return  position_ind_ == EMPTY_POSITION_IND;
    }
    //-----------------------------------------------------------------------------------
    int  get_val() const
    {
        return  positions[position_ind_][VAL_IND];
    }
    //-----------------------------------------------------------------------------------
    bool  is_not_net_cell() const
    {
 
        return  state_ == NOT_NET_CELL;
    }
    //-----------------------------------------------------------------------------------
    bool  is_net_cell_not_specified() const
    {
        return  state_ == NET_CELL_NOT_SPECIFIED;
    }
    //-----------------------------------------------------------------------------------
    bool  inc_pos_or_clear()
    {
        do
        {
            ++position_ind_;
        }while(   position_ind_ < int( possible_positions_cur_.size() )
               && !possible_positions_cur_[position_ind_] );
 
        bool  bool_res =    position_ind_ < int( possible_positions_cur_.size() )
                         && possible_positions_cur_[position_ind_];
 
        if(!bool_res)
        {
            clear();
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    int  get_positions_count_true_functional() const
    {
        return  std::count( possible_positions_functional_.begin(), 
                            possible_positions_functional_.end(), true );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  set_state(T_cell_state  state)
    {
        state_ = state;
    }
    //-----------------------------------------------------------------------------------
    void  clear()
    {       
        possible_positions_cur_  = possible_positions_functional_;
        position_ind_            = EMPTY_POSITION_IND;
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_functional_efficiently
        (
            T_pos_ind  side_ind,
            int        side_val
        )
    {
        T_possible_positions  possible_positions_functional_old( possible_positions_functional_ );
 
        for(int  i = 0; i < POSITIONS_TOTAL; ++i)
        {
            possible_positions_functional_[i] =    possible_positions_functional_[i]
                                                && positions[i][side_ind] == side_val;
        }
        clear();
        return  possible_positions_functional_ != possible_positions_functional_old;       
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_cur
        (
            T_pos_ind  side_ind,
            int        side_val
        )
    {        
        for(int  i = 0; i < POSITIONS_TOTAL; ++i)
        {
            possible_positions_cur_[i] =    possible_positions_cur_[i]
                                         && positions[i][side_ind] == side_val;
        }
 
        return  std::find(possible_positions_cur_.begin(), possible_positions_cur_.end(), true)
                    != possible_positions_cur_.end();
    }
    //-----------------------------------------------------------------------------------
    bool  get_side_val_functional 
        (
            T_pos_ind  side_ind,        
            int&       side_val
        ) const
    {
        T_side_values_set  side_values_set;
        for(size_t  i = 0; i < possible_positions_functional_.size(); ++i)
        {
            if(possible_positions_functional_[i])
            {
                side_values_set.insert(positions[i][side_ind]);
            }
        } 
        bool  bool_res = side_values_set.size() == 1;
        if(bool_res)
        {
            side_val = *side_values_set.begin();
        }
        return  bool_res;
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string          T_str;
typedef std::vector<T_cell>  T_field;
/////////////////////////////////////////////////////////////////////////////////////////
bool  successfully_set_specified_dice(T_field&  field)
{    
    const double  NET_CELL_PROBABILITY_MIN  = 0.4;
    const double  NET_CELL_PROBABILITY_MAX  = 0.7;
    double        net_cell_probability      = 1;
    while( net_cell_probability         < NET_CELL_PROBABILITY_MIN
           || NET_CELL_PROBABILITY_MAX  < net_cell_probability )
    {        
        net_cell_probability = rand() / double(RAND_MAX);
    }              
 
    const double  SPECIFIED_NET_CELL_PROBABILITY_MAX  = 0.3;
    double        specified_net_cell_probability      = 1;
    while(specified_net_cell_probability > SPECIFIED_NET_CELL_PROBABILITY_MAX)
    {        
        specified_net_cell_probability = rand() / double(RAND_MAX);
    }
 
    bool  net_cell_specified_has_been_inserted = false;   
    //Назначаем клетки решетки и заданные клетки.
    for(size_t  k = 0; k < field.size(); ++k)
    {
        if( rand() <= RAND_MAX * net_cell_probability )
        {
            field[k].set_net_cell_not_specified_state(); 
        }
 
        if( rand() <= RAND_MAX * specified_net_cell_probability )
        {
            field[k].set_net_cell_specified_state(); 
            net_cell_specified_has_been_inserted = true;
            //Для клеток кроме первого столбца, где слева функциональная грань, 
            //устанавливаем левую функциональную грань.
            if(k % FIELD_DIM != 0)
            {
                int  side_val = 0;
                if( field[k - 1].get_side_right_functional(side_val) )
                {
                    field[k].set_side_left_functional_efficiently(side_val);
                }
            }
 
            //Для клеток кроме первой строки, где сверху функциональная грань, 
            //устанавливаем верхнюю функциональную грань.
            if(k / FIELD_DIM != 0)
            {
                int  side_val = 0;
                if( field[k - FIELD_DIM].get_side_bottom_functional(side_val) )
                {
                    field[k].set_side_top_functional_efficiently(side_val);
                }
            }
 
            if( !field[k].set_rand_pos() )
            {
                return  false;
            }                       
        }//if( rand() <= RAND_MAX * specified_net_cell_probability )   
    }
    return  net_cell_specified_has_been_inserted;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_field(const T_field&  field)
{    
    const T_str  space = T_str(1, ' ');
    for(size_t  i = 0; i < FIELD_DIM; ++i)
    {
        //Печатаем топовые грани кубиков:
        for(size_t  j = 0; j < FIELD_DIM; ++j)
        {
            int  k = FIELD_DIM * i + j;
            
            if(field[k].is_not_net_cell())
            {
                std::cout << T_str(3, ' ');
            }
            else
            {
                if(field[k].empty())
                {
                    std::cout << " X ";
                }
                else
                {
                    std::cout << ' '
                              << field[k].get_side_top_cur()
                              << ' ';                            
                }
            }
            std::cout << space;
        } 
        std::cout << std::endl;
 
        //Печатаем левые, верхние и правые грани кубиков:
        for(size_t  j = 0; j < FIELD_DIM; ++j)
        {
            int  k = FIELD_DIM * i + j;
            
            if(field[k].is_not_net_cell())
            {
                std::cout << T_str(3, ' ');
            }
            else
            {
                if(field[k].empty())
                {
                    std::cout << "XXX";
                }
                else
                {
                    std::cout << field[k].get_side_left_cur   ()
                              << field[k].get_val             ()
                              << field[k].get_side_right_cur  ();                
                }
            }
            std::cout << space;
        } 
        std::cout << std::endl;
 
        //Печатаем нижние грани кубиков:
        for(size_t  j = 0; j < FIELD_DIM; ++j)
        {
            int  k = FIELD_DIM * i + j;
            
            if(field[k].is_not_net_cell())
            {
                std::cout << T_str(3, ' ');
            }
            else
            {
                if(field[k].empty())
                {
                    std::cout << " X ";
                }
                else
                {
                    std::cout << ' '
                              << field[k].get_side_bottom_cur()
                              << ' ';                            
                }
            }
            std::cout << space;
        } 
        std::cout << std::endl;
        std::cout << std::endl;
    }//for(size_t  i = 0; i < FIELD_DIM; ++i)
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  inc_cell_pos
    (
        int       k, 
        T_field&  field
    )
{
    //Так как влияние заданных клеток уже учтено в функции set_functional_dice, 
    //то пустые незаданные клетки настраиваем только в зависимости от левых 
    //и верхних незаданных клеток решетки.
    if(field[k].empty())
    {
        //Для клеток кроме первого столбца, где слева незаданная клетка решетки, 
        //устанавливаем левую грань.
        if(k % FIELD_DIM != 0)
        {
            if( field[k - 1].is_net_cell_not_specified() )
            {
                field[k].set_side_left_cur( field[k - 1].get_side_right_cur() );
            }                     
        }
 
        //Для клеток кроме первой строки, где сверху незаданная клетка решетки,
        //устанавливаем верхнюю грань.
        if(k / FIELD_DIM != 0)
        {
            if(field[k - FIELD_DIM].is_net_cell_not_specified())
            {
                field[k].set_side_top_cur( field[k - FIELD_DIM].get_side_bottom_cur() );
            }
        }
    }
 
    return  field[k].inc_pos_or_clear();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  get_next_net_cell_not_specified_ind
    (
        int&            k,    
        const T_field&  field
    )
{
    do
    {
        ++k;
    }while(    k < int(field.size())
            && !field[k].is_net_cell_not_specified() );
 
    return  k < int(field.size());
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  get_prev_net_cell_not_specified_ind
    (
        int&            k,    
        const T_field&  field
    )
{
    do
    {
        --k;
    }while(    k >= 0
            && !field[k].is_net_cell_not_specified() );
 
    return  k >= 0;           
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  set_functional_dice(T_field&  field)
{   
    bool  field_has_been_changed = false;
    do
    {
        field_has_been_changed = false;
        for(size_t  k = 0; k < field.size(); ++k)
        {            
            if(!field[k].is_net_cell_not_specified())
            {
                continue;
            }
 
            //Для клеток кроме первого столбца, где слева функциональная грань, 
            //устанавливаем левую грань.
            if(k % FIELD_DIM != 0)
            {
                int  side_val = 0;
                if( field[k - 1].get_side_right_functional(side_val) )
                {
                    if( field[k].set_side_left_functional_efficiently(side_val) )
                    {
                        field_has_been_changed = true;
                    }
                }
            }
 
            //Для клеток кроме первой строки, где сверху функциональная грань,
            //устанавливаем верхнюю грань.
            if(k / FIELD_DIM != 0)
            { 
                int  side_val = 0;
                if( field[k - FIELD_DIM].get_side_bottom_functional(side_val) )
                {
                    if( field[k].set_side_top_functional_efficiently(side_val) )
                    {
                        field_has_been_changed = true;
                    }
                }
            }
 
            //Для клеток кроме последнего столбца, где справа функциональная грань, 
            //устанавливаем правую грань.
            if(k % FIELD_DIM != FIELD_DIM - 1)
            { 
                int  side_val = 0;
                if( field[k + 1].get_side_left_functional(side_val) )
                {
                    if( field[k].set_side_right_functional_efficiently(side_val) )
                    {
                        field_has_been_changed = true;
                    }
                }
            }
 
            //Для клеток кроме последней строки, где снизу функциональная грань,
            //устанавливаем нижнюю грань.
            if(k / FIELD_DIM != FIELD_DIM - 1)
            { 
                int  side_val = 0;
                if( field[k + FIELD_DIM].get_side_top_functional(side_val) )
                {
                    if( field[k].set_side_bottom_functional_efficiently(side_val) )
                    {
                        field_has_been_changed = true;
                    }
                }
            }
            
            if(field[k].get_positions_count_true_functional() == 0)
            {
                return  false;
            }
 
            if(field[k].get_positions_count_true_functional() == 1)
            {
                //Назначаем клетку заданной.                
                field[k].set_net_cell_specified_state();
                field[k].set_min_pos();
            }
        }//for(size_t  k = 0; k < field.size(); ++k)
    }while(field_has_been_changed);
    return  true;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  set_dice(T_field&  field)
{
    //Сначала пытаемся заполнить функциональные клетки.
    if(!set_functional_dice(field))
    {
        return  false;
    }
 
    //Обходим все клетки поля челночными движениями и пытаемся заполнить каждую пустую
    //или неудачно заполненную клетку минимальным значением.     
    int  k = EMPTY_POSITION_IND;   
    if( !get_next_net_cell_not_specified_ind(k, field) )
    {
        return  true;
    }
 
    for(;;)
    {       
        if(inc_cell_pos(k, field))
        {            
            if( !get_next_net_cell_not_specified_ind(k, field) )
            {
                return  true;
            }
        }
        else
        {
            if( !get_prev_net_cell_not_specified_ind(k, field) )
            {
                return  false;
            }
        }
    }   
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
    
    const T_field  FIELD_START(FIELD_DIM * FIELD_DIM);
    T_field        field = FIELD_START;    
    while( !successfully_set_specified_dice(field) )
    {
        field = FIELD_START;
    }
    
    std::cout << "Исходная позиция:"
              << std::endl;
    print_field(field);
    if(set_dice(field))
    {
        std::cout << "Игральные кости в остальные позиции сетки можно расставить так: "
                  << std::endl;
        print_field(field);    
    }
    else
    {
        std::cout << "Для заданной позиции решения не существует."
                  << std::endl;    
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
//Программа играющая в игру «Расстановка игральных костей».
//
//Задана частичная двумерная сетка. В некоторых позициях сетки расставлены 
//игральные кости. Расставить кости в остальных позициях сетки, причём кости 
//могут касаться друг друга только одинаковыми гранями.
/////////////////////////////////////////////////////////////////////////////////////////
// Программа быстро решает задания с размерностью поля 19.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <set>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
const int  FIELD_DIM           = 19;
const int  POSITIONS_TOTAL     = 24;
const int  EMPTY_POSITION_IND  = -1;
/////////////////////////////////////////////////////////////////////////////////////////
enum  T_pos_ind
{
    VAL_IND,
    SIDE_LEFT_IND,
    SIDE_TOP_IND,
    SIDE_RIGHT_IND,
    SIDE_BOTTOM_IND,
    POS_INDEXES_TOTAL
};
/////////////////////////////////////////////////////////////////////////////////////////
int  positions[POSITIONS_TOTAL][POS_INDEXES_TOTAL] =
    {
        {1, 2, 4, 5, 3},
        {1, 3, 2, 4, 5},
        {1, 4, 5, 3, 2},
        {1, 5, 3, 2, 4},
 
        {2, 1, 3, 6, 4},
        {2, 3, 6, 4, 1},
        {2, 4, 1, 3, 6},
        {2, 6, 4, 1, 3},
 
        {3, 1, 5, 6, 2},
        {3, 2, 1, 5, 6},
        {3, 5, 6, 2, 1},
        {3, 6, 2, 1, 5},
 
        {4, 1, 2, 6, 5},
        {4, 2, 6, 5, 1},
        {4, 5, 1, 2, 6},
        {4, 6, 5, 1, 2},
 
        {5, 1, 4, 6, 3},
        {5, 3, 1, 4, 6},
        {5, 4, 6, 3, 1},
        {5, 6, 3, 1, 4},
 
        {6, 2, 3, 5, 4},
        {6, 3, 5, 4, 2},
        {6, 4, 2, 3, 5},
        {6, 5, 4, 2, 3}
    };
/////////////////////////////////////////////////////////////////////////////////////////
class  T_cell
{
    enum  T_cell_state
    {
        NOT_NET_CELL,
        NET_CELL_NOT_SPECIFIED,
        NET_CELL_SPECIFIED    
    };
    //-----------------------------------------------------------------------------------
    typedef std::deque<bool>  T_possible_positions;    
    typedef std::set<int>     T_side_values_set;    
    //-----------------------------------------------------------------------------------
    T_cell_state          state_;   
    T_possible_positions  possible_positions_;
    T_possible_positions  possible_positions_CUR_;
    int                   position_ind_CUR_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_cell() 
        : state_               (NOT_NET_CELL),
          possible_positions_  ( T_possible_positions(POSITIONS_TOTAL, true) )
    {   
        clear();        
    }
    //-----------------------------------------------------------------------------------
    void  set_net_cell_not_specified_state()
    {
        set_state(NET_CELL_NOT_SPECIFIED);
    }
    //-----------------------------------------------------------------------------------
    void  set_net_cell_specified_state()
    {
        set_state(NET_CELL_SPECIFIED);
    }    
    //-----------------------------------------------------------------------------------
    bool  set_side_left_values_set_efficiently(const T_side_values_set&  side_left_values_set)
    {
        return  set_side_values_set_efficiently(SIDE_LEFT_IND, side_left_values_set);
    }
    //-----------------------------------------------------------------------------------    
    bool  set_side_left_efficiently(int  side_left)
    {
        return  set_side_efficiently(SIDE_LEFT_IND, side_left);
    }    
    //-----------------------------------------------------------------------------------
    bool  set_side_top_values_set_efficiently(const T_side_values_set&  side_top_values_set)
    {
        return  set_side_values_set_efficiently(SIDE_TOP_IND, side_top_values_set);
    }
    //-----------------------------------------------------------------------------------    
    bool  set_side_top_efficiently(int  side_top)
    {
        return  set_side_efficiently(SIDE_TOP_IND, side_top);
    }    
    //-----------------------------------------------------------------------------------
    bool  set_side_right_values_set_efficiently
        (const T_side_values_set&  side_right_values_set)
    {
        return  set_side_values_set_efficiently(SIDE_RIGHT_IND, side_right_values_set);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_bottom_values_set_efficiently
        (const T_side_values_set&  side_bottom_values_set)
    {
        return  set_side_values_set_efficiently(SIDE_BOTTOM_IND, side_bottom_values_set);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_left_cur(int  side_left)
    {
        return  set_side_CUR(SIDE_LEFT_IND, side_left);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_right_cur(int  side_right)
    {
        return  set_side_CUR(SIDE_RIGHT_IND, side_right);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_top_cur(int  side_top)
    {
        return  set_side_CUR(SIDE_TOP_IND, side_top);
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_bottom_cur(int  side_bottom)
    {
        return  set_side_CUR(SIDE_BOTTOM_IND, side_bottom);
    }
    //-----------------------------------------------------------------------------------
    T_side_values_set  get_side_right_values_set() const
    {
        return  get_side_values_set(SIDE_RIGHT_IND);
    }
    //-----------------------------------------------------------------------------------    
    bool  get_side_right(int&  side_right) const
    {
        return  get_side_val(SIDE_RIGHT_IND, side_right);
    }    
    //-----------------------------------------------------------------------------------
    T_side_values_set  get_side_left_values_set() const
    {
        return  get_side_values_set(SIDE_LEFT_IND);
    }
    //-----------------------------------------------------------------------------------
    T_side_values_set  get_side_bottom_values_set() const
    {
        return  get_side_values_set(SIDE_BOTTOM_IND);
    }
    //-----------------------------------------------------------------------------------    
    bool  get_side_bottom(int&  side_bottom) const
    {
        return  get_side_val(SIDE_BOTTOM_IND, side_bottom);
    }    
    //-----------------------------------------------------------------------------------
    T_side_values_set  get_side_top_values_set() const
    {
        return  get_side_values_set(SIDE_TOP_IND);
    }
    //-----------------------------------------------------------------------------------
    int  get_side_right_cur() const
    {
        return  positions[position_ind_CUR_][SIDE_RIGHT_IND];
    }
    //-----------------------------------------------------------------------------------
    int  get_side_left_cur() const
    {
        return  positions[position_ind_CUR_][SIDE_LEFT_IND];
    }
    //-----------------------------------------------------------------------------------
    int  get_side_bottom_cur() const
    {
        return  positions[position_ind_CUR_][SIDE_BOTTOM_IND];
    }
    //-----------------------------------------------------------------------------------
    int  get_side_top_cur() const
    {
        return  positions[position_ind_CUR_][SIDE_TOP_IND];
    }
    //-----------------------------------------------------------------------------------    
    bool  set_rand_single_pos_in_possible_positions_and_set_min_position_ind_CUR()
    {
        bool  bool_res = get_true_values_in_possible_positions_count() != 0;
        
        if(bool_res)
        {
            int  position_ind_cur = 0;
            do
            {
                position_ind_cur = rand() % possible_positions_.size();
            }while(!possible_positions_[position_ind_cur]);
 
            possible_positions_  = T_possible_positions(POSITIONS_TOTAL, false);
            possible_positions_[position_ind_cur] = true;
            set_min_position_ind_CUR();
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  set_min_position_ind_CUR()
    {
        bool  bool_res = get_true_values_in_possible_positions_count() != 0;
 
        if(bool_res)
        {
            clear();
            do
            {
                ++position_ind_CUR_;                
            }while(!possible_positions_CUR_[position_ind_CUR_]);
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    bool  empty() const 
    {
        return  position_ind_CUR_ == EMPTY_POSITION_IND;
    }
    //-----------------------------------------------------------------------------------
    int  get_val() const
    {
        return  positions[position_ind_CUR_][VAL_IND];
    }
    //-----------------------------------------------------------------------------------
    bool  is_not_net_cell() const
    {
        return  state_ == NOT_NET_CELL;
    }
    //-----------------------------------------------------------------------------------
    bool  is_net_cell_not_specified() const
    {
        return  state_ == NET_CELL_NOT_SPECIFIED;
    }
    //-----------------------------------------------------------------------------------
    bool  is_net_cell_specified() const
    {
        return  state_ == NET_CELL_SPECIFIED;
    }
    //-----------------------------------------------------------------------------------
    bool  inc_pos_or_clear_and_return_false()
    {
        do
        {
            ++position_ind_CUR_;
        }while(   position_ind_CUR_ < int( possible_positions_CUR_.size() )
               && !possible_positions_CUR_[position_ind_CUR_] );
 
        bool  bool_res =    position_ind_CUR_ < int( possible_positions_CUR_.size() )
                         && possible_positions_CUR_[position_ind_CUR_];
 
        if(!bool_res)
        {
            clear();
        }
        return  bool_res;
    }
    //-----------------------------------------------------------------------------------
    int  get_true_values_in_possible_positions_count() const
    {
        return  std::count( possible_positions_.begin(), 
                            possible_positions_.end(), true );
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  set_state(T_cell_state  state)
    {
        state_ = state;
    }
    //-----------------------------------------------------------------------------------
    void  clear()
    {       
        possible_positions_CUR_  = possible_positions_;
        position_ind_CUR_        = EMPTY_POSITION_IND;
    }
    //-----------------------------------------------------------------------------------
    bool  set_side_values_set_efficiently
        (
            T_pos_ind                 side_ind,
            const T_side_values_set&  side_values_set
        )
    {
        T_possible_positions  possible_positions_old( possible_positions_ );
 
        for(int  i = 0; i < POSITIONS_TOTAL; ++i)
        {
            possible_positions_[i] =    possible_positions_[i]
                                     && side_values_set.count(positions[i][side_ind]);                                                    
        }
        clear();
        return  possible_positions_ != possible_positions_old;       
    }
    //-----------------------------------------------------------------------------------    
    bool  set_side_efficiently
        (
            T_pos_ind  side_ind,
            int        side_val
        )
    {
        T_possible_positions  possible_positions_old( possible_positions_ );
 
        for(int  i = 0; i < POSITIONS_TOTAL; ++i)
        {
            possible_positions_[i] =    possible_positions_[i]
                                     && positions[i][side_ind] == side_val;
        }
        clear();
        return  possible_positions_ != possible_positions_old;       
    }    
    //-----------------------------------------------------------------------------------
    bool  set_side_CUR
        (
            T_pos_ind  side_ind,
            int        side_val
        )
    {        
        for(int  i = 0; i < POSITIONS_TOTAL; ++i)
        {
            possible_positions_CUR_[i] =    possible_positions_CUR_[i]
                                         && positions[i][side_ind] == side_val;
        }
 
        return  std::find(possible_positions_CUR_.begin(), possible_positions_CUR_.end(), true)
                    != possible_positions_CUR_.end();
    }
    //-----------------------------------------------------------------------------------
    T_side_values_set  get_side_values_set(T_pos_ind  side_ind) const
    {
        T_side_values_set  side_values_set;        
        for(size_t  i = 0; i < possible_positions_.size(); ++i)
        {
            if(possible_positions_[i])
            {
                side_values_set.insert(positions[i][side_ind]);
            }
        } 
        return  side_values_set;
    }
    //-----------------------------------------------------------------------------------    
    bool  get_side_val
        (
            T_pos_ind  side_ind,        
            int&       side_val
        ) const
    {
        T_side_values_set  side_values_set;
        for(size_t  i = 0; i < possible_positions_.size(); ++i)
        {
            if(possible_positions_[i])
            {
                side_values_set.insert(positions[i][side_ind]);
            }
        } 
        bool  bool_res = side_values_set.size() == 1;
        if(bool_res)
        {
            side_val = *side_values_set.begin();
        }
        return  bool_res;
    }    
};
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string               T_str;
typedef std::vector<T_cell>       T_field;
typedef std::deque<int>           T_cells_indexes;
typedef std::vector<int>          T_distances;
typedef std::vector<T_distances>  T_vector_of_distances;
typedef std::multimap<int, int>   T_distance_and_its_ind;
/////////////////////////////////////////////////////////////////////////////////////////
bool  successfully_set_specified_dice(T_field&  field)
{    
    const double  NET_CELL_PROBABILITY_MIN  = 0.4;
    const double  NET_CELL_PROBABILITY_MAX  = 0.7;
    double        net_cell_probability      = 1;
    while( net_cell_probability         < NET_CELL_PROBABILITY_MIN
           || NET_CELL_PROBABILITY_MAX  < net_cell_probability )
    {        
        net_cell_probability = rand() / double(RAND_MAX);
    }              
 
    const double  SPECIFIED_NET_CELL_PROBABILITY_MAX  = 0.3;
    double        specified_net_cell_probability      = 1;
    while(specified_net_cell_probability > SPECIFIED_NET_CELL_PROBABILITY_MAX)
    {        
        specified_net_cell_probability = rand() / double(RAND_MAX);
    }
 
    bool  net_cell_specified_has_been_inserted = false;   
    //Назначаем клетки решетки и заданные клетки.
    for(size_t  k = 0; k < field.size(); ++k)
    {
        if( rand() <= RAND_MAX * net_cell_probability )
        {
            field[k].set_net_cell_not_specified_state();
        }
 
        if( rand() <= RAND_MAX * specified_net_cell_probability )
        {
            field[k].set_net_cell_specified_state(); 
            net_cell_specified_has_been_inserted = true;
            //Для клеток кроме первого столбца, где слева функциональная грань, 
            //устанавливаем левую функциональную грань.
            if(k % FIELD_DIM != 0)
            {
                int  side_val = 0;
                if( field[k - 1].get_side_right(side_val) )
                {
                    field[k].set_side_left_efficiently(side_val);
                }
            }
 
            //Для клеток кроме первой строки, где сверху функциональная грань, 
            //устанавливаем верхнюю функциональную грань.
            if(k / FIELD_DIM != 0)
            {
                int  side_val = 0;
                if( field[k - FIELD_DIM].get_side_bottom(side_val) )
                {
                    field[k].set_side_top_efficiently(side_val);
                }
            }
 
            if
                ( 
                    !field[k]
                        .set_rand_single_pos_in_possible_positions_and_set_min_position_ind_CUR() 
                )
            {
                return  false;
            }                       
        }//if( rand() <= RAND_MAX * specified_net_cell_probability )   
    }
    return  net_cell_specified_has_been_inserted;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  print_field(const T_field&  field)
{ 
    const T_str  space = T_str(1, ' ');
    for(size_t  i = 0; i < FIELD_DIM; ++i)
    {
        //Печатаем топовые грани кубиков:
        for(size_t  j = 0; j < FIELD_DIM; ++j)
        {
            int  k = FIELD_DIM * i + j;
            
            if( field[k].is_not_net_cell() )
            {
                std::cout << T_str(3, ' ');
            }
            else
            {
                if(field[k].empty())
                {
                    std::cout << " X ";
                }
                else
                {
                    std::cout << ' '
                              << field[k].get_side_top_cur()
                              << ' ';                            
                }
            }
            std::cout << space;
        } 
        std::cout << std::endl;
 
        //Печатаем левые, верхние и правые грани кубиков:
        for(size_t  j = 0; j < FIELD_DIM; ++j)
        {
            int  k = FIELD_DIM * i + j;
            
            if(field[k].is_not_net_cell())
            {
                std::cout << T_str(3, ' ');
            }
            else
            {
                if(field[k].empty())
                {
                    std::cout << "XXX";
                }
                else
                {
                    std::cout << field[k].get_side_left_cur   ()
                              << field[k].get_val             ()
                              << field[k].get_side_right_cur  ();              
                }
            }
            std::cout << space;
        } 
        std::cout << std::endl;
 
        //Печатаем нижние грани кубиков:
        for(size_t  j = 0; j < FIELD_DIM; ++j)
        {
            int  k = FIELD_DIM * i + j;
            
            if(field[k].is_not_net_cell())
            {
                std::cout << T_str(3, ' ');
            }
            else
            {
                if( field[k].empty() )
                {
                    std::cout << " X ";
                }
                else
                {
                    std::cout << ' '
                              << field[k].get_side_bottom_cur()
                              << ' ';                            
                }
            }
            std::cout << space;
        } 
        std::cout << std::endl;
        std::cout << std::endl;
    }//for(size_t  i = 0; i < FIELD_DIM; ++i)    
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  inc_cell_pos
    (
        int       k, 
        T_field&  field
    )
{
    //Так как влияние заданных клеток уже учтено в функции 
    //set_all_not_specified_cells_according_to_all_specified_cells, 
    //то незаданные клетки настраиваем только в зависимости от соседних 
    //незаданных клеток решетки.
 
    //Ищем соседние незаданные непустые клетки и устанавливаем для нашей клетки
    //их грани.
 
    //Для клеток кроме первого столбца, где слева незаданная непустая клетка, 
    //устанавливаем левую грань.
    if(k % FIELD_DIM != 0)
    {
        if
            ( 
                   field[k - 1].is_net_cell_not_specified()
                && !field[k - 1].empty()
            )
        {
            field[k].set_side_left_cur( field[k - 1].get_side_right_cur() );
        }
    }
 
    //Для клеток кроме первой строки, где сверху незаданная непустая клетка,
    //устанавливаем верхнюю грань.
    if(k / FIELD_DIM != 0)
    {
        if
            ( 
                   field[k - FIELD_DIM].is_net_cell_not_specified()
                && !field[k - FIELD_DIM].empty()
            )
        {
            field[k].set_side_top_cur( field[k - FIELD_DIM].get_side_bottom_cur() );
        }
    }
 
    //Для клеток кроме последнего столбца, где справа незаданная непустая клетка, 
    //устанавливаем правую грань.
    if(k % FIELD_DIM != FIELD_DIM - 1)
    { 
        if
            ( 
                   field[k + 1].is_net_cell_not_specified()
                && !field[k + 1].empty()
            )
        {
            field[k].set_side_right_cur( field[k + 1].get_side_left_cur() );
        }
    }
 
    //Для клеток кроме последней строки, где снизу незаданная непустая клетка,
    //устанавливаем нижнюю грань.
    if(k / FIELD_DIM != FIELD_DIM - 1)
    { 
        if
            ( 
                   field[k + FIELD_DIM].is_net_cell_not_specified()
                && !field[k + FIELD_DIM].empty()
            )
        {
            field[k].set_side_bottom_cur( field[k + FIELD_DIM].get_side_top_cur() );
        }
    }    
 
    return  field[k].inc_pos_or_clear_and_return_false();
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  get_next_net_cell_not_specified_ind
    (
        int&                    net_cell_not_specified_ind_of_index,    
        const T_cells_indexes&  net_cells_not_specified_indexes        
    )
{
    ++net_cell_not_specified_ind_of_index;
    return  net_cell_not_specified_ind_of_index < int(net_cells_not_specified_indexes.size());
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  get_prev_net_cell_not_specified_ind(int&  net_cell_not_specified_ind_of_index)
{
    --net_cell_not_specified_ind_of_index;
    return  net_cell_not_specified_ind_of_index >= 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  set_all_not_specified_cells_according_to_all_specified_cells(T_field&  field)
{   
    bool  field_has_been_changed = false;
    do
    {
        field_has_been_changed = false;
        for(size_t  k = 0; k < field.size(); ++k)
        {            
            if(!field[k].is_net_cell_not_specified())
            {
                continue;
            }
 
            //Для клеток кроме первого столбца устанавливаем множество значений левой грани.
            if(k % FIELD_DIM != 0)
            {
                if
                    ( 
                        field[k].set_side_left_values_set_efficiently
                            (
                                field[k - 1].get_side_right_values_set()
                            ) 
                    )
                {
                    field_has_been_changed = true;
                }
            }
 
            //Для клеток кроме первой строки устанавливаем множество значений верхней грани.
            if(k / FIELD_DIM != 0)
            {
                if
                    ( 
                        field[k].set_side_top_values_set_efficiently
                            (
                                field[k - FIELD_DIM].get_side_bottom_values_set()
                            ) 
                    )
                {
                    field_has_been_changed = true;
                }
            }
 
            //Для клеток кроме последнего столбца устанавливаем множество значений правой грани.
            
            if(k % FIELD_DIM != FIELD_DIM - 1)
            {
                if
                    ( 
                        field[k].set_side_right_values_set_efficiently
                            (
                                field[k + 1].get_side_left_values_set()
                            ) 
                    )
                {
                    field_has_been_changed = true;
                }
            }
 
            //Для клеток кроме последней строки, где снизу функциональная грань,
            //устанавливаем нижнюю грань.
            if(k / FIELD_DIM != FIELD_DIM - 1)
            {
                if
                    ( 
                        field[k].set_side_bottom_values_set_efficiently
                            (
                                field[k + FIELD_DIM].get_side_top_values_set()
                            ) 
                    )
                {
                    field_has_been_changed = true;
                }
            }
            
            if( field[k].get_true_values_in_possible_positions_count() == 0 )
            {
                return  false;
            }
        }//for(size_t  k = 0; k < field.size(); ++k)
    }while(field_has_been_changed);
    return  true;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_distances  get_net_cell_not_specified_distances_from_ind
    (
        int             specified_cell_ind, 
        const T_field&  field
    )
{
    T_distances  distances_res( field.size() );
    bool  distance_is_changed  = false;
    const int  DIST_BIG        = FIELD_DIM * FIELD_DIM * FIELD_DIM;
    do
    {
        distance_is_changed = false;
        for(size_t  k = 0; k < distances_res.size(); ++k)
        {
            if( !field[k].is_net_cell_not_specified() ) continue;
            
            int&  dist_cur = distances_res[k];
            if(dist_cur == 0)
            {
                dist_cur = DIST_BIG;
            }
            //Обходим все соседние клетки.
            int  i = k / FIELD_DIM;
            int  j = k % FIELD_DIM;
            for( int  i_adj = std::max(i - 1, 0); 
                 i_adj <= std::min(i + 1, FIELD_DIM - 1); ++i_adj )
            {
                for(int  j_adj = std::max(j - 1, 0); 
                    j_adj <= std::min(j + 1, FIELD_DIM - 1); ++j_adj)
                {
                    if( abs(i_adj - i) + abs(j_adj - j) == 1 )
                    {
                        int   k_adj     = i_adj * FIELD_DIM + j_adj;                            
                        int&  dist_adj  = distances_res[k_adj];
 
                        if(    dist_adj  != 0 
                            && dist_adj  != DIST_BIG 
                            && dist_cur > dist_adj + 1)
                        {
                            distance_is_changed  = true;
                            dist_cur             = dist_adj + 1;
                        }
 
                        if(   k_adj     == specified_cell_ind
                           && dist_cur  != 1                  )
                        {
                            distance_is_changed  = true;
                            dist_cur             = 1;
                        }
                    }//if(   i_adj == i
                }//for(int  j_adj = std::max(j - 1, 0); ...
            }//for(int  i_adj = std::max(i - 1, 0); ...
        }//for(size_t  k = 0; k < distances_res.size(); ++k)
    }while(distance_is_changed);
 
    return  distances_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_cells_indexes  get_net_cells_not_specified_indexes(const T_field&  field)
{    
    //В этой функции создаем вектор net_cells_not_specified_indexes, в котором индексы 
    //незаданных клеток решетки расположены в порядке возрастания их суммарных расстояний 
    //до всех заданных клеток решетки.
    T_cells_indexes  net_cells_not_specified_indexes;
 
    //Создаем вектор векторов расстояний до незаданных клеток от каждой из заданных клеток.
    T_vector_of_distances  vector_of_distances;
    //Обходим поле, и для каждой заданной клетки создаем вектор расстояний от нее
    //до всех незаданных клеток решетки.
    for(size_t  i = 0; i < field.size(); ++i)
    {
        if(field[i].is_net_cell_specified())
        {
            vector_of_distances.push_back
                ( get_net_cell_not_specified_distances_from_ind(i, field) );
        }
    }
    T_distances  net_cell_not_specified_sum_of_distances(field.size());
    //Суммируем значения элементов vector_of_distances для каждого индекса поля
    //в векторе net_cell_not_specified_sum_of_distances.
    for(size_t  i = 0; i < vector_of_distances.size(); ++i)
    {
        std::transform
            (
                net_cell_not_specified_sum_of_distances.begin(),
                net_cell_not_specified_sum_of_distances.end(),
                vector_of_distances[i].begin(),                
                net_cell_not_specified_sum_of_distances.begin(),
                std::plus<int>()
            );
    }
 
    T_distance_and_its_ind  distance_and_its_ind;
    for(size_t  i = 0; i < net_cell_not_specified_sum_of_distances.size(); ++i)
    {
        if(net_cell_not_specified_sum_of_distances[i])
        {
            distance_and_its_ind
                .insert
                    (std::make_pair(net_cell_not_specified_sum_of_distances[i], i));
        }        
    }
 
    for(T_distance_and_its_ind::const_iterator  it_dist_ind = distance_and_its_ind.begin();
        it_dist_ind != distance_and_its_ind.end(); ++it_dist_ind)
    {
        net_cells_not_specified_indexes.push_back(it_dist_ind->second);
    }
    return  net_cells_not_specified_indexes;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool  set_dice(T_field&  field)
{
    //Обходим все клетки поля челночными движениями и пытаемся заполнить каждую пустую
    //или неудачно заполненную клетку минимальным значением. 
    
    //Создаем дек индексов, по которому будем совершать челночные движения. 
    const  T_field   FIELD_START                          = field;
    int              net_cell_not_specified_ind_of_index  = EMPTY_POSITION_IND;
    T_cells_indexes  net_cells_not_specified_indexes
                         = get_net_cells_not_specified_indexes(field);    
 
    if
        ( 
            !get_next_net_cell_not_specified_ind
                (
                    net_cell_not_specified_ind_of_index, 
                    net_cells_not_specified_indexes
                ) 
        )
    {
        return  true;
    }
    
    const int  REPETITIONS_COUNT_MAX  = 10;
    int        repetitions_counter    = 0;
    int        max_ind_of_index       = 0;    
    int        ind_of_index_old       = 0;
    //Если мы упираемся в какую-то клетку больше REPETITIONS_COUNT_MAX раз, то переносим
    //ее индекс в начало дека net_cells_not_specified_indexes.    
    for(;;)
    {
        if
            ( 
                inc_cell_pos
                    (
                        net_cells_not_specified_indexes[net_cell_not_specified_ind_of_index],
                        field
                    ) 
            )
        {            
            if
                ( 
                    !get_next_net_cell_not_specified_ind
                        (
                            net_cell_not_specified_ind_of_index, 
                            net_cells_not_specified_indexes
                        ) 
                )
            {
                return  true;
            } 
 
            if(net_cell_not_specified_ind_of_index > max_ind_of_index)
            {                
                max_ind_of_index     = net_cell_not_specified_ind_of_index;
                repetitions_counter  = 0;
            }            
        }
        else
        {
            ind_of_index_old = net_cell_not_specified_ind_of_index;
            if
                (
                    !get_prev_net_cell_not_specified_ind
                        (net_cell_not_specified_ind_of_index) 
                )
            {
                return  false;
            }
 
            if(ind_of_index_old == max_ind_of_index)
            {                
                if(++repetitions_counter >= REPETITIONS_COUNT_MAX)
                {
                    std::cout << "начато заново после заполнения "
                              << max_ind_of_index
                              << '\t'
                              << "клеток из "
                              << net_cells_not_specified_indexes.size()
                              << "..."
                              << std::endl;
 
                    int  ind = net_cells_not_specified_indexes[max_ind_of_index];
                    T_cells_indexes::iterator  ind_it  = net_cells_not_specified_indexes.begin();
                    std::advance(ind_it, max_ind_of_index);
                    net_cells_not_specified_indexes.erase(ind_it);
                    net_cells_not_specified_indexes.push_front(ind);                    
                    field                                = FIELD_START;
                    net_cell_not_specified_ind_of_index  = 0;
                    max_ind_of_index                     = 0;
                }
            }
        }
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    srand(static_cast<unsigned>(time(0)));
 
    const T_field  FIELD_START(FIELD_DIM * FIELD_DIM);    
    T_field        field = FIELD_START; 
    
    
    std::cout << "Идет составление задания, имеющего решение:"
              << std::endl;
    while(    !successfully_set_specified_dice                               (field)
           || !set_all_not_specified_cells_according_to_all_specified_cells  (field) )
    {
        field = FIELD_START;
    }   
    
    std::cout << "Исходная позиция:"
              << std::endl;
    print_field(field);
 
    if(set_dice(field))
    {
        std::cout << "Игральные кости в остальные позиции сетки можно расставить так: "
                  << std::endl;
        print_field(field);            
    }
    else
    {
        std::cout << "Для заданной позиции решения не существует."
                  << std::endl;    
    }
}