Разбор задачи: Минимальная стоимость найма K работников

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

 import heapq

def mincostToHireWorkers(quality, wage, K):
        workers, res, heap, sumq = sorted((w / q, q, w) for q, w in zip(quality, wage)), float("inf"), [], 0
        for ratio, q, w in workers:
            heapq.heappush(heap, -q)
            sumq += q
            if len(heap) > K:
                sumq += heapq.heappop(heap)
            if len(heap) == K:
                res = min(res, ratio * sumq)
        return res

Данное решение вычисляет минимальную стоимость найма группы из K работников, соблюдая заданные условия пропорциональной оплаты. Рассмотрим каждый фрагмент кода по порядку.

1. Инициализация данных

workers, res, heap, sumq = sorted((w / q, q, w) for q, w in zip(quality, wage)), float("inf"), [], 0

• Что происходит:
  • Мы сопоставляем каждому работнику отношение wage / quality — это определяет, сколько необходимо платить за единицу качества данного работника.
  • Каждый работник представлен в виде кортежа: (отношение, качество, минимальная зарплата).
  • Работники сортируются по возрастанию отношения, чтобы минимизировать итоговую стоимость группы.
  • Инициализируются:
    • res — переменная для хранения минимальной стоимости найма (начальное значение "бесконечность"),
    • heap — список, который будет использоваться как куча для хранения качеств работников,
    • sumq — сумма качеств работников в текущей группе.

Пример:

quality = [10, 20, 5]
wage = [70, 50, 30]

После сортировки:

workers = [(2.5, 20, 50), (6.0, 5, 30), (7.0, 10, 70)]

2. Проход по списку работников

for ratio, q, w in workers:

• Что происходит:
  • Цикл перебирает всех работников по их отношению wage / quality.
  • Для каждого работника извлекаются:
    • ratio — отношение минимальной зарплаты к качеству,
    • q — качество работника,
    • w — минимальная зарплата.

3. Добавление работника в текущую группу

heapq.heappush(heap, -q)
sumq += q

• Что происходит:
  • Качество текущего работника добавляется в кучу heap (с отрицательным знаком, чтобы создать max-кучу).
  • Сумма качеств sumq увеличивается на качество текущего работника.

Пример: После добавления второго работника (6.0, 5, 30):

• heap = [-20, -5],
• sumq = 25.

4. Удаление лишних работников

if len(heap) > K:
    sumq += heapq.heappop(heap)

• Что происходит:
  • Если количество работников в текущей группе больше K, удаляется работник с наибольшим качеством (так как в max-куче это минимальное отрицательное значение).
  • Из суммы качеств sumq вычитается качество удалённого работника.

Пример: Если K = 2, после добавления третьего работника (7.0, 10, 70):

• heap = [-10, -5] (работник с качеством 20 удалён),
• sumq = 15.

5. Вычисление стоимости группы

if len(heap) == K:
    res = min(res, ratio * sumq)

• Что происходит:
  • Если группа содержит ровно K работников, вычисляется стоимость найма:
    • Стоимость = ratio * sumq, где:
      • ratio — отношение минимальной зарплаты к качеству текущего работника,
      • sumq — сумма качеств всех работников в группе.
  • Переменная res обновляется, если найденная стоимость меньше текущей минимальной.

Пример: Для группы из двух работников:

• ratio = 7.0,
• sumq = 15,
• Стоимость = 7.0 * 15 = 105.

6. Возврат результата

return res

• Что происходит:
  • Возвращается минимальная стоимость найма группы из K работников.

Пример работы кода

Входные данные:

quality = [10, 20, 5]
wage = [70, 50, 30]
K = 2

Этапы выполнения:

1. Создание и сортировка списка работников:

   workers = [(2.5, 20, 50), (6.0, 5, 30), (7.0, 10, 70)]
   

2. Итерирование:
   • Первый работник (2.5, 20, 50):
     • heap = [-20],
     • sumq = 20.
   • Второй работник (6.0, 5, 30):
     • heap = [-20, -5],
     • sumq = 25.
     • Группа из 2 работников, стоимость = 6.0 * 25 = 150.
   • Третий работник (7.0, 10, 70):
     • Добавляем работника:
       • heap = [-10, -5, -20],
       • sumq = 35.
     • Удаляем лишнего:
       • heap = [-10, -5],
       • sumq = 15.
     • Группа из 2 работников, стоимость = 7.0 * 15 = 105.
3. Возврат результата:
   • Минимальная стоимость = 105.