за время 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).

Я зацикливаюсь на каждом подходе из-за того факта, что для уверенности в ответе элемент необходимо явно сравнить с любым другим элементом, чтобы доказать, что это действительно ответ (потому что сравнение не транзитивно).

Это исключает использование кучи, сортировки и т. Д.

Стандартный алгоритм поиска максимума все еще работает. Начните с и перейти на элементы, если вы видите , большее значение, обновить максимум , чтобы быть этим значением. Это работает потому, что каждый пропущенный элемент меньше, чем хотя бы один элемент, и поэтому не может быть максимальным.$a_1$

Чтобы быть понятным, под «стандартным алгоритмом» я имею в виду следующее:

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

Для полноты, я буду обсуждать здесь вопросы, поднятые в комментариях. Настройка в приведенном выше обсуждении заключается в нахождении максимума относительно антисимметричного отношения , где a i является максимумом, если для всех j ≠ i мы имеем a i > a j . Вышеприведенный алгоритм работает в предположении, что максимум существует, однако, если он не известен, его можно использовать для проверки существования максимума (проверьте, действительно ли возвращаемый элемент больше, чем все другие элементы, это упоминается в комментарии Чи а в илмари каронен отвечу).$<$$a_i$$j\neq i$$a_i>a_j$

Если не обязательно антисимметрично, то вышеприведенный алгоритм не работает (как Эмиль упоминал в комментариях). Если < произвольное соотношение (т.е. мы ослабляем как транзитивность, так и антисимметрию), то нетрудно показать, что нахождение максимума за линейное время невозможно. Обозначим # a i, сколько раз a i участвовал в запросе, мы определяем состязательное отношение таким образом, что максимум не может быть выявлен без достаточного количества запросов. Учитывая запрос а я > ? a j , ответьте a i > a j, если # a $<$$<$$\#a_i$$a_i$$a_i >?a_j$$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

фактически будет работать без изменений, пока:

• любую пару элементов можно сравнить, и
• вход гарантированно содержит максимальный элемент, то есть элемент, попарно превышающий любой другой элемент на входе.

^{(Первое предположение выше может быть фактически ослаблено, даже без необходимости изменять алгоритм, если мы предполагаем, что максимальный элемент сопоставим с любым другим элементом, и это x > yвсегда ложно, если элементы xи yнесопоставимы.)}

В частности, вы утверждаете, что:

[…] Чтобы быть уверенным в ответе, этот элемент необходимо явно сравнивать с любым другим элементом (поскольку сравнение не является транзитивным).

неверно в предположениях, приведенных выше. Фактически, чтобы доказать, что приведенный выше алгоритм всегда найдет максимальный элемент, достаточно заметить, что:

1. поскольку цикл перебирает все входные элементы, на некоторой итерации xбудет максимальный элемент;
2. поскольку максимальный элемент попарно больше, чем любой другой элемент, из этого следует, что в конце этой итерации 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

^{(Здесь я предполагаю, что отношение >нерефлексивно, то есть ни один элемент не может быть больше самого себя. Если это не обязательно так, сравнение 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$

Это решение обеспечивается тонкостью: «Ни один элемент не может быть равным» в сочетании с тем фактом, что всегда будет самый большой элемент. Если мы отобразим отношения выигрышей в виде ориентированного графа, ясно, что мы можем достичь наибольшего элемента, просто следуя победам.

Я предполагаю, что отношение антисимметрично хотя бы для одного элемента (что гарантирует существование наибольшего элемента), в противном случае задача невозможна. Если все элементы в конечном множестве сравнимы, то работает обычная процедура нахождения максимума.

Если некоторые элементы не сопоставимы, то будет работать следующая процедура

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$$a < m$$a$$m$$m<a$$a$$m$$a$$m$

$A<B$$B<A$

$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$$i_j$

Надеюсь, это несколько понятно. Не стесняйтесь спрашивать в комментариях или редактировать.

Основная идея заключается в том, что вы не можете собрать какую-либо информацию об оставшихся элементах из уже известных вам, если разрешите совершенно произвольное отношение.

$A<A$$n$$n^2-n$

A > B$n$

$O(n)$