Викидання найпотужніших людей з перевантаженого літака.

Скажімо, у вас літак, і він мало пального. Якщо літак не скине 3000 фунтів ваги пасажирів, він не зможе дістатися до наступного аеропорту. Щоб врятувати максимальну кількість життів, ми хотіли б спочатку скинути найважчих людей із літака.

І о так, у літаку мільйони людей, і ми хотіли б оптимального алгоритму пошуку найважчих пасажирів, не обов'язково сортуючи весь список.

Це проблема проксі-сервера для чогось, що я намагаюся кодувати в C ++. Я хотів би зробити "частковий_сорт" на пасажирському маніфесті за вагою, але я не знаю, скільки елементів мені потрібно. Я міг би реалізувати свій власний алгоритм "частковий_ортаж" ("частковий_сорт_акумулювання_утиліти"), але мені цікаво, чи є простіший спосіб зробити це за допомогою стандартної STL.

Одним із способів було б використання мінімальної купи ( std::priority_queueв C ++). Ось як би ви це зробили, якщо припустити, що у вас був MinHeapклас. (Так, мій приклад є в C #. Я думаю, ви зрозуміли, що ви розумієте.)

int targetTotal = 3000;
int totalWeight = 0;
// this creates an empty heap!
var myHeap = new MinHeap<Passenger>(/* need comparer here to order by weight */);
foreach (var pass in passengers)
{
    if (totalWeight < targetTotal)
    {
        // unconditionally add this passenger
        myHeap.Add(pass);
        totalWeight += pass.Weight;
    }
    else if (pass.Weight > myHeap.Peek().Weight)
    {
        // If this passenger is heavier than the lightest
        // passenger already on the heap,
        // then remove the lightest passenger and add this one
        var oldPass = myHeap.RemoveFirst();
        totalWeight -= oldPass.Weight;
        myHeap.Add(pass);
        totalWeight += pass.Weight;
    }
}

// At this point, the heaviest people are on the heap,
// but there might be too many of them.
// Remove the lighter people until we have the minimum necessary
while ((totalWeight - myHeap.Peek().Weight) > targetTotal)
{
    var oldPass = myHeap.RemoveFirst();
    totalWeight -= oldPass.Weight; 
}
// The heap now contains the passengers who will be thrown overboard.

Відповідно до стандартних посилань, час роботи повинен бути пропорційним n log k, де nкількість пасажирів та kмаксимальна кількість предметів у купі. Якщо припустити, що вага пасажирів, як правило, становить 100 фунтів або більше, то навряд чи купа буде містити більше 30 предметів у будь-який час.

Найгірший випадок, якщо пасажири будуть представлені в порядку від найменшої ваги до найвищої. Це вимагає, щоб кожен пасажир був доданий до купи, а кожен пасажир був видалений з купи. Тим не менше, з мільйонам пасажирів і припускаючи, що найлегший важить 100 фунтів, n log kпрацює на розумно невелику кількість.

Якщо ви отримуєте ваги пасажирів випадковим чином, продуктивність значно краща. Я використовую щось подібне для двигуна рекомендацій (я вибираю 200 найпопулярніших елементів зі списку з декількох мільйонів). Я, як правило, лише 50 000 або 70 000 предметів, фактично доданих до купи.

Я підозрюю, що ви побачите щось досить схоже: більшість ваших кандидатів будуть відхилені, оскільки вони легші, ніж найлегша людина, яка вже знаходиться в купі. І Peekце O(1)операція.

Для отримання додаткової інформації про ефективність вибору купи та швидкого вибору див. Статтю Коли теорія відповідає практиці . Коротка версія: якщо ви вибираєте менше 1% від загальної кількості предметів, то вибір купи - це явний переможець за швидкий вибір. Більше 1%, тоді використовуйте швидкий вибір або такий варіант, як Introselect .

Однак це не допоможе для вашої проблеми з проксі-сервером:

Щоб 1 000 000 пасажирів скинули вагу 3000 фунтів, кожен пасажир повинен втратити (3000/1000000) = 0,003 фунта на людину. Цього можна було досягти шляхом вибивання кожної сорочки чи взуття, або, мабуть, навіть вирізання нігтів, врятуючи всіх. Це передбачає ефективний збір та вимивання до того, як необхідне зниження ваги зросло, оскільки літак використовував більше палива.

Насправді вони більше не дозволяють стрибати нігті на ногах на борту, тож це не вдається.

Нижче наведено досить просту реалізацію прямого рішення. Я не думаю, що існує більш швидкий спосіб, який є на 100% правильним.

size_t total = 0;
std::set<passenger> dead;
for ( auto p : passengers ) {
    if (dead.empty()) {
       dead.insert(p);
       total += p.weight;
       continue;
    }
    if (total < threshold || p.weight > dead.begin()->weight)
    {
        dead.insert(p);
        total += p.weight;
        while (total > threshold)
        {
            if (total - dead.begin()->weight < threshold)
                break;
            total -= dead.begin()->weight;
            dead.erase(dead.begin());
        }
    }
 }

Це спрацьовує, заповнивши набір "мертвих людей", поки він не досягне порогу. Після того, як поріг буде досягнуто, ми продовжуємо переглядати список пасажирів, які намагаються знайти тих, хто важчий за найлегшого загиблого. Коли ми знайшли його, ми додаємо їх до списку, а потім починаємо "Збереження" найлегших людей зі списку, поки ми не зможемо зберегти більше.

У гіршому випадку це буде приблизно таким же, як і всьому списку. Але в кращому випадку ("список мертвих" заповнений належним чином першими X людьми) він виконає O(n).

Припускаючи, що всі пасажири будуть співпрацювати: Використовуйте паралельну мережу сортування . (див. також це )

Ось жива демонстрація

Оновлення: альтернативне відео (перейти до 1:00)

Попросити пар людей порівняти-обмінятися - ви не можете отримати швидше за це.

@Blastfurnace був на правильному шляху. Ви користуєтесь швидким вибором, де повороти - вагові пороги. Кожна секція розбиває один набір людей на набори і повертає загальну вагу для кожного набору людей. Ви продовжуєте розбивати відповідне відро до тих пір, поки ваші відра, що відповідають людям з найвищою вагою, не перевищують 3000 фунтів, а у вашому найнижчому відрі, що знаходиться в цьому комплекті, є 1 особа (тобто вона більше не може бути розділена.)

Цей алгоритм лінійно амортизований, але найгірший квадратичний. Я думаю, що це єдиний лінійний алгоритм часу .

Ось рішення Python, яке ілюструє цей алгоритм:

#!/usr/bin/env python
import math
import numpy as np
import random

OVERWEIGHT = 3000.0
in_trouble = [math.floor(x * 10) / 10
              for x in np.random.standard_gamma(16.0, 100) * 8.0]
dead = []
spared = []

dead_weight = 0.0

while in_trouble:
    m = np.median(list(set(random.sample(in_trouble, min(len(in_trouble), 5)))))
    print("Partitioning with pivot:", m)
    lighter_partition = []
    heavier_partition = []
    heavier_partition_weight = 0.0
    in_trouble_is_indivisible = True
    for p in in_trouble:
        if p < m:
            lighter_partition.append(p)
        else:
            heavier_partition.append(p)
            heavier_partition_weight += p
        if p != m:
            in_trouble_is_indivisible = False
    if heavier_partition_weight + dead_weight >= OVERWEIGHT and not in_trouble_is_indivisible:
        spared += lighter_partition
        in_trouble = heavier_partition
    else:
        dead += heavier_partition
        dead_weight += heavier_partition_weight
        in_trouble = lighter_partition

print("weight of dead people: {}; spared people: {}".format(
    dead_weight, sum(spared)))
print("Dead: ", dead)
print("Spared: ", spared)

Вихід:

Partitioning with pivot: 121.2
Partitioning with pivot: 158.9
Partitioning with pivot: 168.8
Partitioning with pivot: 161.5
Partitioning with pivot: 159.7
Partitioning with pivot: 158.9
weight of dead people: 3051.7; spared people: 9551.7
Dead:  [179.1, 182.5, 179.2, 171.6, 169.9, 179.9, 168.8, 172.2, 169.9, 179.6, 164.4, 164.8, 161.5, 163.1, 165.7, 160.9, 159.7, 158.9]
Spared:  [82.2, 91.9, 94.7, 116.5, 108.2, 78.9, 83.1, 114.6, 87.7, 103.0, 106.0, 102.3, 104.9, 117.0, 96.7, 109.2, 98.0, 108.4, 99.0, 96.8, 90.7, 79.4, 101.7, 119.3, 87.2, 114.7, 90.0, 84.7, 83.5, 84.7, 111.0, 118.1, 112.1, 92.5, 100.9, 114.1, 114.7, 114.1, 113.7, 99.4, 79.3, 100.1, 82.6, 108.9, 103.5, 89.5, 121.8, 156.1, 121.4, 130.3, 157.4, 138.9, 143.0, 145.1, 125.1, 138.5, 143.8, 146.8, 140.1, 136.9, 123.1, 140.2, 153.6, 138.6, 146.5, 143.6, 130.8, 155.7, 128.9, 143.8, 124.0, 134.0, 145.0, 136.0, 121.2, 133.4, 144.0, 126.3, 127.0, 148.3, 144.9, 128.1]

Якщо припустити, що, як і ваги людей, ви маєте гарне уявлення про те, які максимальні та мінімальні значення, ймовірно, використовуватимуть за допомогою радикального сортування для їх сортування в O (n). Тоді просто працюйте від найважчого кінця списку до найлегшого. Загальний час роботи: O (n). На жаль, в STL не існує реалізації свого типу radix, але це досить просто.

Чому б вам не скористатись частковим кваксортом із іншим правилом переривання, ніж "відсортовано". Ви можете запустити його, а потім використовувати лише верхню половину і продовжувати, поки вага всередині цієї вищої половини не містить ваги, яку потрібно принаймні викинути більше, ніж ви повернетесь на один крок у рекурсії та сортуєте список. Після цього ви можете почати викидати людей з найвищого кінця цього відсортованого списку.

Масово-паралельний турнір Сортування: -

Якщо припустити стандартні три місця з боків від ailse: -

1. Попросіть пасажирів на віконному сидінні перейти на середнє сидіння, якщо вони важчі, ніж людина на сидінні на вікні.

2. Попросіть пасажирів на середньому сидінні помінятися з пасажиром на сидінні на проході, якщо вони важчі.

3. Попросіть пасажира на сидінні в лівому проході помінятись на пасажира на правому сидінні проходу, він важчий.

4. Бульбашка сортує пасажирів на правому сидінні проходу. (Робить n кроків для n рядків). - попросіть пасажирів, які перебувають на правильному сидінні проходу, обмінятись з людиною перед n -1 разів.

5 Вибивайте їх із дверей, поки не досягнете 3000 фунтів.

3 кроки + n кроків плюс 30 кроків, якщо у вас дійсно худий пасажирський вантаж.

Для площини з двома проходами - інструкції складніші, але продуктивність приблизно однакова.

Можливо, я б скористався std::nth_elementподілом 20 найважчих людей за лінійний час. Тоді скористайтеся більш складним методом, щоб знайти і відбити найважчу з важких областей.

Ви можете зробити один прохід над списком, щоб отримати середнє та стандартне відхилення, а потім скористатися цим, щоб визначити кількість людей, які повинні пройти. Використовуйте частину_орти для створення списку на основі цього числа. Якщо здогад був низьким, знову використовуйте частину_sort з новою здогадкою.

@James має відповідь у коментарях: a std::priority_queueякщо ви можете використовувати будь-який контейнер, або комбінацію std::make_heapта std::pop_heap(і std::push_heap), якщо ви хочете використовувати щось на зразок a std::vector.

Ось рішення на основі купи за допомогою вбудованого модуля heapq Python. Це в Python, тому не відповідає на початкове запитання, але воно чистіше (IMHO), ніж інше розміщене рішення Python.

import itertools, heapq

# Test data
from collections import namedtuple

Passenger = namedtuple("Passenger", "name seat weight")

passengers = [Passenger(*p) for p in (
    ("Alpha", "1A", 200),
    ("Bravo", "2B", 800),
    ("Charlie", "3C", 400),
    ("Delta", "4A", 300),
    ("Echo", "5B", 100),
    ("Foxtrot", "6F", 100),
    ("Golf", "7E", 200),
    ("Hotel", "8D", 250),
    ("India", "8D", 250),
    ("Juliet", "9D", 450),
    ("Kilo", "10D", 125),
    ("Lima", "11E", 110),
    )]

# Find the heaviest passengers, so long as their
# total weight does not exceeed 3000

to_toss = []
total_weight = 0.0

for passenger in passengers:
    weight = passenger.weight
    total_weight += weight
    heapq.heappush(to_toss, (weight, passenger))

    while total_weight - to_toss[0][0] >= 3000:
        weight, repreived_passenger = heapq.heappop(to_toss)
        total_weight -= weight


if total_weight < 3000:
    # Not enough people!
    raise Exception("We're all going to die!")

# List the ones to toss. (Order doesn't matter.)

print "We can get rid of", total_weight, "pounds"
for weight, passenger in to_toss:
    print "Toss {p.name!r} in seat {p.seat} (weighs {p.weight} pounds)".format(p=passenger)

Якщо k = кількість пасажирів, які кидають, і N = кількість пасажирів, то найкращим випадком для цього алгоритму є O (N), а найгірший для цього алгоритму - Nlog (N). Найгірший випадок трапляється, якщо k тривалий час знаходиться поблизу N. Ось приклад найгіршого акторського складу:

weights = [2500] + [1/(2**n+0.0) for n in range(100000)] + [3000]

Однак у цьому випадку (викидання людей з літака (парашутом, я припускаю)) тоді k повинно бути менше 3000, що становить << "мільйони людей". Отже, середня тривалість виконання повинна становити приблизно Nlog (k), що є лінійним щодо кількості людей.