Caminhos Mais Curtos Fluxo Máximo Árvores Geradoras Mínimas

Transcrição

1 Caminhos Mais Curtos Fluxo Máximo Árvores Geradoras Mínimas Túlio Toffolo Marco Antônio Carvalho BCC0 Aula 1 Algoritmos e Programação Avançada

2 Plano da Aula Caminhos Mais Curtos Algoritmo de Dijkstra Algoritmo de Floyd Fluxo Máximo Algoritmo de Ford Fulkerson Árvores Geradoras Mínimas Algoritmo de Kruskal Algoritmo de Prim Otimização dos algoritmos

3 CAMINHOS PROGRAMAÇÃO MAIS DE TRIPULAÇÕES CURTOS

4 Caminhos mais Curtos Dados: grafo G=(V,A) orientado e distância c ij associada ao arco (i,j) A. Problema: Obter o caminho mais curto entre dois nós s e t. O comprimento de um caminho é igual à soma dos comprimentos (distâncias) dos arcos que formam o caminho. A distância ou comprimento de um arco pode ter diversas interpretações Exemplo 1: Dado um mapa rodoviário, determinar a rota mais curta de uma cidade a outra.

5 Caminhos mais Curtos Exemplo : Construção de uma estrada entre duas cidades A e K. O grafo abaixo representa os diversos trechos possíveis e o custo de construção de cada um. Determinar o trajeto ótimo cujo custo de construção seja mínimo (corresponde a achar o caminho mais curto de A a K em relação a estes custos). B E 6 H A 8 C F I K D G J Solução: A D G I K custo = = 16

6 Caminhos mais Curtos Condição de existência: Caminho de i a j contendo um circuito w: k j i w Comprimento do caminho = comprimento (i k) + comprimento (w) + ( j comprimento (k Qual é o comprimento do caminho mais curto de i a j se o comprimento do circuito w é negativo? 6

7 Caminhos mais Curtos Condição de existência: não há circuitos de comprimento negativo. A solução ótima (caminho mais curto) sempre será um caminho elementar (sem ciclo).

8 Caminhos mais Curtos " Caminho mais curto: - De um nó a outro - De um nó a todos os demais - Entre todos os pares de nós de um grafo 8

9 Caminhos mais Curtos ( G=(V,A Caminho mais curto do nó 1 a cada nó do grafo Hipótese: todas as distâncias c ij são positivas: c ij 0, (i,j) A ( ) Algoritmo de Moore-Dijkstra π*(i) = comprimento do caminho mais curto do nó 1 ao nó i Em especial, π*(1)=0 (distâncias positivas). " Algoritmo com n-1 iterações " No início de cada iteração, o conjunto V de nós está particionado em dois subconjuntos S e S, com o nó 1 em S. S S = φ S S = V 9

10 Caminhos mais Curtos Cada nó i V possui um rótulo π(i ), que verifica a seguinte propriedade: Se Se i S π ( i ) = π * ( i ) π ( i ) = min{ π ( k ) + c ki } k S i S π ( i ) π * ( i ) k Γ i π ( i ), i S, dá o valor do caminho mais curto de 1 a i sob a restrição de que todos os nós utilizados (exceto o próprio i ) pertençam a S. π (a) a π (b) 1 b c ai c bi π (i ) i π (c ) c Sc ci S 10

11 Caminhos mais Curtos Teorema: Seja o nó j S tal que π( j ) = minπ(. i ) i S Então π *( j) = π ( j), isto é, o comprimento do caminho mais curto do nó 1 ao nó j é igual a π ( j ). Demonstração: Por construção, certamente existe um caminho de 1 até j com comprimento π(j). Suponhamos que exista outro caminho de 1 a j de comprimento menor do que π(j). Dividamos este caminho em duas partes: - P 1 é a parte inicial, do nó 1 ao nó L, onde L é o primeiro nó de encontrado S - P é a parte final, do nó L ao nó j 11

12 Caminhos mais Curtos ( π(j comprimento de P 1 π(l) comprimento de P 0 Logo, o comprimento de P 1 + P π(j). 1

13 CAMINHOS MAIS CURTOS PROGRAMAÇÃO ALGORITMO DE TRIPULAÇÕES DE DIJKSTRA

14 Caminhos mais Curtos Algoritmo de Moore-Dijkstra Inicializar S {,3,...,n}, S {1}, π(1) 0, π(j) c 1j se j Γ caso contrário Enquanto S faça Selecionar j S tal que π(j)= min i S {π(i)} S S {j} Para i S e i Γ j + faça π(i) min{π(i), π(j)+c ji } fim_enquanto 1

15 Caminhos mais Curtos O algoritmo de Moore-Dijkstra constrói progressivamente o conjunto dos nós mais próximos de 1. Construção de uma arborescência com raiz em 1 que define os caminhos mais curtos do nó 1 a cada nó do grafo. 1

16 Caminhos mais Curtos Exemplo: S = {1} S = {,3,,,6} π(1) = 0 π() = π(3) = 1 π() = π() = π(6) = + ITERAÇÃO 1 π*(1) = π*(3) = j = 3 S = {,,,6} π() = min{, 1+} = 6 π() = min{, 1+} = 3 π(6) = min{, 1+} = 8 16

17 Caminhos mais Curtos π*(1) = π*(3) = 1 π*() = ITERAÇÃO j = S = {,,6} π() = min{6, 3+} = π() = min{, 3+} = 8 π*() = π*(1) = π*(3) = 1 1 π*() = ITERAÇÃO 3 j = S = {,6} π() = min{8, +} = 8 π(6) = min{, +1} = 6 1

18 Caminhos mais Curtos π*() = π*(1) = π*(3) = 1 1 π*() = π*(6) = 6 ITERAÇÃO j = 6 S = {} π() = 8 π*() = π*(1) = 0 1 π*() = 8 π*() = ITERAÇÃO j = S = { } 1 3 π*(3) = 1 6 π*(6) = 6 18

19 Caminhos mais Curtos nó Iteração Início 0 π

20 Caminhos mais Curtos Número de operações (tempo): ~ n n-1 iterações, cada iteração busca o mínimo em uma lista com ( π até n-1 elementos (vetor " Caminho mais curto do nó 1: ao nó j a todos os nós Mesma complexidade, mas critérios de parada diferentes. " Distâncias negativas: 1 3 Caminho mais curto de 1 a 3? Resultado do algoritmo? Por que? 3 0

21 Caminhos mais Curtos Algoritmo de Moore-Dijkstra para o caso com distâncias negativas Inicializar S {,3,...,n}, S {1}, π(1) 0, π(j) c 1j se j Γ caso contrário Enquanto S faça Selecionar j S tal que π(j)= min i S {π(i)} S S {j} Para i Γ j + faça Calcular π* π(j)+ c ji Se π* < π(i) então S S {i} π(i) π* fim-se fim-para fim-enquanto 1

22 CAMINHOS MAIS CURTOS PROGRAMAÇÃO ALGORITMO DE TRIPULAÇÕES DE FLOYD

23 Caminhos mais Curtos Dados: Grafo G=(V, A) orientado, V = n. Não há circuitos negativos. c = {c ij }, j = 1,...,n, i = 1,...,n c ij 0 c ii = 0 c ij = +, (i, j ) A A k (i, j ) = valor do caminho mais curto de i a j podendo usar apenas nós numerados de 1 a k como nós intermediários. 3

24 Caminhos mais Curtos A 0 (i, j ) = c ij : caminho mais curto de i a j usando no máximo o nó 0 (que não existe) como nó intermediário (caminho ( intermediários mais curto de i a j sem nós A k (i, j ) : pode usar o nó k ou não. A k+1 (i, j ) : pode usar o nó k+1 ou não. A 0 A 1 A 1 A... A n-1 A n A n (i, j ) = valor do caminho mais curto de i a j podendo usar qualquer nó de 1 a n como nó intermediário.

25 Caminhos mais Curtos Se A k+1 (i, j ) não usa o nó k+1 como intermediário, então: A k+1 (i, j ) = A k (i, j ) Se A k+1 (i, j ) usa o nó k+1 como intermediário, então: A k+1 (i, j ) = A k (i, k+1) + A k (k+1, j ) A k+1 (i, j ) = min { A k (i, j ), A k (i, k+1) + A k (k+1, j ) }

26 Caminhos mais Curtos Algoritmo de Floyd: Para i = 1,...,n faça Para j = 1,...,n faça A 0 (i,j) c ij fim-para fim-para Para k = 1,...,n faça Para i = 1,...,n faça Para j = 1,...,n faça A k (i,j) min{a k-1 (i,j), A k-1 (i,k) + A k-1 (k,j)} fim-para fim-para fim-para 6

27 Caminhos mais Curtos Exemplo: C = A 0 = A 1 = A = A 3 = Teoriade Grafos

28 Caminhos mais Curtos Algoritmo de Dijkstra: número de operações (tempo) ~ n n-1 iterações, cada iteração busca o mínimo em uma lista com até ( π n-1 elementos (vetor Algoritmo de Floyd: número de operações (tempo) ~ n 3 Três comandos for de 1 até n um dentro do outro Ou seja, o problema de calcular os caminhos mais curtos entre todos os pares de nós pode ser resolvido com a mesma eficiência aplicando-se n vezes o algoritmo de Dijkstra, uma vez a partir de cada nó inicial. 8

29 Otimizações: uso de Heaps Operação Complex. Real Complexidade Amortizada Pairing Heap Fibonacci Heap isempty O(1) O(1) O(1) size O(1) O(1) O(1) getmax O(1) O(1) O(1) put O(1) O(log n) ** O(1) removemax O(n) O(log n) O(log n) meld O(1) O(log n) ** O(1) remove O(n) O(log n) O(log n) increasekey O(n) O(log n) ** O(1)

30 PROGRAMAÇÃO FLUXO MÁXIMO DE TRIPULAÇÕES

31 Problema do Fluxo Máximo Dados: Grafo G=(X,U) orientado ( c(u u U: capacidade ( c(u f(u) 0 fonte S f sumidouro P Problema: Obter um fluxo máximo de S a P respeitando as restrições de capacidade e as restrições de conservação de fluxo em cada nó. 31

32 Problema do Fluxo Máximo " Inserindo-se um arco de retorno, transforma-se um fluxo em uma circulação : S f P Exemplo: S 1, 1 1, a 0, P capacidades c fluxos f, b 3, 3 3, 3

33 Problema do Fluxo Máximo f ( u ) u: I ( u ) = x u: T ( u ) = x f ( u ) = v, x = S 0, x S, x P -v, x P I(u) u T(u) Com o arco de retorno: f ( u) f ( u) = 0, x X ui : ( u) = x ut : ( u) = x 33

34 Problema do Fluxo Máximo Exemplo: S 1 a b 3 e 1 c d 1 P " Capacidades associadas aos nós: x 3 x 1 ( c(x x

35 FLUXO MÁXIMO ALGORITMO DE FORD FULKERSON

36 Problema do Fluxo Máximo ( básica " Algoritmo de rotulação de Ford e Fulkerson (idéia Início: fluxo viável (por exemplo um fluxo nulo) Iteração: Determinar um caminho C de S a P ao longo do qual nenhum arco esteja saturado. (isto é, f(u) = c(u)) Circuito Γ = C {(P,S)} Aumentar o fluxo ao longo dos arcos de Γ do valor δ = min u Γ [c(u)-f(u)] 36

37 Problema do Fluxo Máximo Exemplo: 1 a 1 S 1 P 1 b Este fluxo (f=3) é máximo? Por que? Fluxo máximo = 3

38 Problema do Fluxo Máximo " A inexistência de um caminho aumentante no grafo original não quer dizer que não seja possível aumentar o fluxo. Obter uma cadeia ligando S e P que, em conjunto com o arco de retorno (P,S) defina um ciclo Γ: ( P,S ) Γ + : arcos de Γ orientados como ( P,S ) Γ - : arcos de Γ orientados no sentido oposto a δ 1 = min u Γ + [c(u) f(u)] (aumento possível nos arcos de Γ + ) δ = min u Γ - [f(u)] (redução possível nos arcos de Γ - ) " Melhorar a solução (aumentar o fluxo) somando δ = min{δ 1, δ } aos fluxos nos arcos de Γ + e subtraindo δ aos fluxos nos arcos de Γ -. 38

39 Problema do Fluxo Máximo Exemplo: f(u) c(u) S a 1, 1 1, X 0 Γ Γ +, X 3 b Γ X 0, 3, 3 P Γ Γ , X δ 1 = δ = 1 δ = 1 39

40 Problema do Fluxo Máximo Algoritmo Procedimento de rotulação para obter um ciclo Γ: ( δ(x Nó x rótulo " Rotulação direta: ( δ(x x marcado ( x,y ) com u = ( c(u f(u) < y não marcado Quantidade pela qual pode ser aumentado o fluxo de S a x seguindo ( A(x uma cadeia cujo último arco é δ(x) x u δ(y) = min { δ(x), c(u)-f(u) } y A(y) = u 0

41 Problema do Fluxo Máximo " Rotulação inversa: ( δ(x x marcado ( y,x ) arco u = f(u) > 0 y não marcado δ(x) u x y δ(y) = min { δ(x), f(u) } A(y) = u f(u) 0 u ROTULAR(f,δ,A,Y) Enquanto δ > 0 faça ALTERAR_FLUXOS(f,δ,A) ROTULAR(f,δ,A,Y) fim-enquanto 1

42 Problema do Fluxo Máximo ROTULAR(f,δ,A,Y) δ, δ(s) + Y {S} Enquanto P Y e δ > 0 faça Se u =(x,y): x Y, y Y e f(u) < c(u) então Y Y {y} A(y) u δ(y) min {δ(x), c(u)-f(u)} Senão Se u =(y,x): x Y, y Y e f(u) > 0 então Y Y {y} A(y) u δ(y) min {δ(x), f(u)} Senão δ 0 fim-enquanto Se P Y então δ δ(p) FIM-ROTULAR

43 Problema do Fluxo Máximo ALTERAR_FLUXOS(f,δ,A) x P f(p,s) f(p,s) + δ Enquanto x S faça u A(x) Se x = T(u) então f(u) f(u) + δ x I(u) Senão f(u) f(u) - δ x T(u) fim-enquanto FIM-ALTERAR_FLUXOS 3

44 Problema do Fluxo Máximo Exemplo: 1, 1 a 1, 0, S 1, 0, P, 3, b 3, 3 3,, Marcação: δ(s) = + δ(b) = δ(a) = 1 δ(p) = 1 δ = 1 Y = {S} Y = {S, b} Y = {S, b, a} Y = {S, b, a, P} ( P,S ) A(S) = ( S,b ) A(b) = ( a,b ) A(a) = ( a,p ) A(P) = f(p,s) = f(a,p) = 1 f(a,b) = 0 f(s,b) = 3 f(s,a) = 1 f(b,p) = 3

45 Problema do Fluxo Máximo Exemplo: 1, 1 a 1, S 0, P 3, b 3, 3, Marcação: δ(s) = + δ(b) = 1 δ = 0, P Y Y = {S} Y = {S, b} FIM

46 Problema do Fluxo Máximo Exemplo: δ(1) = + δ() = 0 δ(6) = 1 δ() = 1 δ = 1 Y = {1} Y = {1, } Y = {1,, 6} Y = {1,, 6, } (,1 ) = A(1) ( 1, ) = A() (,6 ) = A(6) ( 6, ) = A() f(6,) = 1 f(,6) = 1 f(1,) = 1 f(,1) = 1 6

47 Problema do Fluxo Máximo Exemplo: δ(1) = + δ(3) = 10 δ() = 9 δ(8) = 9 δ() = 8 δ = 8 Y = {1} (,1 ) = A(1) Y = {1, 3} ( 1,3 ) = A(3) Y = {1, 3, } ( 3, ) = A() Y = {1, 3,, 8} (,8 ) = A(8) ( 8, ) = A() Y = {1, 3,, 8, } f(8,) = 8 f(,8) = 8 f(3,) = 8 f(1,3) = 8 f(,1) = 3

48 Problema do Fluxo Máximo Exemplo: δ(1) = + δ() = δ(3) = δ() = δ() = δ = (,1 ) = A(1) Y = {1} ( 1, ) = A() Y = {1, } (,3 ) = A(3) Y = {1,, 3} ( 3, ) = A() Y = {1,, 3, } (, ) = A() Y = {1,, 3,, } f(,) = f(3,) = f(,3) = f(1,) = 0 f(,1) = 8 8

49 Problema do Fluxo Máximo Exemplo: δ(1) = + δ(3) = δ() = δ() = δ = Y = {1} Y = {1, 3} Y = {1, 3, } Y = {1, 3,, } (,1 ) = A(1) ( 1,3 ) = A(3) ( 3, ) = A() (, ) = A() f(,) = f(3,) = f(1,3) = 10 f(,1) = 30 9

50 Problema do Fluxo Máximo Exemplo: δ(1) = + δ = 0, P Y Y = {1} FIM 0

51 Problema do Fluxo Máximo Teorema do Corte Mínimo Um conjunto de arcos C é chamado de corte separando P de S se Y X com S Y e P Y tal que C = { u U: I(u) Y, T(u) Y } Um corte separando P de S corta qualquer caminho de S a P no grafo G = (X,U). Capacidade de um corte separando P de S: ( c(u c(c) = u C 1

52 Problema do Fluxo Máximo " Teorema: f S P f P S S P Y Y f(p,s) c(c) fluxo viável f corte C ) ( ) ( ) ( ), ( 0 ), ( C c u c u f f S P f f S P f f f C u C u sp ps ps sp = = + =

53 Problema do Fluxo Máximo Corolário: Quando o algoritmo de rotulação termina com um fluxo f sem que seja possível marcar o nó P, f é a solução ótima do problema de fluxo máximo de S a P. Y u Y ( T(u P Y f(u) = c(u), senão a extremidade u estaria marcada Y u Y ( I(u f(u) = 0, senão a extremidade u estaria marcada 3

54 Problema do Fluxo Máximo Corolário: Se as capacidades são inteiras, então o algoritmo de Ford e Fulkerson obtém em um número finito de iterações uma solução ótima do problema de fluxo máximo.

55 Problema do Fluxo Máximo Teorema: O valor do fluxo máximo é igual à capacidade do corte mínimo separando P de S. Ao final do procedimento de rotulação: Y Y ( f*(p,s f SP = f PS + S f PS f SP P f PS = 0 ( c(c f SP = ( c(c f*(p,s) = ( c(c f(p,s) ( f*(p,s corte é mínimo.

56 Problema do Fluxo Máximo Exemplo: Corte mínimo Capacidade = 30 Fluxo máximo = 30 δ(1) = + Y = {1} δ = 0, P Y FIM 6

57 ÁRVORES PROGRAMAÇÃO GERADORAS DE TRIPULAÇÕES MÍNIMAS

58 Introdução Árvore Geradora Mínima AGM (Minimum Spanning Tree MST) Um dos problemas de otimização mais simples e mais bem estudados em Ciência da Computação e Teoria dos Grafos Objetivos Obtenção de uma árvore em um grafo conexo, com arestas valoradas, de tal forma que a soma dos custos das arestas seja mínimo

59 Principais Algoritmos Algoritmo de Boruvka (196) O. Boruvka. O jistém problému minimálním. Práca Moravské Prirodovedecké Spolecnosi, 3 (196), 3-8. (In Czech.) Algoritmo de Kruskal (196) J.B. Kruskal. On the shortest spanning tree of a graph and the traveling salesman problem. Proceedings of the American Mathematical Society, :8-0, 196. Algoritmo de Prim (19) R.C. Prim. Shortest connection networks and some generalizations. Bell Systems Technology Journal, 36: , 19.

60 ÁRVORES GERADORAS MÍNIMAS PROGRAMAÇÃO ALGORITMO DE TRIPULAÇÕES DE BORUVKA

61 Algoritmo de Boruvka Primeiro algoritmo proposto para resolução do Problema da Árvore Geradora Mínima Surgiu em 196 antes dos primeiros computadores e da publicação do primeiro livro sobre teoria dos grafos (1936) Seu propósito era fornecer uma cobertura elétrica eficiente para a cidade de Bohemia Método ideal para implementação em computadores paralelos

62 Algoritmo de Boruvka Seja um grafo G(N, A), onde N é o conjunto de nós e A o conjunto de arestas Passo 1: Para cada i N faça N i { i } Passo : T* {} Passo 3: Enquanto T* < (n-1) faça Ø Para cada árvore N k faça min(n k, i k, j k ) Ø Para cada árvore N k faça Se os nós i k e j k pertencem a árvores diferentes então unir(i k, j k ) e atualizar T* T* {(i k, j k )}

63 Algoritmo de Boruvka

64 ÁRVORES GERADORAS MÍNIMAS PROGRAMAÇÃO ALGORITMO DE TRIPULAÇÕES DE KRUSKAL

65 Algoritmo de Kruskal Idéia do algoritmo: Aresta de menor peso sempre pertence à árvore geradora de peso mínimo Complexidade: O(A * log A) Gargalo: ordenação das arestas

66 Algoritmo de Kruskal Criar uma lista L com as arestas ordenadas em ordem crescente de pesos. Criar V subárvores contendo cada uma um nó isolado. F contador 0 Enquanto contador < V -1 e L faça Seja (u,v) o próximo arco de L. L L {(u,v)} Se u e v não estão na mesma subárvore então F F {(u,v)} Unir as subárvores que contêm u e v. contador contador + 1 fim-se fim-enquanto

67 Algoritmo de Kruskal

68 Variação do Algoritmo de Kruskal Idéia do algoritmo: Se a aresta de menor peso sempre pertence à árvore geradora de peso mínimo, então a aresta de maior peso não pertence, se o número de arestas for maior que n-1 Complexidade: O(A*log A) Gargalo: ordenação das arestas

69 Variação do Algoritmo de Kruskal Criar uma lista L com as arestas ordenadas em ordem decrescente de pesos. F L contador 0 Enquanto contador < A - V -1 e L faça Seja (u,v) o próximo arco de L. L L {(u,v)} Se (u,v) não é ponte então F F - {(u,v)} contador contador + 1 fim-se fim-enquanto

70 Variação do Algoritmo de Kruskal

71 Algoritmo de Kruskal Principais desvantagens: O método exige uma etapa preparação, por exemplo, em caso de representação por listas de adjacência Grande consumo de memória

72 ÁRVORES GERADORAS MÍNIMAS PROGRAMAÇÃO ALGORITMO DE TRIPULAÇÕES DE PRIM

73 Algoritmo de Prim Idéia do algoritmo: Inicia com uma árvore formada apenas por um nó qualquer do grafo, ou pela aresta de peso mínimo. A cada iteração, adiciona a aresta de menor peso que conecta um nó já conectado a um nó ainda não conectado Complexidade: O(A*log N) = O(A*log A) Usando Heap de Fibonacci: O(A + N*log N)

74 Algoritmo de Prim Seja (u,v) a aresta de menor peso. F {(u,v)} Para i = 1,...,n faça Se c(i,u) < c(i,v) então prox(i) u Senão prox(i) v fim-para prox(u), prox(v) 0, contador 0 Enquanto contador < n- faça Seja j tal que prox(j) 0 e c(j,prox(j)) é mínimo. F F {(j,prox(j))} prox(j) 0 Para i = 1,...,n faça Se prox(i) 0 e c(i,prox(i)) > c(i,j) então prox(i) j fim-para contador contador + 1 fim-enquanto

75 Algoritmo de Prim

76 ÁRVORES GERADORAS MÍNIMAS PROGRAMAÇÃO OTIMIZAÇÕES DE TRIPULAÇÕES

77 Implementações Variação na estrutura de dados utilizada: Prim usando Pairing Heap Prim usando Fibonacci Heap Prim usando Binary Heap

78 Pairing Heap x Fibonacci Heap Operação Complex. Real Complexidade Amortizada Pairing Heap Fibonacci Heap isempty O(1) O(1) O(1) size O(1) O(1) O(1) getmax O(1) O(1) O(1) put O(1) O(log n) ** O(1) removemax O(n) O(log n) O(log n) meld O(1) O(log n) ** O(1) remove O(n) O(log n) O(log n) increasekey O(n) O(log n) ** O(1)

79 Resultados de Moret e Shapiro (1991) Grafos esparsos 1) Binary Heap ) Fibonacci Heap 3) Slay tree ) Rank-relaxed Heap ) Pairing Heap

80 Resultados de Moret e Shapiro (1991) Grafos com A = N * log N 1) Binary Heap ) Fibonacci Heap 3) Slay tree ) Rank-relaxed Heap ) Pairing Heap

81 Resultados de Moret e Shapiro (1991) Grafos com A = N 3/ (grafos densos) 1) Binary Heap ) Fibonacci Heap 3) Slay tree ) Rank-relaxed Heap ) Pairing Heap

82 Resultados da Literatura Moret e Shapiro (1991) fazem uma série de experimentos envolvendo vários algoritmos e estruturas de dados para gerar uma AGM. Nos testes foram utilizadas diferentes estruturas e densidades de grafos Foi feita uma análise tanto de desempenho quanto de consumo de espaço em memória

83 Resultados da Literatura Consumo de memória

84 Resultados da Literatura Tempo de execução

85 Perguntas? 8