โยนคนที่อ้วนที่สุดออกจากเครื่องบินมากเกินไป

สมมติว่าคุณมีเครื่องบินและมีเชื้อเพลิงน้อย เว้นแต่ว่าเครื่องบินจะลดน้ำหนักผู้โดยสารลง 3,000 ปอนด์มันจะไม่สามารถไปถึงสนามบินถัดไปได้ เพื่อช่วยชีวิตคนจำนวนมากที่สุดเราอยากจะโยนคนที่หนักที่สุดออกจากเครื่องบินก่อน

และใช่มีผู้คนนับล้านบนเครื่องบินและเราต้องการอัลกอริธึมที่เหมาะสมที่สุดในการค้นหาผู้โดยสารที่หนักที่สุดโดยไม่จำเป็นต้องเรียงลำดับรายการทั้งหมด

นี่เป็นปัญหาพร็อกซีสำหรับสิ่งที่ฉันพยายามรหัสใน C ++ ฉันต้องการจะทำ "partial_sort" ในรายการผู้โดยสารโดยน้ำหนัก แต่ฉันไม่ทราบว่าฉันต้องการองค์ประกอบกี่ชิ้น ฉันสามารถใช้อัลกอริทึม "partial_sort" ของตัวเอง ("partial_sort_accumulate_until") ได้ แต่ฉันสงสัยว่ามีวิธีที่ง่ายกว่าในการทำสิ่งนี้โดยใช้ STL มาตรฐาน

วิธีหนึ่งคือใช้heap ขั้นต่ำ ( 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 คนน้ำหนักลดลง 3,000 ปอนด์ผู้โดยสารแต่ละคนต้องสูญเสีย (3000/1000000) = 0.003 ปอนด์ต่อคน ที่สามารถทำได้โดยการ jettisoning ทุกคนเสื้อหรือรองเท้าหรือแม้กระทั่งคลิปเล็บมือช่วยทุกคน สิ่งนี้จะถือว่ามีการรวบรวมและโยนทิ้งที่มีประสิทธิภาพก่อนการลดน้ำหนักที่จำเป็นต้องเพิ่มขึ้นเนื่องจากเครื่องบินใช้เชื้อเพลิงมากขึ้น

ที่จริงแล้วพวกเขาไม่อนุญาตให้ใช้กรรไกรตัดเล็บบนกระดานอีกต่อไป

ด้านล่างเป็นการดำเนินการที่ค่อนข้างง่ายของโซลูชันที่ตรงไปตรงมา ฉันไม่คิดว่าจะมีวิธีที่เร็วกว่าที่ถูกต้อง 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 อยู่ในเส้นทางที่ถูกต้อง คุณใช้ quickselect โดยที่ pivots เป็นขีด จำกัด น้ำหนัก แต่ละพาร์ติชันแยกคนหนึ่งชุดออกเป็นชุดและส่งคืนน้ำหนักรวมสำหรับแต่ละชุด คุณยังคงแบ่งกลุ่มที่เหมาะสมต่อไปจนกว่าถังของคุณที่สอดคล้องกับคนที่มีน้ำหนักมากที่สุดคือมากกว่า 3,000 ปอนด์และกลุ่มที่ต่ำที่สุดของคุณที่อยู่ในชุดนั้นมี 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) น่าเสียดายที่ไม่มีการนำ Radix ไปใช้ใน STL แต่เป็นการเขียนที่ตรงไปตรงมา

ทำไมคุณไม่ใช้ quicksort บางส่วนกับกฎการยกเลิกที่แตกต่างจาก "sort" คุณสามารถเรียกใช้แล้วใช้เพียงครึ่งที่สูงกว่าและดำเนินต่อไปจนกว่าน้ำหนักภายในครึ่งที่สูงกว่านี้จะไม่มีน้ำหนักที่ถูกโยนออกไปอีกอย่างน้อยกว่าที่คุณย้อนกลับไปหนึ่งขั้นตอนในการเรียกซ้ำและเรียงลำดับรายการ หลังจากนั้นคุณสามารถเริ่มโยนคนออกจากรายการระดับสูงของรายการที่เรียงลำดับ

จัดเรียงการแข่งขันแบบขนานใหญ่: -

สมมติว่ามีสามที่นั่งมาตรฐานในแต่ละด้านของโรค: -

1. ขอให้ผู้โดยสารในที่นั่งริมหน้าต่างเพื่อเลื่อนไปยังที่นั่งตรงกลางหากพวกเขาหนักกว่าคนที่อยู่ในที่นั่งริมหน้าต่าง

2. ขอให้ผู้โดยสารในที่นั่งตรงกลางเพื่อแลกเปลี่ยนกับผู้โดยสารในที่นั่งทางเดินถ้าพวกเขาหนัก

3. ขอผู้โดยสารในที่นั่งทางเดินซ้ายเพื่อแลกเปลี่ยนกับผู้โดยสารในรหัสที่นั่งทางเดินที่ถูกต้องว่าหนักกว่า

4. Bubble จัดเรียงผู้โดยสารในที่นั่งด้านขวาของทางเดิน (ทำขั้นตอน n ขั้นสำหรับ n แถว) - ถามผู้โดยสารในที่นั่งทางเดินขวาเพื่อแลกเปลี่ยนกับบุคคลที่อยู่ด้านหน้า n -1 ครั้ง

5 เตะพวกเขาออกไปที่ประตูจนกว่าจะถึง 3,000 ปอนด์

3 ขั้นตอน + ขั้นตอนบวก 30 ขั้นตอนหากคุณมีน้ำหนักผู้โดยสารที่ผอมมาก

สำหรับเครื่องบินเดินสองลำ - คำแนะนำนั้นซับซ้อนกว่า แต่ประสิทธิภาพก็ใกล้เคียงกัน

ฉันอาจใช้std::nth_elementเพื่อแยกคนที่มีน้ำหนักมากที่สุด 20 คนออกเป็นเส้นตรง จากนั้นใช้วิธีการที่ซับซ้อนมากขึ้นในการค้นหาและชนจากสวรรค์ที่หนักที่สุด

คุณสามารถผ่านหนึ่งรายการเพื่อรับค่าเฉลี่ยและส่วนเบี่ยงเบนมาตรฐานจากนั้นใช้เพื่อประมาณจำนวนคนที่ต้องไป ใช้ partial_sort เพื่อสร้างรายการตามหมายเลขนั้น หากการเดาต่ำให้ใช้ partial_sort อีกครั้งในส่วนที่เหลือด้วยการเดาใหม่

@James มีคำตอบในความคิดเห็นนี้: std::priority_queueถ้าคุณสามารถใช้ภาชนะใด ๆ หรือการรวมกันของstd::make_heapและstd::pop_heap(และstd::push_heap) std::vectorถ้าคุณต้องการที่จะใช้สิ่งที่ต้องการ

ต่อไปนี้เป็นโซลูชันที่ใช้ฮีปโดยใช้โมดูลในตัวของไพ ธ อน อยู่ใน 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) ซึ่งเป็นเส้นตรงกับจำนวนคน