en tiempo O (n): encuentre el elemento más grande en el conjunto donde la comparación no es transitiva

El título establece la pregunta.

Tenemos como entradas una lista de elementos que podemos comparar (determinar cuál es el mejor ). Ningún elemento puede ser igual.

Puntos clave:

1. La comparación no es transitiva (piense en piedra, papel o tijera): esto puede ser cierto: A> B, B> C, C> A (tenga en cuenta que esto no es una entrada válida ya que no hay una respuesta válida aquí, solo estoy describiendo qué " comparación no transitiva "significa)
2. Se garantiza que cada matriz de entrada tendrá una respuesta
3. mayor significa que el elemento debe ser mayor que cualquier otro elemento
4. La propiedad inversa se mantiene, es decir, A> B implica que B <A

Ejemplo:

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

No puedo encontrar una manera de hacer esto en O (n) tiempo, mi mejor solución es O (n ^ 2).

Me atoro en cada enfoque debido al hecho de que para estar seguro de una respuesta, el elemento necesita ser comparado explícitamente con cualquier otro elemento, para demostrar que es la respuesta (porque la comparación no es transitiva).

Esto descarta el uso de un montón, clasificación, etc.

El algoritmo estándar para encontrar un máximo todavía funciona. Comience con y los elementos, si ve un valor mayor, actualice el máximo para que sea ese valor. La razón por la que esto funciona es que cada elemento que omitió es más pequeño que al menos un elemento y, por lo tanto, no puede ser el máximo.$a_1$

Para ser claros, por "algoritmo estándar" me refiero a lo siguiente:

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

Para completar, discutiré aquí las cuestiones planteadas en los comentarios. La configuración en la discusión anterior es encontrar un máximo relativo a una relación antisimétrica , donde es un máximo si para todo tenemos . El algoritmo anterior funciona bajo el supuesto de que existe un máximo, sin embargo, si esto no se conoce, se puede usar para verificar la existencia de un máximo (verifique si el elemento devuelto es realmente mayor que todos los demás elementos, esto se menciona en el comentario de Chi y en la respuesta de Ilmari Karonen).$<$$a_i$$j\neq i$$a_i>a_j$

Si no es necesariamente antisimétrico, entonces el algoritmo anterior falla (como Emil mencionó en los comentarios). Si es una relación arbitraria (es decir, estamos relajando tanto la transitividad como la antisimetría), entonces no es difícil demostrar que no es posible encontrar un máximo en el tiempo lineal. Denotamos por la cantidad de veces que participó en una consulta, definimos una relación de confrontación de manera que el máximo no se pueda revelar sin suficientes consultas. Dada la consulta , responda si y contrario. Si el número de consultas es$<$$<$$\#a_i$$a_i$$a_i >?a_j$$a_i>a_j$$\# a_i < n-1$$a_i<a_j$$o(n^2)$, aún no se vio un máximo, y se puede configurar para que sea uno de los elementos del conjunto.

Como señala Ariel , el algoritmo estándar de búsqueda máxima que figura a continuación:

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

de hecho funcionará sin modificaciones siempre que:

• se puede comparar cualquier par de elementos, y
• se garantiza que la entrada contiene un elemento máximo, es decir, un elemento que es mayor en pares que cualquier otro elemento en la entrada.

^{(La primera suposición anterior en realidad puede estar relajado, incluso sin tener que modificar el algoritmo, el tiempo que se supone que el elemento de máxima es comparable con cualquier otro elemento y que x > ysiempre es falsa si los elementos xy yson incomparable.)}

En particular, su afirmación de que:

[…] Para estar seguro de una respuesta, el elemento debe compararse explícitamente con cualquier otro elemento (porque la comparación no es transitiva).

no es cierto bajo los supuestos dados anteriormente. De hecho, para demostrar que el algoritmo anterior siempre encontrará el elemento máximo, es suficiente observar que:

1. dado que el ciclo itera sobre todos los elementos de entrada, en alguna iteración xserá el elemento máximo;
2. Como el elemento máximo es por pares mayor que cualquier otro elemento, se deduce que, al final de esa iteración, mserá el elemento máximo; y
3. dado que ningún otro elemento puede ser mayor en pares que el elemento máximo, se deduce que mno cambiará en ninguna de las iteraciones posteriores.

Por lo tanto, al final del ciclo, msiempre será el elemento máximo, si la entrada contiene uno.

PD. Si la entrada no siempre contiene necesariamente un elemento máximo, entonces verificar ese hecho requerirá probar la respuesta del candidato contra cualquier otro elemento para verificar que es realmente máxima. Sin embargo, todavía podemos hacer eso en O ( n ) tiempo después de ejecutar el algoritmo de búsqueda máxima anterior:

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

^{(Asumo aquí que la relación >es irreflexiva, es decir, ningún elemento puede ser mayor que sí mismo. Si ese no es necesariamente el caso, la comparación x > men el paso 2 debería reemplazarse x ≠ m and x > m, donde ≠denota la comparación de identidad. O simplemente podríamos aplicar la optimización anotado abajo.)}

Para probar la exactitud de esta variación del algoritmo, considere los dos casos posibles:

• Si la entrada contiene un elemento máximo, entonces el paso 1 lo encontrará (como se muestra arriba) y el paso 2 lo confirmará.
• Si la entrada no contiene un elemento máximo, entonces el paso 1 terminará eligiendo algún elemento arbitrario como m. No importa qué elemento sea, ya que en cualquier caso no será máximo, y por lo tanto, el paso 2 lo detectará y volverá None.

Si almacenamos el índice de mla matriz de entrada a, que en realidad podría optimizar el paso 2 solamente para comprobar los elementos que vienen antes mde a, ya que todos los elementos posteriores ya se han comparado con men el paso 1. Sin embargo, esta optimización no cambia el tiempo de complejidad asintótica del algoritmo, que sigue siendo O ( n ).

"mayor significa que el elemento debe ser mayor que cualquier otro elemento" es una gran pista sobre cómo hacer esto en .$O(n)$

Si revisa los elementos de comparación de su lista, cualquier elemento que "pierda" una comparación puede descartarse inmediatamente ya que, para ser el más grande, debe ser mayor que TODOS los demás elementos, por lo que la pérdida individual lo descalifica.

$n-1$

Esta solución está habilitada por una sutileza: "Ningún elemento puede ser igual" combinado con el hecho de que siempre habrá un elemento mayor. Si mapeamos las relaciones de victorias como un gráfico dirigido, está claro que podemos alcanzar el elemento más grande simplemente siguiendo las victorias.

Supongo que la relación antisimétrica para al menos un solo elemento (que garantiza la existencia del elemento más grande), de lo contrario, la tarea es imposible. Si todos los elementos en el conjunto finito son comparables, entonces el procedimiento habitual de búsqueda máxima funciona.

Si algunos elementos no son comparables, el siguiente procedimiento funcionará

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$

Espero que esto sea algo comprensible. Siéntase libre de preguntar en comentarios o editar.

La idea básica es que no puede recopilar ninguna información sobre los elementos restantes de los que ya conoce si permite una relación completamente arbitraria.

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

A > B$n$

$O(n)$