web-dev-qa-db-fra.com

La complexité temporelle de l'algorithme Prims?

J'ai trouvé partout la complexité temporelle de l'algorithme Prims comme O ((V + E) log V) = E log V . Mais comme on peut voir l'algorithme:

Il semble que la complexité temporelle soit de O (V (log V + E log V)) . Mais si sa complexité temporelle est de O ((V + E) log V) . Ensuite, la nidification doit être comme ceci:

Mais la nidification ci-dessus semble être fausse.

time-complexityprims-algorithm
8
Sonali
MST-PRIM(G, w, r)
1  for each u ∈ G.V
2       u.key ← ∞
3       u.π ← NIL
4   r.key ← 0
5   Q ← G.V
6   while Q ≠ Ø
7       u ← EXTRACT-MIN(Q)
8       for each v ∈ G.Adjacent[u]
9           if v ∈ Q and w(u, v) < v.key
10              v.π ← u
11              v.key ← w(u, v)

Utiliser un tas binaire

  1. La complexité temporelle requise pour un appel à EXTRACT-MIN(Q) est O(log V) à l'aide d'une file d'attente à priorité minimale. La boucle while à la ligne 6 exécute V fois total.so EXTRACT-MIN(Q) est appelé V fois. Donc, la complexité de EXTRACT-MIN(Q) est O(V logV). 

  2. La boucle for à la ligne 8 exécute le nombre total 2E fois car la longueur de chaque liste de contiguïté est 2E pour un graphe non dirigé. Le temps requis pour exécuter la ligne 11 est O(log v) à l'aide de l'opération DECREASE_KEY sur le tas min. La ligne 11 exécute également le nombre total de 2E. Le temps total nécessaire pour exécuter la ligne 11 est donc O(2E logV) = O(E logV).

  3. La boucle for à la ligne 1 sera exécutée V fois. L'utilisation de la procédure pour effectuer les lignes 1 à 5 nécessitera une complexité de O(V).

La complexité temporelle totale de MST-PRIM est la somme de la complexité temporelle requise pour exécuter les étapes 1 à 3 pour un total de O(VlogV + (E logV + V) = O(E logV).

Utiliser un tas de Fibonacci

  1. Comme ci-dessus.
  2. L’exécution de la ligne 11 nécessite O(1) temps amorti. La ligne 11 exécute un total de 2E fois. La complexité temporelle totale est donc O(E).
  3. Comme ci-dessus

La complexité temporelle totale de MST-PRIM est donc la somme des étapes 1 à 3 exécutées pour une complexité totale de O(V logV + E + V)=O(E + V logV).

23
tanmoy

Votre idée semble correcte. Prenons la complexité comme suit: V(lg(v) + E(lg(v))) Remarquons ensuite que, dans la boucle for interne, nous parcourons tous les sommets et non le contour, modifions donc légèrement la valeur de . V(lg(v) + V(lg(v))) , Ce qui signifie V(lg(v)) + V*V(lg(v)) Mais pour l'analyse dans le pire des cas (graphiques denses), V * V est à peu près égal au nombre d'arêtes, E V(lg(v)) + E(lg(v))(V+E((lg(v)) mais depuis V << E, d’où E(lg(v))

2
user3473400

en réalité, comme vous le dites, imbriqué à l'intérieur alors que la complexité temporelle devrait être v.E lg V est correct en cas d'analyse asymptotique. Mais en cormen ils ont fait une analyse amortie qui explique pourquoi (Elogv) 

1
Rakhi

La complexité temporelle de l'algorithme prims est O (VlogV + ElogV). Il est clair pour moi que vous comprenez comment VlogV est arrivé.

Maintenant, comment ElogV vient-il, alors jetez un coup d’œil aux prims algo

MST-PRIM(G, w, r) 1 for each u ∈ G.V 2 u.key ← ∞ 3 u.π ← NIL 4 r.key ← 0 5 Q ← G.V 6 while Q ≠ Ø 7 u ← EXTRACT-MIN(Q) 8 for each v ∈ G.Adj[u] 9 if v ∈ Q and w(u, v) < v.key 10 v.π ← u 11 v.key ← w(u, v) }

votre problème se situe entre la ligne 8 et la ligne 11 . Comme vous pouvez facilement le constater, les lignes 8 à 11 sont exécutées pour chaque élément de Q et nous savons que le nombre d’éléments de Q est V. Considérons maintenant ceci pour le 1er élément de Q, nous lançons la boucle à la ligne 8 pour chaque voisin et nous faisons la même chose pour son élément suivant et la même chose pour tous les autres éléments de Q. puisque le nombre d'élément dans Q est égal à V, nous lançons la boucle à la ligne 8 avec exactement 2E fois. EX: -

   1
  / \
 2---3

supposons maintenant que l'élément de Q sera dans l'ordre 1, 2, 3. Si nous exécutons la boucle à la ligne 8 pour le premier élément de Q i, e 1, nous l'exécutons exactement 2 fois (nous vérifions chacun de ses voisins) et pour 2 nous courons en boucle à la ligne 8 pour 2 fois et même pour 3. Nous obtenons maintenant 2 + 2 + 2 = 6 (nombre total de fois où la boucle à la ligne 8 est exécutée), ce qui correspond à 2 * E (où E est le nombre total d'arêtes du graphique), de sorte que la complexité temporelle des lignes 8 à 11 devient 

O(2*ElogV) nous supprimons les constantes en notation big-oh afin que la complexité devienne

O(ElogV)

maintenant la complexité temporelle totale de l'algorithme devient O (VlogV + ElogV) = O ((V + E) logV)

Dans un graphe dense, nous avons E> V, donc dans la complexité temporelle, nous ignorons V et obtenons 

O(ElogV)
0
Anshu Shahi