web-dev-qa-db-fra.com

Pourquoi la complexité temporelle de DFS et de BFS O (V + E)

L'algorithme de base pour BFS:

set start vertex to visited

load it into queue

while queue not empty

   for each Edge incident to vertex

        if its not visited

            load into queue

            mark vertex

Je pense donc que la complexité temporelle serait la suivante:

v1 + (incident edges) + v2 + (incident edges) + .... + vn + (incident edges)

où v est le sommet 1 à n

Premièrement, ce que j'ai dit est-il correct? Deuxièmement, comment est-ce que cette O(N + E), et l’intuition de savoir pourquoi serait vraiment gentil. Merci

algorithmtime-complexitygraph-theorybreadth-first-search
117
ordinary

Votre somme

v1 + (incident edges) + v2 + (incident edges) + .... + vn + (incident edges)

peut être réécrit comme

(v1 + v2 + ... + vn) + [(incident_edges v1) + (incident_edges v2) + ... + (incident_edges vn)]

et le premier groupe est O(N) tandis que l'autre est O(E).

244
Mihai Maruseac

DFS (analyse):

  • Définir/obtenir une étiquette de sommet/bord prend O(1) temps
  • Chaque sommet est étiqueté deux fois
    • une fois comme inexploité
    • une fois comme visité
  • Chaque bord est étiqueté deux fois
    • une fois comme inexploité
    • une fois en DECOUVERTE ou RETOUR
  • La méthode incidentEdges est appelée une fois pour chaque sommet.
  • DFS s'exécute en O(n + m) time à condition que le graphique soit représenté par la structure de la liste de contiguïté
  • Rappelons que Σv deg(v) = 2m

BFS (analyse):

  • Définir/obtenir une étiquette de sommet/bord prend O(1) temps
  • Chaque sommet est étiqueté deux fois
    • une fois comme inexploité
    • une fois comme visité
  • Chaque bord est étiqueté deux fois
    • une fois comme inexploité
    • une fois en DECOUVERTE ou en CROIX
  • Chaque sommet est inséré une fois dans une séquence Li
  • La méthode incidentEdges est appelée une fois pour chaque sommet.
  • BFS s'exécute en O(n + m) time, à condition que le graphique soit représenté par la structure de la liste de contiguïté
  • Rappelons que Σv deg(v) = 2m
37
TheNewOne

Très simplifié sans beaucoup de formalité: chaque bord est considéré exactement deux fois et chaque nœud est traité exactement une fois. La complexité doit donc être un multiple constant du nombre d'arêtes ainsi que du nombre de sommets.

18
JavaFreak

La complexité temporelle est O(E+V) au lieu de O(2E+V) parce que si la complexité temporelle est n ^ 2 + 2n + 7, elle est écrite sous la forme O (n ^ 2).

Par conséquent, O (2E + V) est écrit comme O (E + V)

car la différence entre n ^ 2 et n est importante mais pas entre n et 2n.

10
Dhruvam Gupta

Je pense que chaque bord a été pris en compte deux fois et que tous les nœuds ont été visités une fois. La complexité temporelle totale devrait donc être de 0 (2E + V).

3
Kehe CAI

Explication courte mais simple:

Dans le pire des cas, vous devez visiter tous les sommets et Edge, d'où la complexité temporelle dans le pire des cas est O (V + E).

2
CodeYogi

Une explication intuitive à cela consiste simplement à analyser une seule boucle:

  1. visiter un sommet -> O (1)
  2. une boucle for sur toutes les arêtes incidentes -> O(e) où e est un nombre d'arêtes incidentes sur un sommet donné v.

Donc, le temps total pour une seule boucle est O (1) + O (e). Faites maintenant la somme pour chaque sommet, car chaque sommet est visité une fois. Cela donne

Sigma_i

p {
    height: 50px;
    line-height: 50px;
}

span {
    position: relative;
    font-size: 2.5em;
    display: inline-block;
    line-height: .7em;
    vertical-align: middle;
}

span:before {
    font-size: 12px;
    display: block;
    position absolute;
    left: 0;
    top: 0;
    content: "V";
    width: 22px;
    text-align: center;
}

span:after {
    font-size: 12px;
    display: block;
    position absolute;
    left: 0;
    bottom: 0;
    content: "k = 1";
    width: 27px;
    text-align: center;
}
<p>
    <span>&Sigma;</span>
    O(1) + O(e)
=> 
    <span>&Sigma;</span>
    O(1)
    +
   <span>&Sigma;</span>
    O(e)

=> O(V) + O(E)

</p>

[O(1) + O (e)]

2
Ultrablendz