Pesquisa em Profundidade Kruskal

Complexidade Temporal: O( |E| + |V| ) Pseudo-código:

|E| é a cardinalidade dos arcos e |V| é a cardinalidade 1. A←
dos vértices. 2. For each vertex v ∈ V[G]
Implementação em python: 3. do Make-Set(v)
4. sort the edges of E by nondecreasing weight w
def dfs(graph,root,visited=None): 5. for each edge (u,v) ∈ E, in order by nondecreasing
if visited == None: weight
visited = set([root]) 6. do if Find-Set(u) ≠ Find-Set(v)
for v in graph[root]:
if v not in visited: 7. then A ← A U {(u,v)}
visited.add(v) 8. Union(u,v)
dfs(graph,v,visited) # set union 9. return A
return visited
Análise do algoritmo:
O tempo de execução do algoritmo de Kruskal para
um grafo G=(V,E) depende da implementação da
estrutura de dados dos conjuntos disjuntos.
Pesquisa em Largura A inicialização toma o tempo de O(V), e o tempo para
ordenar os arcos na linha 4 é O(E log E). O tempo
Complexidade Espacial: O( |E| + |V| ) total de execução do algoritmo de Kruskal é O(E log
Complexidade Temporal: O( |E| + |V| ) E).
|E| é a cardinalidade dos arcos e |V| é a cardinalidade
dos vértices.
Implementação em python:
Dijkstra
visited = []
Pseudo-código:
def BFS(G,s,visited):
1. for each vertex v ∈ V[G]
Q=[]#priority queue: first-in, first-out
Q.append(s) 2. do d[v]←∞
visited=[s] 3. π[v]←NIL
while Q!=[]: 4. d[s]←0
curr_node=Q.pop() 5. S←
for i in G[curr_node]: 6. ←V[G]
if i not in Q: 7. while Q≠:
Q.insert(0,i) 8. do u←Extract_Min(Q)
visited.append(i) 9. S←S U {u}
return visited 10. for each vertex v ∈ Adj[u]
11. do if d[v]>d[u]+w(u,v) → passo de
12. then d[v]←d[u]+w(u,v) → relaxação
▼
Prim Decrease-Key implícito

1. Q←V
Belmman-Ford
2. For each u ∈ Q: Pseudo-código:
3. key[u]←∞ 1. for each v ∈ V – {s} |
4. key[r]←0 for some arbitrary s ∈ V 2. do d[v]←∞ | Inicialização
5. π[r]←NIL 3. d[s]←0 |
6. while Q≠: 4. for i←1 to |V(G)| - 1
7. do u←Extract-Min(Q) 5. do for each edge (u,v) ∈ E[G]
8. for each v ∈ Adj[u] 6. do if d[v]>d[u]+w(u,v) Passo de
9. do if v ∈ Q and w(u,v)<keys[v] 7. then d[v]←d[u]+w(u,v) relaxamento
10. then key[v]←w(u,v) ► Decrease-Key 8. for each eadge (u,v) ∈ E[G]
11. π[v]←u 9. do if d[v]>d[u]+w(u,v)
10. then return FALSE (report that a negative-weight
Análise do algoritmo: cycle exists)
Usando matriz de adjacência: O(V2) 11. return TRUE (if no negative-weight cycles:
Usando heaps binárias: O((V+E log (V)) = O(E log(v)) d[v]=(s,v)
Usando heap de Fibonacci e listas de adjacência: O(E
+ log(V)) Análise do algoritmo:
O algoritmo de Bellman-Ford possui um tempo de
execução de O(VE), desde que a inicialização nas
linhas 1-3 tomar um tempo de Θ(V), cada um dos |V|-1
passos sobre os arcos nas linhas 4-7 tomarem um
tempo de O(E), e o ciclo for nas linhas 8-10 tomar um
tempo de O(E).
Sociologia

Complexidade temporal: n2

vistos = []
ordem = []

def dfs(g,u):
global vistos ► DFS ao grafo G
vistos.append(u)
for v in g[u]:
if v not in vistos: dfs(g,v)
ordem.append(u)

def gt(g):
gr={}
for i in g: ► Determinar Gt
adj=[j for j in g for k in g[j] if k==i]
gr[i]=adj
return gr

def dfs2(g,u):
if u not in g: return 0
vistos.append(u)
c = 1 ► DFS ao grafo Gt,e cálculo dos
grupos e pessoas s/ grupo
for v in g[u]:
if v not in vistos:
c += dfs2(g,v)
return c