[Матрица] Круг или квадрат?

/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::vector<int>    T_row;
typedef std::vector<T_row>  T_matr;
/////////////////////////////////////////////////////////////////////////////////////////
bool  is_square
    (
        int            rows_total,
        int            cols_total,
        const T_matr&  matr
    )
{
    const int  SQUARE_DIM_MIN  = 3;
    const int  MATR_DIM_MAX    = 1000;
    if(std::min(rows_total, cols_total) < SQUARE_DIM_MIN) return false;
    if(std::max(rows_total, cols_total) > MATR_DIM_MAX  ) return false;
    bool  black_cell_exist = false;
    //Отыскиваем минимальный прямоугольник, содержащий все черные клетки
    //(расширяя область, если встречаем черную клетку).
    int  left_not_white_col    = cols_total;
    int  right_not_white_col   = -1;
 
    int  top_not_white_row     = rows_total;
    int  bottom_not_white_row  = -1;
 
    for(int  row = 0; row < rows_total; ++row)
    {
        for(int  col = 0; col < cols_total; ++col)
        {
            if(matr[row][col])
            {
                black_cell_exist = true;
 
                if(col < left_not_white_col)
                {
                    left_not_white_col = col;    
                }
 
                if(col > right_not_white_col)
                {
                    right_not_white_col = col;    
                }
 
                if(row < top_not_white_row)
                {
                    top_not_white_row = row;    
                }
 
                if(row > bottom_not_white_row)
                {
                    bottom_not_white_row = row;    
                }
            }//if
        }//for(int  col = 0; col < rows_total; ++col)
    }//for(int  row = 0; row < rows_total; ++row)
 
    if(!black_cell_exist) return false;
 
    //Вычисляем размеры полученного прямоугольника.
    int  not_white_W = right_not_white_col  - left_not_white_col + 1;
    int  not_white_H = bottom_not_white_row - top_not_white_row  + 1;
    //Вычисляем минимальную сторону оставшегося квадрата.
    int  remaind_square_W    = std::max(1, not_white_W - 4);
    int  remaind_square_H    = std::max(1, not_white_H - 4);
    int  remaind_square_dim  = std::max(remaind_square_W, remaind_square_H);
 
    //Пробегаемся по левым верхним допустимым вершинам оставшегося квадрата.
    for(int  top_sq_row = top_not_white_row; 
        top_sq_row <= top_not_white_row + 2; 
        ++top_sq_row)
    {
        //Если до нижнего края прямоугольника не больше 2, то:        
        if(bottom_not_white_row - (top_sq_row + remaind_square_dim - 1) <= 2)
        {
            for(int  left_sq_col = left_not_white_col; 
                left_sq_col <= left_not_white_col + 2; 
                ++left_sq_col)
            {
                //Если до правого края прямоугольника не больше 2, то:                
                if(right_not_white_col - (left_sq_col + remaind_square_dim - 1) <= 2)
                {
                    //Проверяем, что все клетки квадрата черные.
                    bool  remaind_square_is_black = true;
                    for(int  rem_sq_row = top_sq_row; 
                        rem_sq_row < top_sq_row + remaind_square_dim;
                        ++ rem_sq_row)
                    {
                        for(int  rem_sq_col = left_sq_col; 
                            rem_sq_col < left_sq_col + remaind_square_dim;
                            ++ rem_sq_col)
                        {
                            if(!matr[rem_sq_row][rem_sq_col])
                            {
                                remaind_square_is_black = false;
                            }
                        }                    
                    }
                    if(remaind_square_is_black)  return true;
                }
            }            
        }
    }
    return  false;
}
/////////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    const int  ARR_DIM = 7;
    int  arr[ARR_DIM][ARR_DIM] =
    {
        {0, 0, 0, 0, 0, 0, 0},
 
        {0, 0, 0, 0, 0, 0, 0},
 
        {0, 0, 0, 0, 1, 0, 0},
 
        {0, 0, 0, 0, 0, 0, 0},
 
        {0, 0, 1, 0, 0, 0, 0},
 
        {0, 0, 0, 0, 0, 0, 0},
 
        {0, 0, 0, 0, 0, 0, 0},
    };
 
    T_matr  matr(ARR_DIM, T_row(ARR_DIM));
    for(int  i = 0; i < ARR_DIM; ++i)
    {
        for(int  j = 0; j < ARR_DIM; ++j)
        {
            matr[i][j] = arr[i][j];
        }
    }
    std::cout << (is_square(ARR_DIM, ARR_DIM, matr) ? "квадрат" : "круг")
              << std::endl;
}

#include <iostream>
#include <cstdlib> //for abs
int main(){
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    int n, m;
    std::cin >> n >> m;
    if (n < 3 || m < 3){
        std::cout << "CIRCLE";
        return 0;
    }
    char **matrix = new char* [n];
    for (int i = 0; i < n; ++i)
        matrix[i] = new char [m];
    
    int x1 = n, x2 = -1, y1 = -1, y2 = -1;
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < m; ++j){
            std::cin >> matrix[i][j];
            if (matrix[i][j] == '*'){
                if (y1 == -1)
                    y1 = i;
                else
                    y2 = i;
            if (j < x1)
                x1 = j;
            if (j > x2)
                x2 = j;
            }
        }
    
    
    for (int i = y1; i < y1 + 3; ++i)
        for (int j = x1; j < x1 + 3; ++j){
            bool have_whole_cell = false;
            if (abs(i - j) != abs(x2 - y2)) //отсечение неквадратов
                continue;
            for (int x = j; x < x2 - 1; ++x)
                for (int y = i; y < y2 - 1; ++y)
                    if (matrix[y][x] == '.')
                        have_whole_cell = true;
            if (!have_whole_cell){
                std::cout << "SQUARE\n";
                goto del;
            }
        }
    std::cout << "CIRCLE\n";                
    del:
    for (int i = 0; i < n; ++i)
        delete[] matrix[i];
    delete[] matrix;
    
    return 0;
}