trong thời gian O (n): Tìm phần tử lớn nhất trong tập hợp so sánh không mang tính bắc cầu

Tiêu đề nêu câu hỏi.

Chúng tôi có đầu vào như một danh sách các yếu tố, mà chúng tôi có thể so sánh (xác định cái nào là lớn nhất ). Không có yếu tố nào có thể bằng nhau.

Những điểm chính:

1. So sánh không mang tính bắc cầu (nghĩ rằng kéo giấy đá): điều này có thể đúng: A> B, B> C, C> A (lưu ý đây không phải là đầu vào hợp lệ vì không có câu trả lời hợp lệ ở đây, tôi chỉ mô tả những gì " so sánh không bắc cầu "có nghĩa là)
2. Mỗi mảng đầu vào sẽ được đảm bảo có câu trả lời
3. lớn nhất có nghĩa là phần tử phải lớn hơn mọi phần tử khác
4. Thuộc tính converse giữ tức là A> B ngụ ý rằng B <A

Thí dụ:

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

Tôi không thể tìm ra cách để làm điều này trong thời gian O (n), giải pháp tốt nhất của tôi là O (n ^ 2).

Tôi bị mắc kẹt trên mọi phương pháp vì thực tế là để chắc chắn có câu trả lời, yếu tố này cần được so sánh rõ ràng với mọi yếu tố khác, để chứng minh đó thực sự là câu trả lời (vì so sánh không mang tính bắc cầu).

Điều này quy định việc sử dụng một đống, sắp xếp, vv

Thuật toán tiêu chuẩn để tìm tối đa vẫn hoạt động. Bắt đầu với và đi qua các yếu tố, nếu bạn thấy một giá trị lớn hơn, cập nhật tối đa là giá trị đó. Lý do điều này hoạt động là mọi yếu tố bạn bỏ qua nhỏ hơn ít nhất một yếu tố và do đó không thể là tối đa.$a_1$

Để rõ ràng, theo "thuật toán tiêu chuẩn", ý tôi là như sau:

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

Để đầy đủ, tôi sẽ thảo luận ở đây các vấn đề được nêu trong các ý kiến. Các thiết lập trong các cuộc thảo luận ở trên là tìm một người họ hàng tối đa cho một mối quan hệ đối xứng chống , nơi một i là tối đa nếu cho tất cả j ≠ i chúng tôi có một i > một j . Thuật toán trên hoạt động theo giả định rằng tồn tại tối đa, tuy nhiên nếu không biết điều này, người ta có thể sử dụng nó để xác minh sự tồn tại của mức tối đa (kiểm tra xem phần tử được trả về có thực sự lớn hơn tất cả các phần tử khác hay không, điều này được đề cập trong nhận xét của Chi và trong câu trả lời của Ilmari Karonen).$<$$a_i$$j\neq i$$a_i>a_j$

Nếu không nhất thiết là đối xứng, thì thuật toán trên không thành công (như Emil đã đề cập trong các bình luận). Nếu < là một mối quan hệ tùy ý (nghĩa là chúng ta đang thư giãn cả tính đối xứng và tính đối xứng), thì không khó để chỉ ra rằng việc tìm kiếm tối đa trong thời gian tuyến tính là không thể. Biểu thị bằng # một i số lần một tôi tham gia vào một truy vấn, chúng tôi xác định một mối quan hệ thù địch trong một cách mà tối đa không thể tiết lộ mà không đủ các truy vấn. Căn cứ vào truy vấn một i > ? a j , trả lời a i > a j nếu # a $<$$<$$\#a_i$$a_i$$a_i >?a_j$$a_i>a_j$ và a i < a j nếu không. Nếu số lượng truy vấn là o ( n 2 ) , thì mức tối đa chưa được nhìn thấy và nó có thể được đặt thành một trong các thành phần trong tập hợp.$\# a_i < n-1$$a_i<a_j$$o(n^2)$

Như Ariel lưu ý , thuật toán tìm tối đa tiêu chuẩn được đưa ra dưới đây:

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

trong thực tế sẽ làm việc mà không sửa đổi miễn là:

• bất kỳ cặp yếu tố nào cũng có thể được so sánh, và
• đầu vào được đảm bảo chứa một phần tử tối đa, tức là một phần tử lớn hơn từng cặp so với bất kỳ phần tử nào khác trong đầu vào.

^{(Giả định đầu tiên ở trên thực sự có thể được nới lỏng, thậm chí không cần phải sửa đổi thuật toán, miễn là chúng tôi giả định rằng phần tử tối đa có thể so sánh với mọi phần tử khác và x > yluôn luôn sai nếu các phần tử xvà ykhông thể so sánh được.)}

Cụ thể, yêu cầu của bạn rằng:

[Chắc chắn] để chắc chắn về một câu trả lời, yếu tố này cần được so sánh rõ ràng với mọi yếu tố khác (vì so sánh không mang tính bắc cầu).

là không đúng theo các giả định được đưa ra ở trên. Trong thực tế, để chứng minh rằng thuật toán ở trên sẽ luôn tìm thấy phần tử tối đa, đủ để quan sát rằng:

1. vì vòng lặp lặp trên tất cả các phần tử đầu vào, tại một số lần lặp xsẽ là phần tử tối đa;
2. vì phần tử cực đại lớn hơn từng cặp so với mọi phần tử khác, nên theo sau, ở phần lặp đó, msẽ là phần tử cực đại; và
3. vì không có phần tử nào khác có thể được ghép đôi lớn hơn phần tử cực đại, nên phần tử theo sau msẽ không thay đổi trên bất kỳ lần lặp tiếp theo nào.

Do đó, ở cuối vòng lặp, msẽ luôn là phần tử tối đa, nếu đầu vào chứa một.

Thi thiên Nếu đầu vào không nhất thiết phải luôn chứa một phần tử tối đa, thì việc xác minh thực tế đó thực sự sẽ yêu cầu kiểm tra câu trả lời của ứng viên đối với mọi yếu tố khác để xác minh rằng nó thực sự là tối đa. Tuy nhiên, chúng ta vẫn có thể làm điều đó trong thời gian O ( n ) sau khi chạy thuật toán tìm tối đa ở trê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

^{(Tôi giả sử ở đây rằng mối quan hệ >là không phản xạ, tức là không có yếu tố nào có thể lớn hơn chính nó. Nếu không nhất thiết phải như vậy, thì nên so sánh x > mở bước 2 x ≠ m and x > m, trong đó ≠biểu thị so sánh nhận dạng. Hoặc chúng ta có thể áp dụng tối ưu hóa lưu ý dưới đây.)}

Để chứng minh tính đúng đắn của biến thể thuật toán này, hãy xem xét hai trường hợp có thể xảy ra:

• Nếu đầu vào chứa một phần tử tối đa, thì bước 1 sẽ tìm thấy nó (như được hiển thị ở trên) và bước 2 sẽ xác nhận nó.
• Nếu đầu vào không chứa phần tử tối đa, thì bước 1 sẽ chọn một số phần tử tùy ý là m. Không quan trọng đó là yếu tố nào, vì trong mọi trường hợp, nó sẽ không tối đa, và do đó bước 2 sẽ phát hiện ra và trả về None.

Nếu chúng ta lưu trữ các chỉ số mtrong mảng đầu vào a, chúng ta có thể thực sự bước tối ưu hóa 2 để chỉ kiểm tra những yếu tố mà đến trước mtrong a, vì bất kỳ yếu tố sau đã được so sánh với mở bước 1. Nhưng tối ưu hóa này không làm thay đổi mức độ phức tạp thời gian tiệm cận của thuật toán, vẫn là O ( n ).

$O(n)$

Nếu bạn xem qua danh sách so sánh các yếu tố của mình, bất kỳ yếu tố nào "mất" so sánh có thể bị loại bỏ ngay lập tức vì để trở thành lớn nhất, nó phải lớn hơn TẤT CẢ các yếu tố khác để mất một lần loại bỏ nó.

$n-1$ sự so sánh và kết thúc với những yếu tố lớn nhất là kết quả của sự so sánh cuối cùng của bạn, bằng cách loại bỏ một kẻ thất bại mỗi và mọi lúc.

Giải pháp này được kích hoạt bởi một sự tinh tế: "Không có yếu tố nào có thể bằng" kết hợp với thực tế là sẽ luôn có một yếu tố lớn nhất. Nếu chúng ta lập bản đồ chiến thắng các mối quan hệ dưới dạng biểu đồ có hướng, rõ ràng chúng ta có thể đạt được yếu tố lớn nhất chỉ bằng cách theo dõi các chiến thắng.

Tôi giả định rằng mối quan hệ đối xứng cho ít nhất một yếu tố duy nhất (đảm bảo sự tồn tại của yếu tố lớn nhất), nếu không thì nhiệm vụ là không thể. Nếu tất cả các phần tử trong tập hữu hạn có thể so sánh được thì quy trình tìm tối đa thông thường sẽ hoạt động.

Nếu một số yếu tố không thể so sánh thì quy trình sau sẽ hoạt động.

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$

Ban đầu. tối đa
$i=1:$ $\max = A$
$i=2:$ $\max = A$ (kể từ khi $A > B$)
$i=3:$ $\max = C$ (kể từ khi $A < C$)
$i=4:$ $\max = D$ (since $D > C$)

This algorithm works since if $m>a$ (or $a < m$) for all $a$ then $m$ is the greatest. If $m<a$ for some element $a$ then $m$ cannot be the greatest. Similarly, if $a$ and $m$ are not comparable then they both cannot be the greatest. This procedure would work even if all elements are comparable.

As an addition to Ariel's answer about the concerns raised by Emil Jeřábek: If we allow $A<B$ and $B<A$ then there is no O(n) algorithm:

Assume you have elements $A_1 ... A_n$. Your algorithm will in each step query $A_i<A_j$ for some pair i and j. No matter in which order you query them, there is always a relation where you have to query all relations before finding the maximum. The reason for this is best described by assuming you have an adversary who can change the problem while your algorithm is running.

(Note that the argument is independent of what the algorithm actually does with the information he gets about the elements, since it explains that he cannot know that an element is maximal before making $n^2$ queries.)

For most of the algorithm the adversary will make sure to always return true for $A_i<A_j$ until your last query for a given $j$. Note that you cannot know that one given element is maximal until you compared it to all other elements. Only for the last element for which you finish all relations the adversary will return true for the last element as well.

The resulting relation will always be such that there is some $j_0$ for which $A_i < A_{j_0}\forall i$ and for all other $j$ there will be some $i_j$ such that $A_i<A_j \forall i\neq i_j$ and we will not have $A_{i_j} < A_j$. The adversary chooses $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)$