Разбор задачи: Минимальная сумма пути

Предложенный нами код решения:

 def minPathSum(grid):
    """
    Вычисляет минимальную сумму чисел на пути из верхнего левого угла
    в нижний правый угол матрицы, при движении только вправо или вниз.
    :param grid: Двумерный список (матрица) неотрицательных чисел
    :return: Минимальная сумма чисел на пути
    """
    m, n = len(grid), len(grid[0])  # Размеры матрицы

    # Обрабатываем первую строку
    for j in range(1, n):
        grid[0][j] += grid[0][j - 1]

    # Обрабатываем первый столбец
    for i in range(1, m):
        grid[i][0] += grid[i - 1][0]

    # Обрабатываем оставшиеся ячейки
    for i in range(1, m):
        for j in range(1, n):
            grid[i][j] += min(grid[i - 1][j], grid[i][j - 1])

    return grid[m - 1][n - 1]

Шаг 1: Инициализация

m, n = len(grid), len(grid[0])  # Размеры матрицы

• Мы начинаем с того, что получаем размеры матрицы: m — это количество строк, а n — количество столбцов. Эти данные необходимы для дальнейшего построения пути.

Шаг 2: Обработка первой строки

for j in range(1, n):
    grid[0][j] += grid[0][j - 1]

• Первая строка требует особого внимания, так как перемещение может происходить только вправо.
• Для каждой ячейки во второй и следующих ячейках первой строки мы просто прибавляем к текущему значению число из предыдущей ячейки (слева), так как единственный способ попасть в ячейку — двигаться из ячейки слева. Таким образом, мы постепенно накапливаем минимальную сумму для каждой ячейки.

Шаг 3: Обработка первого столбца

for i in range(1, m):
    grid[i][0] += grid[i - 1][0]

• Подобно первой строке, в первом столбце возможен только один вариант движения — вниз.
• Каждую ячейку столбца мы обновляем, прибавляя к ней число из ячейки, находящейся непосредственно выше (севернее). Это позволяет учесть минимальную сумму для движения вниз.

Шаг 4: Обработка всех остальных ячеек

for i in range(1, m):
    for j in range(1, n):
        grid[i][j] += min(grid[i - 1][j], grid[i][j - 1])

• Для всех остальных ячеек в матрице мы принимаем минимальную сумму из двух возможных путей:
  1. Из ячейки выше (grid[i - 1][j]), если мы двигаемся вниз.
  2. Из ячейки слева (grid[i][j - 1]), если мы двигаемся вправо.
• Каждую ячейку матрицы мы обновляем, прибавляя к ней минимальную сумму, которую мы могли бы получить, двигаясь с одного из двух возможных направлений. Этот шаг гарантирует, что на каждом шаге мы выбираем оптимальный путь.

Шаг 5: Возврат результата

return grid[m - 1][n - 1]

• После того как мы обработали все ячейки матрицы, минимальная сумма пути, приводящая к нижнему правому углу, будет храниться в ячейке grid[m - 1][n - 1]. Мы возвращаем это значение как результат.

Пример

Для матрицы:

[[1, 3, 1],
 [1, 5, 1],
 [4, 2, 1]]

1. Первая строка будет обновлена так:

[[1, 4, 5],
 [1, 5, 1],
 [4, 2, 1]]

2. Первый столбец будет обновлен так:

[[1, 4, 5],
 [2, 5, 1],
 [6, 2, 1]]

3. Остальные ячейки будут обновлены следующим образом:

[[1, 4, 5],
 [2, 7, 6],
 [6, 8, 7]]

• Итоговая минимальная сумма пути равна 7.