Perché la complessità temporale di DFS e BFS O (V + E)

L'algoritmo di base per 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

Quindi penso che la complessità del tempo sarebbe:

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

dove vè vertice 1din

Innanzitutto, ciò che ho detto è corretto? In secondo luogo, com'è O(N + E), e intuizione sul perché sarebbe davvero bello. Grazie

La tua somma

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

può essere riscritto come

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

e il primo gruppo è O(N)mentre l'altro è O(E).

DFS (analisi):

• L'impostazione / acquisizione di un'etichetta vertice / bordo richiede O(1)tempo
• Ogni vertice è etichettato due volte
  • una volta come INESPLORATO
  • una volta come VISITATO
• Ogni bordo è etichettato due volte
  • una volta come INESPLORATO
  • una volta come SCOPERTA o INDIETRO
• Il metodo incidentEdges viene chiamato una volta per ciascun vertice
• DFS viene eseguito nel O(n + m)tempo a condizione che il grafico sia rappresentato dalla struttura dell'elenco di adiacenza
• Richiama questo Σv deg(v) = 2m

BFS (analisi):

• L'impostazione / acquisizione di un'etichetta vertice / bordo richiede tempo O (1)
• Ogni vertice è etichettato due volte
  • una volta come INESPLORATO
  • una volta come VISITATO
• Ogni bordo è etichettato due volte
  • una volta come INESPLORATO
  • una volta come SCOPERTA o CROCE
• Ogni vertice viene inserito una volta in una sequenza Li
• Il metodo incidentEdges viene chiamato una volta per ciascun vertice
• BFS viene eseguito nel O(n + m)tempo a condizione che il grafico sia rappresentato dalla struttura dell'elenco di adiacenza
• Richiama questo Σv deg(v) = 2m

Molto semplificato senza molta formalità: ogni fronte viene considerato esattamente due volte e ogni nodo viene elaborato esattamente una volta, quindi la complessità deve essere un multiplo costante del numero di bordi e del numero di vertici.

La complessità temporale è O(E+V)invece O(2E+V)perché se la complessità temporale è n ^ 2 + 2n + 7, allora è scritta come O (n ^ 2).

Quindi, O (2E + V) è scritto come O (E + V)

perché la differenza tra n ^ 2 e n conta ma non tra n e 2n.

Penso che ogni fronte sia stato considerato due volte e ogni nodo sia stato visitato una volta, quindi la complessità temporale totale dovrebbe essere O (2E + V).

Una spiegazione intuitiva a questo è semplicemente analizzando un singolo ciclo:

1. visita un vertice -> O (1)
2. a ciclo continuo su tutti i bordi degli incidenti -> O (e) dove e è un numero di bordi incidenti su un dato vertice v.

Quindi il tempo totale per un singolo loop è O (1) + O (e). Ora sommalo per ogni vertice quando ogni vertice viene visitato una volta. Questo da

For every V
=> 

    O(1)
    +

    O(e)

=> O(V) + O(E)

Spiegazione breve ma semplice:

Nel caso peggiore avresti bisogno di visitare tutti i vertici e gli spigoli, quindi la complessità temporale nel caso peggiore è O (V + E)