ในเวลา O (n): ค้นหาองค์ประกอบที่ยิ่งใหญ่ที่สุดในชุดซึ่งการเปรียบเทียบไม่ได้ผ่านการถ่ายทอด

หัวข้อระบุคำถาม

เรามีรายการองค์ประกอบที่เราสามารถเปรียบเทียบได้ (พิจารณาว่าอะไรคือสิ่งที่ยิ่งใหญ่ที่สุด ) องค์ประกอบไม่สามารถเท่ากับ

ประเด็นสำคัญ:

1. การเปรียบเทียบไม่ใช่การถ่ายทอด (คิดว่ากรรไกรกระดาษหิน): สิ่งนี้เป็นจริง: A> B, B> C, C> A (โปรดทราบว่านี่ไม่ใช่การป้อนข้อมูลที่ถูกต้องเนื่องจากไม่มีคำตอบที่ถูกต้องที่นี่ฉันแค่อธิบายว่า " การเปรียบเทียบที่ไม่เกี่ยวกับสกรรมกริยา "หมายถึง)
2. แต่ละอาร์เรย์อินพุตจะรับประกันว่าจะมีคำตอบ
3. ยิ่งใหญ่ที่สุดหมายถึงองค์ประกอบจะต้องมากกว่าองค์ประกอบอื่น ๆ
4. คุณสมบัติการสนทนาถือเช่น A> B หมายความว่า B <A

ตัวอย่าง:

Input: [A,B,C,D]
A > B, B > C, C > A
D > A, D > B, D > C
Output: D

ฉันไม่สามารถหาวิธีที่จะทำสิ่งนี้ได้ในเวลา O (n) ทางออกที่ดีที่สุดของฉันคือ O (n ^ 2)

ฉันติดอยู่กับทุกวิธีเพราะความจริงที่ว่าเพื่อให้แน่ใจว่าคำตอบองค์ประกอบจะต้องมีการเปรียบเทียบอย่างชัดเจนกับองค์ประกอบอื่น ๆ ทุกอย่างเพื่อพิสูจน์ว่ามันเป็นคำตอบแน่นอน (เพราะการเปรียบเทียบไม่ใช่สกรรมกริยา)

กฎนี้ใช้งานฮีปการเรียงลำดับเป็นต้น

อัลกอริทึมมาตรฐานสำหรับการค้นหาสูงสุดยังคงทำงาน เริ่มต้นด้วย1และไปกว่าองค์ประกอบถ้าคุณเห็นค่าขนาดใหญ่ปรับปรุงสูงสุดที่จะเป็นค่าที่ เหตุผลที่ใช้งานได้คือองค์ประกอบทุกอย่างที่คุณข้ามไปมีขนาดเล็กกว่าอย่างน้อยหนึ่งองค์ประกอบและอาจไม่ใช่ค่าสูงสุด$a_1$

เพื่อให้ชัดเจนโดย "อัลกอริธึมมาตรฐาน" ฉันหมายถึงสิ่งต่อไปนี้:

max <- a_1
for i=2 to n
   if a_i > max
      max <- a_i
output max

เพื่อความสมบูรณ์ฉันจะพูดถึงที่นี่ปัญหาที่เกิดขึ้นในความคิดเห็น การตั้งค่าในการอภิปรายดังกล่าวข้างต้นคือการหาญาติสูงสุดให้กับความสัมพันธ์สมมาตรต่อต้านที่ฉันเป็นสูงสุดถ้าสำหรับทุกJ ≠ ฉันเรามีฉัน >เจ อัลกอริทึมด้านบนทำงานภายใต้สมมติฐานว่ามีค่าสูงสุดอยู่อย่างไรก็ตามถ้าไม่ทราบเราสามารถใช้มันเพื่อตรวจสอบการมีอยู่ของค่าสูงสุด (ตรวจสอบว่าองค์ประกอบที่คืนมานั้นมีค่ามากกว่าองค์ประกอบอื่น ๆ ทั้งหมดหรือไม่ และในคำตอบของ Ilmari Karonen)$<$$a_i$$j\neq i$$a_i>a_j$

หากไม่จำเป็นต้องต่อต้านสมมาตรดังนั้นอัลกอริทึมด้านบนจึงล้มเหลว (ดังที่ Emil ได้กล่าวไว้ในความคิดเห็น) หาก<เป็นความสัมพันธ์โดยพลการ (เช่นเราผ่อนคลายทั้งความไวและความต้านทานต่อสมมาตร) ดังนั้นจึงไม่ยากที่จะแสดงว่าการหาค่าสูงสุดในเวลาเชิงเส้นเป็นไปไม่ได้ แสดงเป็นจำนวน# ฉันเป็นจำนวนครั้งที่ฉันเข้าร่วมในแบบสอบถามเรากำหนดความสัมพันธ์ของฝ่ายตรงข้ามในลักษณะที่จำนวนสูงสุดไม่สามารถเปิดเผยได้หากไม่มีข้อความค้นหาเพียงพอ ได้รับแบบสอบถามฉัน > ? Jตอบฉัน > Jถ้า# $<$$<$$\#a_i$$a_i$$a_i >?a_j$$a_i>a_j$และฉัน < เจมิฉะนั้น หากจำนวนการสืบค้นคือ o ( n 2 )จะยังไม่เห็นจำนวนสูงสุดและสามารถตั้งค่าให้เป็นองค์ประกอบอย่างใดอย่างหนึ่งในชุด$\# a_i < n-1$$a_i<a_j$$o(n^2)$

ในฐานะที่เป็นเอเรียลบันทึกอัลกอริทึมการค้นหาสูงสุดมาตรฐานที่ระบุด้านล่าง:

def find_maximum(a):
    m = a[0]
    for x in a:
        if x > m: m = x
    return m

จะใช้งานได้จริงโดยไม่มีการดัดแปลงตราบใดที่:

• องค์ประกอบใด ๆ ที่สามารถเปรียบเทียบและ
• อินพุตรับประกันว่าจะมีองค์ประกอบสูงสุดคือองค์ประกอบที่เป็น pairwise มากกว่าองค์ประกอบอื่น ๆ ในอินพุต

^{(ข้อสันนิษฐานแรกข้างต้นสามารถผ่อนคลายได้จริงโดยไม่ต้องปรับเปลี่ยนอัลกอริทึมตราบใดที่เราสันนิษฐานว่าองค์ประกอบสูงสุดเทียบได้กับองค์ประกอบอื่น ๆ และx > yเป็นเท็จเสมอถ้าองค์ประกอบxและyหาที่เปรียบมิได้)}

โดยเฉพาะอย่างยิ่งการอ้างสิทธิ์ของคุณที่:

[…] เพื่อให้แน่ใจในคำตอบองค์ประกอบจะต้องมีการเปรียบเทียบอย่างชัดเจนกับองค์ประกอบอื่น ๆ ทั้งหมด (เนื่องจากการเปรียบเทียบไม่ใช่สกรรมกริยา)

ไม่เป็นจริงภายใต้สมมติฐานที่ให้ไว้ข้างต้น ในความเป็นจริงเพื่อพิสูจน์ว่าอัลกอริทึมด้านบนจะค้นหาองค์ประกอบสูงสุดเสมอก็เพียงพอที่จะสังเกตว่า:

1. เนื่องจากการวนซ้ำวนซ้ำทุกองค์ประกอบอินพุตที่การวนซ้ำบางรายการxจะเป็นองค์ประกอบสูงสุด
2. เนื่องจากองค์ประกอบสูงสุดเป็น pairwise มากกว่าองค์ประกอบอื่น ๆ ทุกอย่างมันจึงตามมาว่าในตอนท้ายของการทำซ้ำนั้นmจะเป็นองค์ประกอบสูงสุด และ
3. เนื่องจากไม่มีองค์ประกอบอื่นใดสามารถจับคู่ได้มากกว่าองค์ประกอบสูงสุดมันจึงตามมาซึ่งmจะไม่เปลี่ยนแปลงในการวนซ้ำใด ๆ ที่ตามมา

ดังนั้นในตอนท้ายของลูปmจะเป็นองค์ประกอบสูงสุดเสมอหากอินพุตมีหนึ่งรายการ

ps หากการป้อนข้อมูลไม่จำเป็นต้องมีองค์ประกอบสูงสุดเสมอการยืนยันความจริงที่ว่าจะต้องมีการทดสอบคำตอบที่ผู้สมัครกับทุกองค์ประกอบอื่น ๆ เพื่อตรวจสอบว่ามันเป็นจริงสูงสุด อย่างไรก็ตามเรายังคงสามารถทำได้ในเวลา O ( n ) หลังจากเรียกใช้อัลกอริทึมการค้นหาสูงสุดด้านบน:

def find_maximum_if_any(a):
    # step 1: find the maximum, if one exists
    m = a[0]
    for x in a:
        if x > m: m = x

    # step 2: verify that the element we found is indeed maximal
    for x in a:
        if x > m: return None  # the input contains no maximal element
    return m  # yes, m is a maximal element

^{(ฉันสมมติว่านี่>คือความสัมพันธ์แบบirreflexive นั่นคือไม่มีองค์ประกอบใดสามารถยิ่งใหญ่กว่าตัวเองได้หากไม่จำเป็นต้องเป็นกรณีนี้การเปรียบเทียบx > mในขั้นตอนที่ 2 ควรถูกแทนที่ด้วยx ≠ m and x > mโดยที่จะเป็นการ≠เปรียบเทียบตัวตนหรือเราอาจใช้การเพิ่มประสิทธิภาพ ระบุไว้ด้านล่าง.)}

เพื่อพิสูจน์ความถูกต้องของอัลกอริทึมการเปลี่ยนแปลงนี้ให้พิจารณาสองกรณีที่เป็นไปได้:

• หากอินพุตมีองค์ประกอบสูงสุดแล้วขั้นตอนที่ 1 จะค้นหา (ดังแสดงด้านบน) และขั้นตอนที่ 2 จะยืนยัน
• ถ้าใส่ไม่ได้มีองค์ประกอบสูงสุดแล้วขั้นตอนที่ 1 mจะจบลงหยิบบางองค์ประกอบโดยพลการเป็น มันไม่สำคัญซึ่งองค์ประกอบมันเป็นเพราะมันจะในกรณีใด ๆ จะไม่ใช่สูงสุดและดังนั้นขั้นตอนที่ 2 Noneจะตรวจสอบว่าและผลตอบแทน

ถ้าเราเก็บไว้ในดัชนีของmในอาร์เรย์การป้อนข้อมูลที่aเราสามารถทำได้จริงขั้นตอนการเพิ่มประสิทธิภาพที่ 2 เพื่อตรวจสอบองค์ประกอบเฉพาะผู้ที่มาก่อนmในaตั้งแต่องค์ประกอบใด ๆ ในภายหลังได้รับแล้วเมื่อเทียบกับmในขั้นตอนที่ 1 แต่เพิ่มประสิทธิภาพนี้ไม่ได้เปลี่ยนความซับซ้อนเชิงเวลา ของอัลกอริทึมซึ่งยังคงเป็น O ( n )

$O(n)$

หากคุณผ่านรายการการเปรียบเทียบองค์ประกอบองค์ประกอบใด ๆ ที่ "สูญเสีย" การเปรียบเทียบสามารถถูกยกเลิกได้ทันทีเพื่อให้เป็นสิ่งที่ยิ่งใหญ่ที่สุดมันจะต้องมากกว่าองค์ประกอบอื่น ๆ ทั้งหมดดังนั้นการสูญเสียครั้งเดียวจะทำให้ขาดคุณสมบัติ

$n-1$

โซลูชันนี้เปิดใช้งานโดยความละเอียดอ่อน: "ไม่มีองค์ประกอบใดที่สามารถเท่าเทียมกัน" รวมกับความจริงที่ว่าจะมีองค์ประกอบที่ยิ่งใหญ่ที่สุดเสมอ ถ้าเราแมปชนะความสัมพันธ์เป็นกราฟกำกับมันชัดเจนว่าเราสามารถเข้าถึงองค์ประกอบที่ยิ่งใหญ่ที่สุดเพียงแค่ทำตามการชนะ

ฉันคิดว่าความสัมพันธ์ antisymmetric อย่างน้อยหนึ่งองค์ประกอบ (ซึ่งรับประกันการมีอยู่ขององค์ประกอบที่ยิ่งใหญ่ที่สุด) มิฉะนั้นงานเป็นไปไม่ได้ หากองค์ประกอบทั้งหมดในชุด จำกัด มีการเปรียบเทียบแล้วขั้นตอนการหาค่าสูงสุดตามปกติจะใช้งานได้

หากองค์ประกอบบางอย่างไม่สามารถเปรียบเทียบกันได้กระบวนการต่อไปนี้จะใช้งานได้

max = nil
For i=1 to n
   if max is nil then
      max = a[i]
   if max and a[i] are not comparable then
      max = nil
   else if max < a[i] then
      max = a[i]
End

$A,B,C,D$

$i=1:$ $\max = A$
$i=2:$ $\max = A$$A > B$
$i=3:$ $\max = C$$A < C$
$i=4:$ $\max = D$ (ตั้งแต่ $D > C$)

อัลกอริทึมนี้ใช้งานได้ตั้งแต่ถ้า $m>a$ (or $a < m$) สำหรับทุกอย่าง $a$ แล้วก็ $m$เป็นสิ่งที่ยิ่งใหญ่ที่สุด ถ้า$m<a$ สำหรับองค์ประกอบบางอย่าง $a$ แล้วก็ $m$ไม่สามารถยิ่งใหญ่ที่สุด ในทำนองเดียวกันถ้า$a$ และ $m$ไม่เปรียบเทียบกันแล้วพวกเขาทั้งสองไม่สามารถยิ่งใหญ่ที่สุด ขั้นตอนนี้จะใช้งานได้แม้ว่าองค์ประกอบทั้งหมดจะเปรียบเทียบกัน

นอกเหนือจากคำตอบของ Arielเกี่ยวกับข้อกังวลของเอมิลJeřábek : ถ้าเราอนุญาต$A<B$ และ $B<A$ ดังนั้นจึงไม่มีอัลกอริทึม O (n):

สมมติว่าคุณมีองค์ประกอบ $A_1 ... A_n$. อัลกอริทึมของคุณจะอยู่ในแบบสอบถามแต่ละขั้น$A_i<A_j$สำหรับบางคู่ฉันและเจ ไม่ว่าจะเรียงตามลำดับที่คุณค้นหาพวกเขาจะมีความสัมพันธ์ที่คุณต้องค้นหาความสัมพันธ์ทั้งหมดก่อนที่จะหาค่าสูงสุด เหตุผลนี้อธิบายได้ดีที่สุดโดยสมมติว่าคุณมีคู่ต่อสู้ที่สามารถเปลี่ยนปัญหาได้ในขณะที่อัลกอริทึมของคุณกำลังทำงานอยู่

(โปรดทราบว่าข้อโต้แย้งนั้นขึ้นอยู่กับสิ่งที่อัลกอริทึมทำจริงกับข้อมูลที่เขาได้รับเกี่ยวกับองค์ประกอบเนื่องจากมันอธิบายว่าเขาไม่สามารถรู้ได้ว่าองค์ประกอบนั้นเป็นค่าสูงสุดก่อนที่จะสร้าง $n^2$ คำสั่ง.)

สำหรับอัลกอริทึมส่วนใหญ่ฝ่ายตรงข้ามจะทำให้แน่ใจว่าจะได้ผลตอบแทนจริง $A_i<A_j$ จนกว่าจะมีการสอบถามครั้งสุดท้ายสำหรับ $j$. โปรดทราบว่าคุณไม่สามารถรู้ได้ว่าองค์ประกอบที่ให้มานั้นมีค่าสูงสุดจนกระทั่งคุณเปรียบเทียบกับองค์ประกอบอื่น ๆ ทั้งหมด เฉพาะกับองค์ประกอบสุดท้ายที่คุณจบความสัมพันธ์ทั้งหมดฝ่ายตรงข้ามจะกลับมาเป็นจริงสำหรับองค์ประกอบสุดท้ายเช่นกัน

ความสัมพันธ์ที่เกิดขึ้นจะเป็นเช่นนั้นเสมอ $j_0$ ซึ่ง $A_i < A_{j_0}\forall i$ และอื่น ๆ ทั้งหมด $j$ จะมีบ้าง $i_j$ ดังนั้น $A_i<A_j \forall i\neq i_j$ และเราจะไม่มี $A_{i_j} < A_j$. ฝ่ายตรงข้ามเลือก$j_0$ and the $i_j$s depending on your algorithm.

I hope this is somewhat understandable. Feel free to ask in comments or edit.

The basic idea is that you cannot gather any information about the remaining elements from the ones you already know if you allow a completely arbitrary relation.

The argument still works if we disallow $A<A$. We will only save $n$ queries that way and still need $n^2-n$.

I'm going to cheat and call the number of A > B entries $n$ and you need to look at every entry at least once.

That way you can loop over just the entries and remove the element that is less than the other from the set of possible solutions. With a hashset or similar this is possible in $O(n)$