Comment trouver 5 valeurs répétées en temps O (n)?

Supposons que vous ayez un tableau de taille contenant des entiers de à inclus, avec exactement cinq répétitions. J'ai besoin de proposer un algorithme qui puisse trouver les nombres répétés en temps . Je ne peux, pour ma vie, penser à rien. Je pense que le tri, au mieux, serait ? La traversée du tableau serait alors , résultant en . Cependant, je ne suis pas vraiment sûr que le tri soit nécessaire car j'ai vu des choses délicates avec une liste liée, des files d'attente, des piles, etc.$n \geq 6$$1$$n − 5$$O(n)$$O(n\log n)$$O(n)$$O(n^2\log n)$

Vous pouvez créer un tableau supplémentaire de taille n . Définissez initialement tous les éléments du tableau sur 0 . Faites ensuite une boucle dans le tableau d'entrée A et augmentez B [ A [ i ] ] de 1 pour chaque i . Après cela, vous vérifiez simplement le tableau B : boucle sur A et si B [ A [ i ] ] > 1, alors A [ i ] est répété. Vous le résolvez dans O ( n $B$$n$$0$$A$$B[A[i]]$$i$$B$$A$$B[A[i]] > 1$$A[i]$$O(n)$temps au prix de la mémoire qui est et parce que vos entiers sont compris entre 1 et n - 5 .$O(n)$$1$$n-5$

La solution dans la réponse de fade2black est la solution standard, mais elle utilise l' espace . Vous pouvez améliorer cela à l' espace O ( 1 ) comme suit:$O(n)$$O(1)$

1. Soit le tableau . Pour d = 1 , … , 5 , calculer σ d = ∑ n i = 1 A [ i ] d .$A[1],\ldots,A[n]$$d=1,\ldots,5$$\sigma_d = \sum_{i=1}^n A[i]^d$
2. Calculez (vous pouvez utiliser les formules bien connues pour calculer cette dernière somme dans O ( 1 ) ). Notez que τ d = m d 1 + ⋯ + m d 5 , où m 1 , … , m 5 sont les nombres répétés.$\tau_d = \sigma_d - \sum_{i=1}^{n-5} i^d$$O(1)$$\tau_d = m_1^d + \cdots + m_5^d$$m_1,\ldots,m_5$
3. Calculez le polynôme . Les coefficients de ce polynôme sont des fonctions symétriques de m 1 , … , m 5 qui peuvent être calculées à partir de τ 1 , … , τ 5 dans O ( 1 ) .$P(t) = (t-m_1)\cdots(t-m_5)$$m_1,\ldots,m_5$$\tau_1,\ldots,\tau_5$$O(1)$
4. Trouvez toutes les racines du polynôme en essayant toutes les n - 5 possibilités.$P(t)$$n-5$

Cet algorithme suppose le modèle de machine RAM, dans lequel les opérations arithmétiques de base sur les mots bits prennent O ( 1 ) .$O(\log n)$$O(1)$

Une autre façon de formuler cette solution est la suivante:

1. Calculez et déduisez y 1 = m 1 + ⋯ + m 5 en utilisant la formule y 1 = x 1 - ∑ n - 5 i = 1 i .$x_1 = \sum_{i=1}^n A[i]$$y_1 = m_1 + \cdots + m_5$$y_1 = x_1 - \sum_{i=1}^{n-5} i$
2. Calculer dans O ( n ) en utilisant la formule x 2 = ( A [ 1 ] ) A [ 2 ] + ( A [ 1 ] + A [ 2 ] ) A [ 3 ] + ( A [ $x_2 = \sum_{1 \leq i < j \leq} A[i] A[j]$$O(n)$ $$x_2 = (A[1]) A[2] + (A[1] + A[2]) A[3] + (A[1] + A[2] + A[3]) A[4] + \cdots + (A[1] + \cdots + A[n-1]) A[n].$$
3. Déduire utilisant la formule y 2 = x 2 - ∑ 1 ≤ i < j ≤ n - 5 i j - ( n - 5 ∑ i = 1 i ) y 1$y_2 = \sum_{1 \leq i < j \leq 5} m_i m_j$ $$y_2 = x_2 - \sum_{1 \leq i < j \leq n-5} ij - \left(\sum_{i=1}^{n-5} i\right) y_1.$$
4. Calculez et déduisez y 3 , y 4 , y 5 le long de lignes similaires.$x_3,x_4,x_5$$y_3,y_4,y_5$
5. Les valeurs de sont (jusqu'au signe) les coefficients du polynôme P ( t ) de la solution précédente.$y_1,\ldots,y_5$$P(t)$

Cette solution montre que si nous remplaçons 5 par , nous obtenons (je crois) un algorithme O ( d 2 n ) utilisant l' espace O ( d 2 ) , qui effectue des opérations arithmétiques O ( d n ) sur des entiers de longueur de bit O ( d log n ) , en gardant au plus O ( d ) de ceux-ci à un moment donné. (Cela nécessite une analyse minutieuse des multiplications que nous effectuons, dont la plupart impliquent un opérande de longueur uniquement O ( log $d$$O(d^2n)$$O(d^2)$$O(dn)$$O(d\log n)$$O(d)$ .) Il est concevable que cela puisse être amélioré en temps O ( d n ) et enespace O ( d ) en utilisant l'arithmétique modulaire.$O(\log n)$$O(dn)$$O(d)$

Il existe également un algorithme de temps linéaire et d'espace constant basé sur le partitionnement, qui peut être plus flexible si vous essayez de l'appliquer à des variantes du problème sur lesquelles l'approche mathématique ne fonctionne pas bien. Cela nécessite de muter le tableau sous-jacent et présente des facteurs constants pires que l'approche mathématique. Plus précisément, je pense que les coûts en termes du nombre total de valeurs et du nombre de doublons d sont respectivement O ( n log d ) et O ( d ) , bien que le prouver rigoureusement prendra plus de temps que je n'en ai actuellement .$n$$d$$\mathcal{O}(n \log d)$$\mathcal{O}(d)$

Algorithme

Commencez avec une liste de paires, où la première paire est la plage sur l'ensemble du tableau, ou si indexé 1.$[(1, n)]$

Répétez les étapes suivantes jusqu'à ce que la liste soit vide:

1. Prenez et supprimez toute paire de la liste.$(i, j)$
2. Trouvez le minimum et le maximum, et max , du sous-tableau noté.$\text{min}$$\text{max}$
3. Si , le sous-tableau se compose uniquement d'éléments égaux. Donnez ses éléments sauf un et ignorez les étapes 4 à 6.$\text{min} = \text{max}$
4. Si , le sous-tableau ne contient aucun doublon. Ignorez les étapes 5 et 6.$\text{max} - \text{min} = j - i$
5. Partitionnez le sous-tableau autour de , de sorte que les éléments jusqu'à un certain indiceksont plus petits que le séparateur et les éléments au-dessus de cet indice ne le sont pas.$\frac{\text{min}+\text{max}}{2}$$k$
6. Ajoutez et ( k + 1 , j ) à la liste.$(i, k)$$(k + 1, j)$

Analyse cursive de la complexité temporelle.

Les étapes 1 à 6 prennent du temps , car la recherche du minimum et du maximum et le partitionnement peuvent être effectués en temps linéaire.$\mathcal{O}(j - i)$

Chaque paire de la liste est soit la première paire, ( 1 , n ) , soit un enfant d'une paire pour laquelle le sous-tableau correspondant contient un élément en double. Il y a au plus d ⌈ log 2 n + 1 ⌉ de tels parents, car chaque parcours divise par deux la plage dans laquelle un doublon peut être, il y a donc au plus 2 d ⌈ log 2 n + 1 ⌉ au total lorsque des paires sont incluses sur des sous-réseaux sans doublons. À tout moment, la taille de la liste ne dépasse pas 2 $(i, j)$$(1, n)$$d \lceil \log_2 n + 1\rceil$$2d \lceil \log_2 n + 1\rceil$$2d$.

Considérez le travail pour trouver un double. Cela consiste en une séquence de paires sur une plage exponentiellement décroissante, donc le travail total est la somme de la séquence géométrique, ou . Cela produit un corollaire évident que le travail total pour les doublons d doit être O ( n d ) , qui est linéaire en n .$\mathcal{O}(n)$$d$$\mathcal{O}(nd)$$n$

Pour trouver une limite plus stricte, considérons le pire des cas de doublons répartis au maximum. Intuitivement, la recherche prend deux phases, l'une où le tableau complet est parcouru à chaque fois, en parties progressivement plus petites, et l'autre où les parties sont plus petites que donc seules les parties du tableau sont traversées. La première phase ne peut être quelogd enprofondeur, donc a coûtéO(nlogd), et la deuxième phase a coûtéO(n)parce que la superficie totale recherchée diminue à nouveau de façon exponentielle.$\frac{n}{d}$$\log d$$\mathcal{O}(n \log d)$$\mathcal{O}(n)$

Laissant cela comme une réponse car il a besoin de plus d'espace qu'un commentaire.

Vous faites une erreur dans l'OP lorsque vous suggérez une méthode. Trier une liste puis la traverser temps, pas O ( n 2 log n ) temps. Lorsque vous faites deux choses (qui prennent O ( f ) et O ( g ) respectivement) séquentiellement, la complexité temporelle résultante est O ( f + g ) = O ( max f , g ) (dans la plupart des circonstances).$O(n\log n)$$O(n^2\log n)$$O(f)$$O(g)$$O(f+g)=O(\max{f,g})$

Afin de multiplier les complexités temporelles, vous devez utiliser une boucle for. Si vous avez une boucle de longueur et que pour chaque valeur de la boucle vous faites une fonction qui prend O ( g ) , alors vous aurez le temps O ( f g ) .$f$$O(g)$$O(fg)$

Donc, dans votre cas, vous triez dans puis transversalement dans O ( n ) résultant en O ( n log n + n ) = O ( n log n ) . Si pour chaque comparaison de l'algorithme de tri vous deviez faire un calcul qui prend O ( n ) , alors il faudrait O ( n 2 log n ) mais ce n'est pas le cas ici.$O(n\log n)$$O(n)$$O(n\log n+n)=O(n\log n)$$O(n)$$O(n^2\log n)$

Au cas où vous seriez curieux de savoir si j'affirme que , il est important de noter que ce n'est pas toujours vrai. Mais si f ∈ O ( g ) ou g ∈ O ( f ) (qui vaut pour toute une série de fonctions communes), il le sera. Le moment le plus courant qu'il ne tient pas est lorsque des paramètres supplémentaires sont impliqués et que vous obtenez des expressions comme O ( 2 c n + n log n ) .$O(f+g)=O(\max{f,g})$$f\in O(g)$$g\in O(f)$$O(2^cn+n\log n)$

Il existe une variante en place évidente de la technique de tableau booléen utilisant l'ordre des éléments comme magasin (où arr[x] == xpour les éléments "trouvés"). Contrairement à la variante de partition qui peut être justifiée d'être plus générale, je ne sais pas quand vous auriez réellement besoin de quelque chose comme ça, mais c'est simple.

for idx from n-4 to n
    while arr[arr[idx]] != arr[idx]
        swap(arr[arr[idx]], arr[idx])

Cela place simplement à plusieurs reprises arr[idx]l'emplacement arr[idx]jusqu'à ce que vous trouviez cet emplacement déjà pris, auquel cas il doit s'agir d'un doublon. Notez que le nombre total de swaps est limité par puisque chaque swap rend sa condition de sortie correcte.$n$

Soustrayez les valeurs que vous avez de la somme .$\sum_{i=1}^{n} i = \frac{(n-1) \cdot n}{2}$

Donc, après le temps (en supposant que l'arithmétique est O (1), ce qui n'est pas vraiment, mais supposons), vous avez une somme σ 1 de 5 entiers entre 1 et n:$\Theta(n)$$\sigma_1$

$x_1 + x_2 + x_3 + x_4 + x_5 = \sigma_1$

Soi-disant, ce n'est pas bon, non? Vous ne pouvez pas comprendre comment diviser cela en 5 nombres distincts.

$\sum_{i=1}^{n} i^2$

${x_1}^2 + {x_2}^2 + {x_3}^2 + {x_4}^2 + {x_5}^2 = \sigma_2$

$\vec{x}$

$\lceil\log(5n^6)\rceil$

$1$$n-5$$O(N)$

Mappez un tableau sur 1 << A[i]puis XOR tout ensemble. Vos doublons seront les numéros où le bit correspondant est désactivé.

DATA=[1,2,2,2,2,2]

from collections import defaultdict

collated=defaultdict(list):
for item in DATA:
    collated[item].append(item)
    if len(collated) == 5:
        return item.

# n time