Algorithme de temps linéaire déterministe pour vérifier si un tableau est une version triée de l'autre

Considérez le problème suivant:

Entrée: deux tableaux et de longueur , où est trié.$A$$B$$n$$B$

Question: ne et contiennent les mêmes éléments (avec leur multiplicité)?$A$$B$

Quel est l' algorithme déterministe le plus rapide pour ce problème?
Peut-il être résolu plus rapidement que de les trier? Ce problème peut-il être résolu en temps linéaire déterministe?

Vous n'avez pas spécifié votre modèle de calcul, je vais donc supposer le modèle de comparaison.

Considérez le cas particulier dans lequel le tableau est extrait de la liste En mots, le ème élément est soit soit .{ 1 , 2 } × { 3 , 4 } × ⋯ × { 2 n - 1 , 2 n } . i 2 i - 1 2 $B$

$$\{1,2\} \times \{3,4\} \times \cdots \times \{2n-1,2n\}.$$ $i$$2i-1$$2i$

Je revendique que si l'algorithme conclut que et contiennent les mêmes éléments que l'algorithme a par rapport à chaque élément à son homologue . En effet, supposons que l'algorithme conclut que et contiennent les mêmes éléments, mais compare jamais le premier élément de à son homologue . Si nous commutons le premier élément, l'algorithme procéderait exactement de la même manière, même si la réponse est différente. Cela montre que l'algorithme doit comparer le premier élément (et tout autre élément) à son homologue .B B A A B B A $A$$B$$B$$A$$A$$B$$B$$A$$A$

Cela signifie que si et contiennent les mêmes éléments, puis après avoir vérifié ce l'algorithme connaît l'ordre de tri de . Il doit donc avoir au moinsdifférentes feuilles, et cela prend donc du temps .B A n ! Ω ( n log n $A$$B$$A$$n!$$\Omega(n\log n)$

Cette réponse considère un modèle de calcul différent: le modèle RAM à coût unitaire. Dans ce modèle, les mots machine ont la taille et les opérations sur eux prennent . Nous supposons également par souci de simplicité que chaque élément du tableau tient dans un seul mot machine (et est donc au plus en magnitude).O ( 1 ) n O ( 1 $O(\log n)$$O(1)$$n^{O(1)}$

Nous allons construire un algorithme aléatoire temporel linéaire avec une erreur unilatérale (l'algorithme peut déclarer que les deux tableaux contiennent les mêmes éléments même si ce n'est pas le cas) pour le problème plus difficile de déterminer si deux tableaux et contiennent les mêmes éléments. (Nous n'avons besoin d'aucun d'entre eux pour être triés.) Notre algorithme fera une erreur avec une probabilité au plus .b 1 , … , b n 1 /$a_1,\ldots,a_n$$b_1,\ldots,b_n$$1/n$

L'idée est que l'identité suivante est valable si les tableaux contiennent les mêmes éléments: Le calcul exact de ces polynômes prendra trop de temps. Au lieu de cela, nous choisissons un nombre premier aléatoire et un aléatoire et testons si Si les tableaux sont égaux, le test réussira toujours, alors concentrons-nous sur les cas où les tableaux sont différents. En particulier, un certain coefficient de est non nul. Puisque ont une magnitude , ce coefficient a une magnitudepx0 n ∏ i = 1 (x0-ai)≡ n ∏ i = 1 (x0-bi

$$\prod_{i=1}^n (x-a_i) = \prod_{i=1}^n (x-b_i).$$ $p$$x_0$ $$\prod_{i=1}^n (x_0-a_i) \equiv \prod_{i=1}^n (x_0-b_i) \pmod{p}.$$ $\prod_{i=1}^n (x-a_i) - \prod_{i=1}^n (x-b_i)$$a_i,b_i$$n^{O(1)}$$2^n n^{O(n)} = n^{O(n)}$, et donc il a au plus facteurs premiers de taille . Cela signifie que si nous choisissons un ensemble d'au moins nombres premiers de taille au moins (disons), alors pour un nombre premier aléatoire de cet ensemble, il tiendra avec probabilité au moins que Un modulo aléatoire en sera témoin avec une probabilité de (puisqu'un polynôme de degré au plus a au plus racines).$O(n)$$\Omega(n)$$n^2$$p$$n^2$$p$$1-1/n$ $$\prod_{i=1}^n (x-a_i) - \prod_{i=1}^n (x-b_i) \not\equiv 0 \pmod{p}.$$ $x_0$$p$$1-n/p \geq 1-1/n$$n$$n$

En conclusion, si nous choisissons un aléatoire de taille à peu près parmi un ensemble d'au moins nombres premiers différents, et un modulo aléatoire , alors lorsque les tableaux ne contiennent pas les mêmes éléments, notre test échouera avec probabilité . L'exécution du test prend du temps car s'inscrit dans un nombre constant de mots machine.$p$$n^2$$n^2$$x_0$$p$$1-O(1/n)$$O(n)$$p$

En utilisant le test de primalité temporelle polynomiale et comme la densité des nombres premiers de taille à peu près est , nous pouvons choisir un nombre premier aléatoire dans le temps . Le choix d'un modulo aléatoire peut être implémenté de différentes manières, et est facilité car dans notre cas, nous n'avons pas besoin d'un aléatoire complètement uniforme .$n^2$$\Omega(1/\log n)$$p$$(\log n)^{O(1)}$$x_0$$p$$x_0$

En conclusion, notre algorithme s'exécute dans le temps , génère toujours OUI si les tableaux contiennent les mêmes éléments et génère NON avec la probabilité si les tableaux ne contiennent pas les mêmes éléments. On peut améliorer la probabilité d'erreur de pour toute constante .$O(n)$$1-O(1/n)$$1-O(1/n^C)$$C$

je proposerai un autre algorithme (ou au moins un schéma d'un tel algorithme)

Le schéma suppose que les valeurs (supposées " entiers ") se situent dans une plage (étroite?) Entre$[min,max]$

1. En temps balayant les deux tableaux, nous pouvons trouver les valeurs et pour les deux et leur multiplicité, si elles diffèrent, les tableaux ne sont pas des permutations l'un de l'autre$O(n)$minmax

2. Soustrayez les minde toutes les valeurs des deux tableaux (ici le fait qu'un tableau est déjà dans l'ordre trié n'est pas pris en compte, cela peut probablement être amélioré)

3. Supposons que les valeurs dans les tableaux représentent des masses et nous appliquons une accélération / vitesse à chacune de magnitude (cela peut être amélioré à une magnitude de dans certains cas)c > $1$$c > 1$

4. déplacer les masses jusqu'à ce qu'elles atteignent la valeur maximale max-min, cela a une complexité de . Cela permet de retrouver à la fois les mêmes valeurs et leur multiplicité, si celles-ci diffèrent, les tableaux ne sont pas des permutations les uns des autres. Sinon, les tableaux sont des permutations les uns des autres.$O((max-min)n)$

notez que le schéma d'algorithme ci-dessus peut être (déterministe) assez rapide dans de nombreuses situations pratiques.

Le schéma d'algorithme ci-dessus est une variation d'un algorithme de tri à temps linéaire utilisant des " masses mobiles ". L'intuition physique derrière l' algorithme de tri des " masses mobiles " est la suivante:

Supposons que la valeur de chaque élément représente réellement sa magnitude de masse et imaginez organiser tous les éléments sur une ligne et appliquer la même force d'accélération.

Ensuite, chaque élément se déplacera jusqu'à une distance liée à sa masse, plus massive moins de distance et vice-versa. Ensuite, pour récupérer les articles triés, collectez simplement les articles dans l'ordre inverse en fonction de la distance parcourue.

Cet algorithme est linéaire et déterministe , mais il y a une mise en garde en ce que la quantité de force d'accélération initiale et la distance à parcourir (ou le temps d'attente) sont liées à la distribution des valeurs (c'est-à-dire les " masses ", le ci-dessus). On peut également essayer de discrétiser l'espace pour que les articles voyagent dans une grille et gagner un facteur constant dans la vitesse de l'algorithme (et utiliser une routine de tri rapide pour trier différents articles dans la même cellule ).$max-min$

À cet égard, l'algorithme ci-dessus est similaire aux algorithmes de tri basés sur le numérique (par exemple , tri-radix , tri - comptage )

On peut penser que cet algorithme ne signifie pas grand-chose, mais il montre au moins une chose. Que, " fondamentalement ", au niveau physique, le tri de nombres arbitraires est une opération en temps linéaire dans le nombre d'articles.