def cut_off_trees_for_golf_event_brute_force(forest):
    number_of_rows = len(forest)
    number_of_columns = len(forest[0])

    trees_to_cut = []
    for row_index in range(number_of_rows):
        for column_index in range(number_of_columns):
            tree_height = forest[row_index][column_index]
            if tree_height > 1:
                trees_to_cut.append((tree_height, row_index, column_index))

    trees_to_cut.sort()

    def calculate_manhattan_distance(start_row, start_column, end_row, end_column):
        return abs(start_row - end_row) + abs(start_column - end_column)

    import itertools

    shortest_distance = float('inf')
    
    # Try all permutations of tree cutting orders.
    for permutation in itertools.permutations(trees_to_cut):
        current_row = 0
        current_column = 0
        total_distance_for_permutation = 0
        
        # Sum up distance between each tree.
        for tree_height, next_row, next_column in permutation:
            distance = calculate_manhattan_distance(current_row, current_column, next_row, next_column)
            total_distance_for_permutation += distance
            current_row = next_row
            current_column = next_column

        # Keep track of the smallest total distance seen
        shortest_distance = min(shortest_distance, total_distance_for_permutation)

    if shortest_distance == float('inf'):
        return -1
    else:
        return shortest_distance

from collections import deque

def cut_off_trees(forest):
    tree_locations = []
    rows = len(forest)
    cols = len(forest[0])

    for row in range(rows):
        for col in range(cols):
            height = forest[row][col]
            if height > 1:
                tree_locations.append((height, row, col))

    tree_locations.sort()

    start_row, start_col = 0, 0
    total_steps = 0

    for height, target_row, target_col in tree_locations:
        steps = find_shortest_path(forest, start_row, start_col, target_row, target_col)

        if steps == -1:
            return -1

        total_steps += steps
        start_row, start_col = target_row, target_col
        forest[target_row][target_col] = 1

    return total_steps

def find_shortest_path(forest, start_row, start_col, target_row, target_col):
    rows = len(forest)
    cols = len(forest[0])
    queue = deque([(start_row, start_col, 0)])
    visited = set()
    visited.add((start_row, start_col))

    # Define possible movement directions: up, down, left, right
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]

    while queue:
        current_row, current_col, steps = queue.popleft()

        if current_row == target_row and current_col == target_col:
            return steps

        for delta_row, delta_col in directions:
            new_row = current_row + delta_row
            new_col = current_col + delta_col

            # Check boundary conditions and if cell is traversable
            if 0 <= new_row < rows and 0 <= new_col < cols and \
               forest[new_row][new_col] > 0 and (new_row, new_col) not in visited:

                queue.append((new_row, new_col, steps + 1))
                visited.add((new_row, new_col))

    # If no path is found return -1
    return -1