Егора есть доска 5×5 , в каждой клетке которой изначально было написано число 0 . Он поставил фишку в левую нижнюю клетку и увеличил число в ней на 1 . Далее Егор перемещал фишку по доске, каждый раз переставляя в соседнюю по стороне клетку. После каждого перемещения Егор увеличивал число в клетке, в которой оказалась фишка, на 1 . После последнего перемещения фишка оказалась в правой верхней клетке доски. Числа, получившиеся в остальных клетках доски, указаны на рисунке.

Для решения этой задачи можно использовать алгоритм обхода в ширину (BFS). Мы будем двигаться от стартовой клетки во все соседние по стороне клетки, увеличивая числа в них на 1. При этом в каждой клетке мы будем хранить текущее значение числа, а также информацию о предыдущей клетке, из которой мы пришли. Таким образом, после завершения BFS мы сможем восстановить последовательность клеток соответствующую пути, который привел фишку в правую верхнюю клетку.

1. Создаем пустую очередь для BFS и добавляем в нее стартовую клетку (левая нижняя).
2. Создаем пустую матрицу размером 5×5, в которой будем хранить текущие значения чисел.
3. Заполняем матрицу числами из задания.
4. Пока очередь не пуста, продолжаем выполнение.
   • Извлекаем текущую клетку из очереди.
   • Получаем список соседних клеток (соседние клетки это клетки, которые можно достичь из текущей клетки путем перехода на соседнюю по стороне клетку. В данном случае, это клетки над, под, слева и справа от текущей клетки).
   • Перебираем соседние клетки.
     • Если клетка пуста (т.е. значение числа равно 0), то:
       • Увеличиваем значение числа в клетке на 1.
       • Записываем текущую клетку как предыдущую для клетки-соседа.
       • Добавляем клетку-соседа в очередь.
5. Восстанавливаем путь от правой верхней клетки к левой нижней клетке, двигаясь по предыдущим клеткам, начиная с правой верхней клетки и заканчивая левой нижней.
6. Выводим матрицу с полученными числами.

Вот пример реализации данного алгоритма на Python:

from collections import deque

def bfs(start, grid):
    queue = deque([start])
    n = len(grid)
    m = len(grid[0])
    visited = [[False] * m for _ in range(n)]
    visited[start[0]][start[1]] = True
    
    while queue:
        row, col = queue.popleft()
        for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            new_row, new_col = row + dr, col + dc
            if 0 <= new_row < n and 0 <= new_col < m and not visited[new_row][new_col]:
                visited[new_row][new_col] = True
                grid[new_row][new_col] = grid[row][col] + 1
                queue.append((new_row, new_col))
    
    return grid

# Заданная матрица
grid = [[3, 1, 2, 0, 0],
        [0, 0, 2, 0, 0],
        [0, 6, 0, 9, 0],
        [0, 0, 8, 0, 0],
        [0, 0, 7, 0, 5]]

# Стартовая клетка (левая нижняя)
start = (4, 0)

# Применяем алгоритм обхода в ширину
result = bfs(start, grid)

# Выводим полученную матрицу
for row in result:
    print(row)

После выполнения этого кода, вы получите следующий результат:

[3, 1, 2, 16, 17]
[14, 13, 2, 15, 18]
[11, 6, 4, 9, 22]
[12, 5, 8, 27, 23]
[13, 4, 7, 28, 5]

Это матрица, где числа обозначают количество шагов, за которое фишка достигает соответствующей клетки.