Рекурсивное заполнение матрицы

Из колледжа интересная но простая задачка. Нужно условно заполнить все ячейки матрицы примерно вот таким образом:

Вроде чего сложного просто стукаешься или ходишь по приоритету нарпавлений. И все отлично если алгортим начинает идти от стенок, но если мы берем центр то все сложнее. Мы можем просто зайти в петлю и ой все так сказать. Что бы это не происходило необходимо делать возврат назад и просто идти в другую сторону. Ну так как программа у нас рекурсивная то и сложность возрастет.

Так как я не нашел аналогов такой задачке то выложу тут мой коДЬ что бы желающий мог понять алгортим (python вроде не осбо сложный для понимания)

import copy
import time
def PA(args): #функция отрисовки матрицы на экран
    if not args:
        return None
    result = ""
    result += "\t" + "\t".join([str(x) for x in range(len(args))]) + "\n" + "\n"
    for i in range(len(args)):
        add = [str(x) for x in args[i]]
        result += str(i) + "\t" + "\t".join(add) + "\n"
    return result

row,col = map(int,input('Ведите размер матрицы:').split())
All = [[0 for row_i in range(row)] for col_i in range(col)]
count = row*col
start_col,start_row = map(int,input('Ведите начальную точку:').split())

def take_direction(All,col,row): #получаем доступные нам направления
    direction_list = {'up': None, 'left': None, 'right': None, 'down': None}
    try: #up
        if row > 0 and All[row-1][col] == 0:
            direction_list['up'] = True
        else:
            direction_list['up'] = False
    except:
        direction_list['up'] = None
    try: #down
        if row < len(All)-1 and All[row+1][col] == 0:
            direction_list['down'] = True
        else:
            direction_list['down'] = False
    except:
        direction_list['down'] = None
    try: #right
        if col < len(All[0])-1 and All[row][col+1] == 0:
            direction_list['right'] = True
        else:
            direction_list['right'] = False
    except:
        direction_list['right'] = None
    try: #left
        if col > 0 and All[row][col-1] == 0:
            direction_list['left'] = True
        else:
            direction_list['left'] = False
    except:
        direction_list['left'] = None
    return direction_list



def rec_function(All,row,col,count,count_end,direction_list=None): #Данный алгоритм можно улучшить если использовать потоки
    save_row,start_col = row,col #сохроняем текущую позицию
    save_count = count #сохроняем текущий счетчик
    All[row][col] = count
    if not direction_list: #Получение данных о том какие направление доступны
        direction_list = take_direction(All,col,row)
    if direction_list.get('up'): #выбор направления в верх
        row-=1
        direction_list.pop('up')
    elif direction_list.get('right'):#выбор направления в право
        col+=1
        direction_list.pop('right')
    elif direction_list.get('down'):#выбор направления в низ
        row+=1
        direction_list.pop('down')
    elif direction_list.get('left'):#выбор направления в лево
        col-=1
        direction_list.pop('left')
    else:
        if count == count_end: #Проверка на окончание сетчика
            return All #Тупика нет мы вернули все
        else:
            return False # мы зашли в тупик!
    count += 1
    data = rec_function(copy.deepcopy(All),row,col,count,count_end)
    if data: # проверка на тупик!
        return data #если тупика нет
    else:
        # вызов с передачей доступных направлений
        # будет увеличивать сложность алгоритма!!!
        return rec_function(copy.deepcopy(All),save_row,start_col,save_count,count_end,direction_list)

start_execution = time.time()
try:
    print(PA(rec_function(All,start_row,start_col,1,count))) #результат
except RecursionError:
    print("Слишком большая сложность. Уменьшите размер матрицы или поменяйте начальную координату")
print(f"Время выполнения: {time.time()-start_execution}")

Ну вроде все подписал и должно работать (надеюсь гугл меня найдет)