Заполнить матрицу ЛП, от левого верхнего угла по спирали: вправо - вниз - влево - вверх

#include <cstdio>
#include <cstring>
#include <cassert>
 
inline unsigned dec_width(unsigned x)
{
  unsigned w = 1;
  while (x /= 10) w++;
  return w;
}
 
int** new_matrix(unsigned rows, unsigned cols)
{
  int** x = new int*[rows];
  for (int row = 0; row != rows; row++)
  {
    x[row] = new int[cols];
    memset(x[row], 0, sizeof(int) * cols);
  }
  return x;
}
 
void free_matrix(int** src, unsigned rows)
{
  for (int row = 0; row != rows; row++) delete []src[row];
  delete []src;
}
 
void print_matrix(int** src, unsigned rows, unsigned cols, const char* header)
{
  unsigned* widths = new unsigned[cols];
  for (int col = 0; col != cols; col++)
  {
    widths[col] = 1;
    for (int row = 0; row != rows; row++)
    {
      unsigned cw = dec_width(src[row][col]);
      if (cw > widths[col]) widths[col] = cw;
    }
  }
 
  printf("\n%s [%d x %d]\n", header, rows, cols);
  for (int row = 0; row != rows; row++)
  {
    for (int col = 0; col != cols; col++) printf(" %*d", widths[col], src[row][col]);
    printf("\n");
  }
 
  delete []widths;
}
 
#define DOWN  0
#define RIGHT 1
#define UP    2
#define LEFT  3
 
// вычисление следующей позиции
bool next(int** x, unsigned rows, unsigned cols, int &row, int &col, int &dir)
{
  #define bounds(x, max) (0 <= (x) && (x) < (max)) // 0 ≤ x < max
  #define possible(r, c) (bounds(r, rows) && bounds(c, cols) && !x[r][c])
  
  switch (dir % 4) 
  {
    case RIGHT:
      if (possible(row, col + 1)) { col++; return true; } // вправо 
      if (possible(row + 1, col)) { row++, dir = DOWN; return true; } // вниз
    break;  
    
    case DOWN:
      if (possible(row + 1, col)) { row++; return true; } // вниз
      if (possible(row, col - 1)) { col--, dir = LEFT; return true; } // влево
    break;
    
    case LEFT:
      if (possible(row, col - 1)) { col--; return true; } // влево
      if (possible(row - 1, col)) { row--, dir = UP; return true; } // вверх
    break;
      
    case UP:
      if (possible(row - 1, col)) { row--; return true; } // вверх
      if (possible(row, col + 1)) { col++, dir = RIGHT; return true; } // вправо
    break;
  }
 
  return false;
}
 
// заполнение матрицы по спирали по часовой стрелке 
// из левого верхнего угла.
void fill_matrix(int** x, unsigned rows, unsigned cols)
{
  int row = 0, col = 0, value = 0, dir = RIGHT;
  do x[row][col] = ++value;
  while (next(x, rows, cols, row, col, dir));
}
 
int main(void)
{
  unsigned rows, cols;
  do printf("\n? rows & cols: ");
  while (scanf("%u %u", &rows, &cols) != 2 || !rows || !cols);
  int** x = new_matrix(rows, cols);
  fill_matrix(x, rows, cols);
  print_matrix(x, rows, cols, " >> matrix: ");
  free_matrix(x, rows);
  return 0;
}

#include <iostream>
#include <iomanip>
#include <vector>
 
struct Plot
{   int x, y;
    Plot operator+(const Plot& p){return {x + p.x, y + p.y};}
};
 
using vec1_t = std::vector<int   >;
using vec2_t = std::vector<vec1_t>;
 
std::ostream& operator<<(std::ostream& o, vec2_t m)
{   const auto a = std::to_string(m.size() * m.front().size()).size();
    for     (const auto& r : m)
    {   for (const auto& c : r)
        {   std::cout << std::setw(a) << c << ' ';
        }   std::cout << '\n';
    }       std::cout << '\n';
    return o;
}
 
const Plot P[] =
{   {  1,  0},
    {  0,  1},
    { -1,  0},
    {  0, -1}
};
 
int main()
{
    while(true)
    {
        int R, C; std::cout << "Row, Column: "; std::cin >> R >> C;
 
        auto m = vec2_t(R, vec1_t(C, 0));
 
        auto b = [&](const Plot& p)
        {   return (size_t)p.y < R && (size_t)p.x < C && m[p.y][p.x] == 0;
        };
 
        Plot now{0, 0};
 
        for(int N = C * R + 1, i = 1, j = 0; i < N && b(now); ++i)
        {
            m[now.y][now.x] = i;
            auto      a = now + P[  j%4];
            if(!b(a)) a = now + P[++j%4];
            now = a;
        }
 
        std::system("cls"); std::cout << m;
    }
}