J'essaie de concevoir un algorithme pour trouver des indices de deux mêmes éléments dans un tableau. L'entrée est une matrice et la sortie est deux indices I & J tels que la matrice [I] = tableau [J]. La complexité du temps doit être O (nlogn).
Voici ce que j'ai essayé p> boucle imbriquée est O (n ^ 2), mais si j'essaie de concevoir comme ça . Quelle serait la complexité du temps? p> n est la taille de la matrice
Ma mise en œuvre fonctionnerait O (N [(N-1) + (N-2) + (N-3) ... + 1]). Est-ce toujours (n ^ 2), quelqu'un m'a dit que c'est O (nlogn), pourquoi? P> p>
3 Réponses :
Comme vous savez que la complexité temporelle de votre algorithme est Si vous triez le tableau, deux indices avec la même valeur pourraient être situés à côté de l'autre. Par conséquent, vous pouvez parcourir la matrice triée et signaler leur index initial des deux indices de voisins actuels dans la matrice triée. P>
La complexité temporelle du tri pourrait être O (n ^ 2) code>. Pour obtenir un meilleur résultat, vous pouvez d'abord trier le tableau, puis trouver les indices. p>
O (n log n) code>, puis itération sur la matrice est
o (n) code>. Par conséquent, cet algorithme est
O (n journal n) code>. P>
Vous pouvez conserver deux array: une avec les valeurs ( J'ai implémenté cette idée dans une fonction Python: p> Vous pouvez essayer avec quelques exemples: p> A code>) et une avec les indices (
i code>). Un éventuel
O (nlogn) code> algorithme pourrait être:
A code> en parallèle avec la matrice d'index
i code>. (Complexité temporelle:
O (nlogn) code>). LI>
A code> et comparez tous les éléments avec son voisin droit, si un duplicata est trouvé, vous pouvez renvoyer l'index correspondant dans
i code>. (Complexité temporelle:
O (n) code>) li>
OL>
a = [2,3,5,2,6] code> donner
(0, 3) code> li>
a = [2, 3, 100, 6, 15, 40, 7, 3] code> donner
(1, 7) code> li>
ul> p>
Vous pouvez utiliser une carte pour la recherche inverse pour code> boucle a o (n) heure +
inverselookup code> a O (1 ) Heure + O (n) Espace (Table de hachage) P> P>