def min_moves_to_clean_brute_force(classroom):
    if not classroom or not classroom[0]:
        return 0

    number_of_rows = len(classroom)
    number_of_cols = len(classroom[0])
    memoization_cache = {}

    def is_completely_clean(classroom_state_tuple):
        for row_tuple in classroom_state_tuple:
            if 'D' in row_tuple:
                return False
        return True

    def perform_cleaning_move(classroom_state_tuple, move_row, move_col):
        mutable_grid = [list(row_tuple) for row_tuple in classroom_state_tuple]
        for row_offset in range(2):
            for col_offset in range(2):
                target_row = move_row + row_offset
                target_col = move_col + col_offset
                if 0 <= target_row < number_of_rows and 0 <= target_col < number_of_cols:
                    mutable_grid[target_row][target_col] = 'C'
        return tuple(tuple(row_list) for row_list in mutable_grid)

    def explore_all_move_sequences(current_classroom_state):
        # To avoid re-solving for the same classroom layout, we cache results for states we see.
        if current_classroom_state in memoization_cache:
            return memoization_cache[current_classroom_state]

        # Base case: if the room is clean, a path is complete and requires 0 more moves.
        if is_completely_clean(current_classroom_state):
            return 0
        
        minimum_moves_for_this_path = float('inf')
        
        # This loop tries every possible cleaning move from the current state to explore all paths.
        for row_index in range(number_of_rows):
            for col_index in range(number_of_cols):
                next_classroom_state = perform_cleaning_move(current_classroom_state, row_index, col_index)
                
                # A move must change the classroom state, otherwise we risk infinite recursion on a dead-end.
                if next_classroom_state != current_classroom_state:
                    result_from_next_state = explore_all_move_sequences(next_classroom_state)
                    
                    if result_from_next_state != float('inf'):
                        minimum_moves_for_this_path = min(minimum_moves_for_this_path, 1 + result_from_next_state)

        memoization_cache[current_classroom_state] = minimum_moves_for_this_path
        return minimum_moves_for_this_path

    initial_state_tuple = tuple(tuple(row) for row in classroom)
    final_answer = explore_all_move_sequences(initial_state_tuple)
    
    return final_answer if final_answer != float('inf') else -1

def minimum_moves_to_clean_classroom(messes_per_section):
    number_of_sections = len(messes_per_section)
    if not number_of_sections:
        return 0

    total_messes = sum(messes_per_section)

    # If the total messes cannot be evenly distributed, a balanced state is impossible to achieve.
    if total_messes % number_of_sections != 0:
        return -1

    # Calculate the target number of messes each section must have for the classroom to be 'clean'.
    target_messes_per_section = total_messes // number_of_sections
    total_moves_required = 0

    # The total moves is the sum of all items that must be relocated from over-filled sections.
    for current_section_messes in messes_per_section:
        if current_section_messes > target_messes_per_section:
            total_moves_required += current_section_messes - target_messes_per_section

    return total_moves_required