en temps O (n): trouver le plus grand élément de l'ensemble où la comparaison n'est pas transitive

Le titre pose la question.

Nous avons en entrée une liste d'éléments que nous pouvons comparer (déterminer lequel est le plus grand ). Aucun élément ne peut être égal.

Points clés:

1. La comparaison n'est pas transitive (pensez aux ciseaux de papier de roche): cela peut être vrai: A> B, B> C, C> A (notez que ce n'est pas une entrée valide car il n'y a pas de réponse valide ici, je ne fais que décrire ce que " comparaison non transitive "signifie)
2. Chaque tableau d'entrée sera garanti d'avoir une réponse
3. le plus grand signifie que l'élément doit être supérieur à tout autre élément
4. La propriété inverse tient à dire A> B implique que B <A

Exemple:

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

Je ne peux pas trouver un moyen de le faire en temps O (n), ma meilleure solution est O (n ^ 2).

Je suis bloqué sur chaque approche car pour être sûr d'une réponse, l'élément doit être explicitement comparé à tous les autres éléments, pour prouver qu'il s'agit bien de la réponse (car la comparaison n'est pas transitive).

Cela exclut l'utilisation d'un tas, le tri, etc.

L'algorithme standard pour trouver un maximum fonctionne toujours. Commencez par et passez en revue les éléments, si vous voyez une valeur plus grande, mettez à jour le maximum pour être cette valeur. La raison pour laquelle cela fonctionne est que chaque élément que vous avez ignoré est plus petit qu'au moins un élément et ne peut donc pas être le maximum.$a_1$

Pour être clair, par «algorithme standard», je veux dire ce qui suit:

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

Pour être complet, je vais discuter ici des questions soulevées dans les commentaires. Le paramètre de la discussion ci-dessus consiste à trouver un maximum par rapport à une relation antisymétrique , où a i est un maximum si pour tout j ≠ i nous avons a i > a j . L'algorithme ci-dessus fonctionne en supposant qu'un maximum existe, mais si cela n'est pas connu, on peut l'utiliser pour vérifier l'existence d'un maximum (vérifier si l'élément retourné est en effet supérieur à tous les autres éléments, cela est mentionné dans le commentaire de Chi et dans la réponse d'Ilmari Karonen).$<$$a_i$$j\neq i$$a_i>a_j$

Si n'est pas nécessairement anti symétrique, alors l'algorithme ci-dessus échoue (comme Emil l'a mentionné dans les commentaires). Si < est une relation arbitraire (c'est-à-dire que nous assouplissons à la fois la transitivité et l'anti-symétrie), il n'est pas difficile de montrer qu'il n'est pas possible de trouver un maximum en temps linéaire. On note # un i le nombre de fois un i participé à une requête, nous définissons une relation contradictoire d'une manière que le maximum ne peut être révélé sans suffisamment de requêtes. Étant donné la requête a i > ? a j , répondez a i > a j si # a $<$$<$$\#a_i$$a_i$$a_i >?a_j$$a_i>a_j$ et a i < a j sinon. Si le nombre de requêtes est o ( n 2 ) , alors un maximum n'a pas encore été vu, et il peut être défini pour être l'un des éléments de l'ensemble.$\# a_i < n-1$$a_i<a_j$$o(n^2)$

Comme le note Ariel , l'algorithme de recherche de maximum standard donné ci-dessous:

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

fonctionnera en fait sans modification tant que:

• n'importe quelle paire d'éléments peut être comparée, et
• l'entrée est garantie pour contenir un élément maximal, c'est-à-dire un élément qui est par paire plus grand que tout autre élément dans l'entrée.

^{(La première hypothèse ci-dessus peut en fait être assouplie, même sans avoir à modifier l'algorithme, tant que nous supposons que l'élément maximal est comparable à tous les autres éléments et cela x > yest toujours faux si les éléments xet ysont incomparables.)}

En particulier, vous affirmez que:

[…] Pour être certain d'une réponse, l'élément doit être explicitement comparé à tous les autres éléments (car la comparaison n'est pas transitive).

n'est pas vrai dans les hypothèses données ci-dessus. En fait, pour prouver que l'algorithme ci-dessus trouvera toujours l'élément maximal, il suffit de constater que:

1. puisque la boucle itère sur tous les éléments d'entrée, à une certaine itération xsera l'élément maximal;
2. puisque l'élément maximal est deux par deux plus grand que tout autre élément, il s'ensuit qu'à la fin de cette itération, mil sera l'élément maximal; et
3. Puisqu'aucun autre élément ne peut être deux par deux plus grand que l'élément maximal, il s'ensuit que mcela ne changera sur aucune des itérations suivantes.

Par conséquent, à la fin de la boucle, msera toujours l'élément maximal, si l'entrée en contient un.

Ps. Si l'entrée ne contient pas nécessairement toujours un élément maximal, la vérification de ce fait nécessitera en effet de tester la réponse candidate par rapport à tous les autres éléments pour vérifier qu'elle est vraiment maximale. Cependant, nous pouvons toujours le faire en temps O ( n ) après avoir exécuté l'algorithme de recherche de maximum ci-dessus:

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

^{(Je suppose ici que la relation >est irréflexive, c'est-à-dire qu'aucun élément ne peut être supérieur à lui-même. Si ce n'est pas nécessairement le cas, la comparaison x > mde l'étape 2 devrait être remplacée par x ≠ m and x > m, où ≠dénote une comparaison d'identité. Ou nous pourrions simplement appliquer l'optimisation noté ci-dessous.)}

Pour prouver l'exactitude de cette variation de l'algorithme, considérons les deux cas possibles:

• Si l'entrée contient un élément maximal, alors l'étape 1 le trouvera (comme indiqué ci-dessus) et l'étape 2 le confirmera.
• Si l'entrée ne contient pas d'élément maximal, alors l'étape 1 finira par choisir un élément arbitraire comme m. Peu importe de quel élément il s'agit, car il sera en tout cas non maximal, et donc l'étape 2 le détectera et le retournera None.

Si nous stockons l'indice mdans le tableau d'entrée a, on pourrait en fait pas optimize 2 pour vérifier que les éléments qui viennent avant mdans a, puisque les éléments ultérieurs ont déjà été comparé à l' métape 1. Mais cette optimisation ne change pas la complexité du temps asymptotique de l'algorithme, qui est toujours O ( n ).

«le plus grand signifie que l'élément doit être plus grand que tous les autres éléments» est une énorme indication sur la façon de procéder dans .$O(n)$

Si vous parcourez votre liste en comparant des éléments, tout élément qui "perd" une comparaison peut être immédiatement éliminé car, pour être le plus grand, il doit être supérieur à TOUS les autres éléments afin que la perte unique le disqualifie.

$n-1$

Cette solution est rendue possible par une subtilité: "Aucun élément ne peut être égal" combiné avec le fait qu'il y aura toujours un plus grand élément. Si nous cartographions les relations de victoires sous forme de graphique dirigé, il est clair que nous pouvons atteindre le plus grand élément simplement en suivant les victoires.

Je suppose que la relation antisymétrique pour au moins un élément unique (qui garantit l'existence du plus grand élément), sinon la tâche est impossible. Si tous les éléments de l'ensemble fini sont comparables, la procédure de recherche de maximum habituelle fonctionne.

Si certains éléments ne sont pas comparables, la procédure suivante fonctionnera

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$

En complément de $A<B$$B<A$

$A_1 ... A_n$$A_i<A_j$

$n^2$

Pour la plupart de l'algorithme, l'adversaire s'assurera de toujours retourner vrai pour $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$

J'espère que c'est quelque peu compréhensible. N'hésitez pas à demander dans les commentaires ou à modifier.

L'idée de base est que vous ne pouvez pas collecter d'informations sur les éléments restants à partir de ceux que vous connaissez déjà si vous autorisez une relation complètement arbitraire.

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

A > B$n$

$O(n)$