def minimize_rounding_error_brute_force(prices, target):    minimum_error = float('inf')
    number_of_prices = len(prices)
    # Iterate through all possible rounding combinations.
    for i in range(2 ** number_of_prices):
        current_sum = 0.0
        current_error = 0.0
        rounded_numbers = []
        # Determine rounding for each price.
        for price_index in range(number_of_prices):
            if (i >> price_index) & 1:
                rounded_price = int(prices[price_index]) + 1
                current_error += abs(prices[price_index] - rounded_price)
                current_sum += rounded_price
                rounded_numbers.append(rounded_price)
            else:
                rounded_price = int(prices[price_index])
                current_error += abs(prices[price_index] - rounded_price)
                current_sum += rounded_price
                rounded_numbers.append(rounded_price)
        # Check if the rounded sum matches the target.
        if abs(current_sum - target) < 1e-6:
            # Update minimum error if necessary. 
            minimum_error = min(minimum_error, current_error)
    # Prevent returning infinity if no valid combination exists
    if minimum_error == float('inf'):
        return -1.0
    else:
        return minimum_error

def minimize_error(numbers, target):
    total_down = 0
    fractional_parts = []

    for number in numbers:
        down = int(number)
        total_down += down
        fractional_part = number - down
        fractional_parts.append(fractional_part)

    # Calculate how many numbers need rounding up.
    up_count = target - total_down

    if up_count < 0 or up_count > len(numbers):
        return "-1"

    # Sort by fractional part to minimize error.
    sorted_indices = sorted(range(len(numbers)), key=lambda i: fractional_parts[i], reverse=True)

    total_error = 0.0

    # Round numbers based on sorted indices.
    for i in range(len(numbers)):
        if i < up_count:
            # Round up numbers with the largest fractional parts first.
            total_error += (1 - fractional_parts[sorted_indices[i]])

        else:
            # Round down the remaining numbers.
            total_error += fractional_parts[sorted_indices[i]]

    return "{:.3f}".format(total_error)