Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Like this document? Why not share!

Like this? Share it with your network

Share

Caminhos Mínimos: Dijkstra e Floyd-Warshall

  • 9,052 views
Uploaded on

Otimização e Implementação dos Algoritmos de Caminhos Mínimos: Dijkstra e Floyd-Warshall. ...

Otimização e Implementação dos Algoritmos de Caminhos Mínimos: Dijkstra e Floyd-Warshall.

Este trabalho obteve a primeira colocação na 1ª Competição de Caminhos Mínimos do DECOM/UFOP.

More in: Education , Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
9,052
On Slideshare
9,052
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
315
Comments
0
Likes
2

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Universidade Federal de Ouro PretoInstituto de Ciências Exatas e Biológicas Departamento de Computação TEORIA DOS GRAFOS Primeiro Trabalho Prático Caminhos Mínimos Johnnatan Messias P. Afonso Kayran dos Santos Vítor Mangaravite Professor - Haroldo Gambini Santos Ouro Preto 25 de outubro de 2010
  • 2. Sumário1 Introdução 1 1.1 Considerações iniciais . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Especicações da máquina . . . . . . . . . . . . . . . . . . . . . . . . 1 1.3 Especicação do problema . . . . . . . . . . . . . . . . . . . . . . . . 1 1.3.1 Material a ser entregue . . . . . . . . . . . . . . . . . . . . . . 1 1.3.2 Documentação impressa incluindo . . . . . . . . . . . . . . . . 2 1.3.3 Regras de Implementação . . . . . . . . . . . . . . . . . . . . 2 1.3.4 Problemas Teste . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.3.5 Formato de Entrada e Saída e Parâmetros . . . . . . . . . . . 3 1.4 Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.4.1 Heaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.4.2 Aplicação do Algoritmo . . . . . . . . . . . . . . . . . . . . . 5 1.4.3 Versão Preliminar x Final . . . . . . . . . . . . . . . . . . . . 5 1.5 Floyd-Warshall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.5.1 Aplicação do Algoritmo . . . . . . . . . . . . . . . . . . . . . 6 1.5.2 Versão Preliminar x Final . . . . . . . . . . . . . . . . . . . . 62 Algoritmo e estruturas de dados 7 2.1 Grafo do Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.1.1 Função CriaGrafoPorNome . . . . . . . . . . . . . . . . . . . . 7 2.1.2 Função ConstruindoLista . . . . . . . . . . . . . . . . . . . . . 8 2.1.3 Função AddInteração . . . . . . . . . . . . . . . . . . . . . . . 9 2.2 Heap Binária . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.2.1 Inicialização da heap . . . . . . . . . . . . . . . . . . . . . . . 10 2.2.2 Remove menor . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.3 Diminui . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.4 Tamanho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.3 Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.3.1 Função Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.3.2 Função DijkstraP . . . . . . . . . . . . . . . . . . . . . . . . . 13 2.3.3 Função Main para o Dijkstra . . . . . . . . . . . . . . . . . . . 14 2.4 Grafo do Floyd-Warshall . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.4.1 Função CriaGrafoPorNome . . . . . . . . . . . . . . . . . . . . 16 2.4.2 Função alocaMatriz . . . . . . . . . . . . . . . . . . . . . . . . 17 2.4.3 Função iniciaMatriz . . . . . . . . . . . . . . . . . . . . . . . . 19 2.4.4 Função iniciaPred . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.5 Floyd-Warshall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.5.1 Função oydP . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.5.2 Função oyd . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.5.3 Função oydPNeg . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.5.4 Função oydNeg . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.5.5 Função imprimirsalvar . . . . . . . . . . . . . . . . . . . . . . 23 2.5.6 Função mainF . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 2
  • 3. 3 Testes 27 3.1 Exemplo de teste para o Floyd-Warshall . . . . . . . . . . . . . . . . 27 3.1.1 Grafo com Peso Positivo . . . . . . . . . . . . . . . . . . . . . 27 3.1.2 Grafo com Peso Negativo . . . . . . . . . . . . . . . . . . . . . 29 3.2 Testes em massa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 3.2.1 Floyd-Warshall . . . . . . . . . . . . . . . . . . . . . . . . . . 31 3.2.2 Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344 Conclusão 36Lista de Figuras 1 Figura Repres. Alocação Matriz . . . . . . . . . . . . . . . . . . . . . 18 2 Figura Grafo com Peso Positivos . . . . . . . . . . . . . . . . . . . . 27 3 Figura Matriz Dist . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4 Figura Matriz Pred . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 5 Figura Exemplo de Caminho . . . . . . . . . . . . . . . . . . . . . . . 28 6 Figura Grafo com Peso Negativo . . . . . . . . . . . . . . . . . . . . . 29 7 Figura Matriz Dist . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 8 Figura Matriz Pred . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 9 Figura Exemplo de Caminho Neg . . . . . . . . . . . . . . . . . . . . 30 10 Graco para Floyd-Warshall sobre o grafo rg300_768 . . . . . . . . . 31 11 Graco para Floyd-Warshall sobre o grafo rg300_4730 . . . . . . . . 32 12 Graco para Floyd-Warshall sobre o grafo comp-2007-2-22c . . . . . . 33 13 Graco para Dijkstra sobre o grafo rome99c . . . . . . . . . . . . . . 34 14 Graco para Dijkstra sobre o grafo USA-road-d-NYc . . . . . . . . . 35Lista de Programas 1 Algoritmo Floyd Warshall C . . . . . . . . . . . . . . . . . . . . . . . 5 2 TAD Grafo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3 Função CriaGrafoPorNome para o dijkstra . . . . . . . . . . . . . . . 7 4 Função ConstruindoLista . . . . . . . . . . . . . . . . . . . . . . . . . 8 5 Função ConstruindoLista . . . . . . . . . . . . . . . . . . . . . . . . . 9 6 TAD Grafo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 7 Criação da heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 8 Inicialização da heap . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 9 Remove Menor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 10 Decrementa Chave . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 11 Tamanho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 12 Fijkstra sem Impressão . . . . . . . . . . . . . . . . . . . . . . . . . . 12 13 Dijkstra com Impressão . . . . . . . . . . . . . . . . . . . . . . . . . . 13 14 Programa principal do Dijkstra . . . . . . . . . . . . . . . . . . . . . 14 15 TAD Grafo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 16 Função criagrafopornome . . . . . . . . . . . . . . . . . . . . . . . . . 16 17 Função alocaMatriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 18 Função iniciamatriz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 3
  • 4. 19 Função iniciaPred . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 20 Função oydP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 21 Função oyd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 22 Função oydPNeg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 23 Função oydNeg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 24 Função imprimirsalvar . . . . . . . . . . . . . . . . . . . . . . . . . . 23 25 Função mainF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 26 Programa de Teste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38Lista de Tabelas 1 Instâncias de teste e algoritmos a executar . . . . . . . . . . . . . . . 2 4
  • 5. 1 Introdução A computação tem como base a resolução de problemas que até então não haviasoluções disponíveis bem como para soluções rápidas para o mesmo problema. Assim, cabe ao Cientista da Computação identicar soluções para a resoluçãodos problemas, principalmente, tornando-os otimizados e rápidos. Através dessesconceitos coube ao grupo utilizar os conceitos de Teoria dos Grafos para a modelagemdo trabalho. Na teoria de grafos, o problema do caminho mínimo consiste na minimização docusto de travessia de um grafo entre dois nós (ou vértices). Custo este dado pelasoma dos pesos de cada aresta percorrida. Formalmente, dado um grafo valorado (ou seja, um conjunto V de vértices, umconjunto A de arestas e uma função de peso f : A → R) e, dado qualquer elementov ∈V, encontrar um caminho P de v para cada v ∈ V tal que p∈P f (p) é mínimoentre todos os caminhos conectando n a n.1.1 Considerações iniciais • Ambiente de desenvolvimento do código fonte: Microsoft Visual Studio C 10.0, NetBeans 6.9.1. • Compilador: gcc 4.4.5. • Linguagem utilizada: Linguagem C. • Ambiente de desenvolvimento da documentação: TeXnicCenter 1 BETA 7.50- A Editor de L T X, Editor dos grafos: R-2.12.0 for windows. E1.2 Especicações da máquina • Intel Pentium IV 3.0 GHz, 64 bits • Memória: 2 GB • Ubuntu 10.10 AMD 64, kernel 2.6.35-22 generic1.3 Especicação do problema1.3.1 Material a ser entregue Código em C, incluindo instruções para compilação. Essas instruções podem,por exemplo, indicar opções que devem ser usadas na compilação do código em C.(ex.: -O2 -ast-math). Devem ser oferecidas as seguintes implementações: • Algoritmo de Dijkstra para para computação de c.m. de uma fonte para todos os outros vértices; → a fonte deve ser sorteada com a função rand a cada execução do algoritmo de Dijkstra dentro do programa. 1
  • 6. • Algoritmo Floyd-Warshall (FW) para computação dos caminhos mínimos de todos os vértices para todos os outros do grafo; → a implementação de FW deve incluir um teste para a existência de ciclos de custo negativo no grafo. Caso um seja encontrado, o algoritmo deve concluir imediatamente sua execução e indicar o ciclo encontrado.1.3.2 Documentação impressa incluindo • explicação da implementação, incluindo referências bibliográcas; • tabelas contendo os resultados dos experimentos realizados1.3.3 Regras de Implementação Os códigos devem ser escritos em C, sem o uso de bibliotecas adicionais, excetoa biblioteca padrão da linguagem ou da biblioteca GNU. Os seguintes padrões* C são aceitos: • ANSI C 89 • ANSI C 99 • GNU C *O compilador GCC permite a compilação com validação de códigos com a ag-std. Ex.: (-std=c99). Códigos com vazamento de memória ou problemas do tipo serão penalizados com-1 pontos. Os códigos serão testados com a ferramenta valgrind.1.3.4 Problemas Teste Instância Vértices Arestas Testar rome99c.gr 3.353 8.859 Dijkstra USA-road-d.NYc.gr.bz2 264.346 730.100 Dijkstra rg300_768.gr 300 768 Floyd-Warshall rg300_4730.gr 300 4.730 Floyd-Warshall comp-2007-2-22c.gr.gz 600 276.666 Floyd-Warshall Tabela 1: Instâncias de teste e algoritmos a executar • soluções devem ser checadas; caminhos mínimos pré-computados para rome99: spathsRome99c.gr.bz2 (lembre-se que entre dois nós pode haver mais de um caminho ótimo possível). outros: nspathsRg300_768.txt.bz2 . • alguns problemas vieram da competição do DIMACS. • os problemas teste para o algoritmo Floyd-Warshall (FW) podem incluir val- ores negativos nos custos dos arcos. A implementação de FW, quando encon- trar um ciclo de custo negativo, deve abortar a computação e como saída deve somente indicar o caminho que indica o ciclo de custo negativo encontrado. * 2
  • 7. 1.3.5 Formato de Entrada e Saída e Parâmetros O programa deve receber os seguintes argumentos, quando chamado pela linhade comando: prog <arquivoProblema> <nrExecuções> <flagDepuração> Onde <flagDepuração> pode receber valor 0 ou 1. Como exemplo: prog rome99.gr 1000 1 Indica que o programa irá ler o grafo do arquivo rome99.gr, executando o algo-ritmo de caminhos mínimos 1000 vezes e ao nal irá imprimir/salvar informação dedepuração. A informação de depuração que deve ser gerada, quando solicitada, é a seguinte: arquivo spaths.txt O arquivo spaths.txt deve conter todos os caminhos mínimos computados paracada par de vértices (s,t), sendo s diferente de t . Cada linha contém a informaçãosobre o caminho mínimo de um par (s,t), no formato: [s,t](dist) n1 n2 n3 ... nn Onde: • s: nó fonte • t: nó destino • dist: distância calculada entre s e t • n1 n2 n3 ... nn: caminho computado entre s e t, incluindo todos os nós intermediários no formato: s n2 n3 ... t1.4 Dijkstra O algoritmo de dijkstra para caminhos mínimos foi feito por Edsger W. Dijkstraem 1956 e foi publicado em 1959. Este algoritmo é um algoritmo de busca emgrafos que resolve o problema de caminhos mínimos para grafos sem ciclos de custonegativo [5]. O algoritmo de dijkstra é um algoritmo guloso, pois toma uma decisão queparece ser a melhor no momento. Dado um nó fonte ele calcula o caminho demenor distancia deste nó a todos os outros. Ele funciona semelhante ao BFS, porémtrata grafos com peso. Ele trata os nós mais próximos da fonte primeiro, porémessa proximidade se refere ao peso entre as arestas e não ao número de arestaspercorridas. Sua complexidade é O((|E| + |V |)log|V |)[5]. Para a execução do algoritmo são utilizados dois vetores auxiliares (dist epred) com tamanho igual ao numero de vértices do grafo. O vetor dist armazenaráas distancias do nó fonte até qualquer nó do grafo. O vetor pred armazenará osanteriores de cada nó no caminho da fonte até ele. Além disso é necessária umaheap para saber a ordem de processamento dos nós. Ao inicio da execução do algoritmo o vetor de distancias é inicializado com innitopara todos os vértices, exceto o nó fonte s que terá distancia 0. O vetor pred serátodo inicializado com nulo. O algoritmo processa todos os nós da heap. Enquantoainda há nós na heap retira-se o menor vértice (u) e, para cada vizinho v vérticeverica se a distancia até v passando por u é menor que a distancia até v já calculada.Caso seja menor u é marcado como antecessor de v no vetor pred e a distancia 3
  • 8. até v é alterada para a distancia até u mais a distancia entre u e v, atualizando aheap com a nova distancia. As operações que são mais custosas para o algoritmo do dijkstra são as operaçõessobre a heap, portanto uma escolha errada de heap pode causar ineciência doalgoritmo.1.4.1 Heaps Heaps são las de prioridade implementadas baseadas em árvores. Existem ba-sicamente dois tipos de heap, a heap de máximo, em que para cada nó x na arvore,x tem chave maior que de todos seus lhos[2], e a heap de mínimo que é utilizada noalgoritmo de dijkstra, em que cada nó x pai sempre é menor que todos seus lhos. As heaps para o dijkstra possuem como chave os valores de distancia do vérticefonte até os respectivos nós. A medida que a distancia encontrada diminui para cadanó, sua prioridade aumenta e sua vez de ser processado se aproxima, congurandouma heap de mínimo. As funções básicas de uma heap qualquer são: • Inserção • deleção de menor • decremento da chave Heaps de Fibonacci: Para a versão nal foi feita uma tentativa de implementação da heap de bonacci[7].As heaps de bonacci são coleções de árvores ordenadas como heaps mínimos[6]. Asheaps de bonacci são implementadas usando listas circulares duplamente encadeadas[1].A heap é composta da lista de raízes e para cada nó da lista de raízes tem uma listade lhos que também pode ter seus lhos, assim em diante. A heap também temum ponteiro para o menor nó da lista. A inserção na heap de bonacci apenas insere o novo nó na lista de raízes. Ainserção verica se o novo nó é menor que o menor atual, caso seja o menor passa aser o novo. Esse procedimento é executado com custo real O(1). Na função de extração do menor nó, o nó apontado por min é removido dalista de raízes e todos seus lhos são inseridos na lista de raízes. Depois a heap éconsolidada, o que signica que todas as raízes terão grau (numero de lhos na lista)diferente. Caso haja mais de um nó com um certo grau, o maior deles vira lho dooutro. A menor das raízes passa a ser o novo min. O custo amortizado da funçãode extração de menor é O(logn). A diminuição da chave pode fazer com que um lho que menor que seu pai,ferindo a propriedade das heaps. Caso isso ocorra este nó é cortado do pai e levadoà lista de raízes. Caso o pai seja lho de outro nó e já tenha perdido um lho sendolho desde que virou lho de seu nó pai, ele também será cortado de seu pai e viraráraiz da heap, senão apenas será marcado para ser cortado se perder mais lhos. Seo nó decrementado for menor que a raiz, este passará a ser o novo minimo. O custoamortizado desta função é O(1). As heaps de bonacci possuem uma estrutura muito complexa, contendo listascirculares duplamente encadeadas. Isso dicultou bastante a implementação nãopermitindo que fosse encerrada a versão do dijkstra usando essas heaps em tempo 4
  • 9. hábil, pois para cada nó há apontador para seu pai, seu irmão da esquerda, seu irmão da direita e todos seus lhos. Acredita-se que essas heaps poderiam melhorar ainda mais o algoritmo do dijkstra devido à sua boa complexidade. Com as heaps 2 binarias a ordem de complexidade do dijkstra se aproxima muito de O(n logn), com 2 heaps de bonacci essa complexidade aproximaria O(n ). 1.4.2 Aplicação do Algoritmo 1.4.3 Versão Preliminar x Final Para o problema proposto a cada nó da heap é representado pelo índice de seu vértice no grafo, índice esse que é usado para a identicação da distancia do nó no vetor dist, valor este que é a chave do nó. A função diminui recebe o índice do nó que foi alterado, porém não é conhecido seu posicionamento na heap. Para saber qual nó da heap foi alterado de inicio foi feita uma busca linear O(n) em todo o vetor da heap, versão que foi enviada na preliminar da competição. Para a versão nal essa busca linear foi substituída pela busca em hash que é O(1). Como os possíveis valores da heap são conhecidos (1 até n) e também seu tamanho máximo (n), foi possível fazer um hash mínimo perfeito. Para isso foi criado um novo vetor pos, que para cada posição i deste vetor, seu valor corresponde à posição do vértice i do grafo no vetor da heap. 1.5 Floyd-Warshall O algoritmo de Floyd-Warshall tem como objetivo calcular a menor distância de todos os vértices do grafo para todos os demais, recebendo, para isso, uma matriz de adjacências representando o grafo. Com ordem de complexidade cúbica assume que para percorrer o caminho A→C haverá um caminho A → B e B → C , isto é, para qualquer par de vértices (i, j) ∈ V , considera-se todos os caminhos de iaj cujos vértices intermediários pertencem ao subconjunto 1, 2, 3..., k , e p como o mais curto de todos eles. Em resumo: dist(i; j; k): o comprimento do caminho mais curto entre i e j tal que apenas os nós 1, ..., k podem ser usados como intermediários. No Programa 1 temos o algoritmo implementado em C. void ∗ ∗∗ int f l o y d ( TGrafo g , TVertice auxMatriz ) { int ∗∗ k, i , j ; pred ; pred = NULL ; 5 −>q t d V e r t ) ) ; for pred = i n i c i a P r e d ( pred ,&( g −>q t d V e r t ; i ++) for ( i =0; i < g ( j = 0 ; j <g− >q t d V e r t ; j ++) a u x M a t r i z [ i ] [ j ] = g− for >m a t r i z [ i ] [ j ] ; ( k = 0 ; k < g− for >q t d V e r t ; k++)10 i < g− for ( i = 0; >q t d V e r t ; i ++) j < g− if ( j = 0; >q t d V e r t ; j ++) ( ( auxMatriz [ i ] [ k ] . peso + auxMatriz [ k ] [ j ] . peso ) < auxMatriz [ i ] [ j ] . peso ) { auxMatriz [ i ] [ j ] . peso = auxMatriz [ i ] [ k ] . peso + auxMatriz [ k ] [ j ] . peso ; if pred [ i ] [ j ] = pred [ k ] [ j ] ;15 ( auxMatriz [ i ] [ i ] . peso < 0) { 5
  • 10. return ; } } f r e e ( pred [ 0 ] ) ;20 f r e e ( pred ) ; } Programa 1: Algoritmo Floyd Warshall C 1.5.1 Aplicação do Algoritmo O algoritmo de Floyd-Warshall pode ser utilizado para os seguintes problemas: • Caminhos mais curtos em grafos orientados (algoritmo de Floyd); • Proximidade transitiva de grafos orientados (algoritmo de Warshall); • Encontrar uma expressão regular denotando a linguagem regular aceita por um autômato nito (algoritmo de Kleene); • Inversões de matrizes de números reais (algoritmo de Gauss-Jordan); • Roteamento otimizado. Nesta aplicação, o objetivo é encontrar o caminho com o máximo uxo entre dois vértices. Isto signica que, em vez de calcular o mínimo, calcula-se o máximo; • Testar se um grafo não-orientado é bipartido. 1.5.2 Versão Preliminar x Final Reinicialização das Matrizes: • Preliminar: Na versão preliminar havia um erro no algoritmo de modo que as matrizes de distâncias e dos predecessores não eram reinicializadas quando o usuário passava como argumento um número inteiro superior a uma execução. Através disso as matrizes não eram reinicializadas a partir da 1 execução. Esse problema afetava a execução do programa somente quando não havia impressão ou quando o número de execuções fosse superior a 1 (um). • Final: Para melhorar o desempenho bem como corrigir o problema anterior alocamos tanto a matriz de distâncias quanto a dos predecessores antes de chamar a função do algoritmo Floyd-Warshall e desalocando no nal da ex- ecução de todo o programa, assim possibilitou em um ganho de desempenho quando levarmos em consideração a alocação das matrizes. Um ponto importante a ser citado é que mesmo não alocando e desalocando a todo execução sempre reinicializamos as duas matrizes. Isso pode ser percebido no Programa 17 Tratamento do Ciclo Negativo: • Preliminar: Não havia uma otimização no tratamento de ciclos negativos, assim, em cada execução o algoritmo vericava se havia ou não ciclos negativos no grafo. 6
  • 11. • Final: Para otimizar o tratamento de ciclos negativos foi incluída na estrutura 15 do grafo uma variável ehcicloNeg que verica na entrada de arquivos, vide Programa 16, se no grafo continha ou não peso negativo. Através dessa veri- cação, para otimizar, criamos diferentes funções para o algoritmo de Floyd- Warshall, sendo para grafos com ciclos negativos: oydPNeg, oydNeg, vide Programas 22, 23 respectivamente . E para positivos: oydP, oyd, vide Programas 20, 21 respectivamente. Nessas funções não realizamos a vericação para caso haja ciclo negativo uma vez que o grafo não contém determinado ciclo[3]. Obs.: Na Seção 2.4 explicaremos melhor esse método. 2 Algoritmo e estruturas de dados 2.1 Grafo do Dijkstra O grafo para o algoritmo de dijkstra foi representado pela lista de adjacências apresentada na estrutura 2 #include " s t d a f x . h" typedef struct int { qtdusada , ∗ resultado ; 5 } Caminho ; typedef struct int ∗ { vizinhos , ∗ pesos , qtdAlloc , qtdFree ; } TVertice ;10 typedef struct int { qtdVert , qtdMedia ; TVertice ∗ v; } TGrafo ;15 TGrafo cria_grafo_por_nome ( char ∗ ) ; void i m p r i m i r _ s a l v a r ( Caminho ∗) ;20 void construindoLista ( int ∗ int ∗, , TGrafo ∗) ; void addInteracao ( int ∗ int ∗ , , TGrafo ∗, int ∗ ) ; Programa 2: TAD Grafo 2.1.1 Função CriaGrafoPorNome A Função CriaGrafoPorNome tem como objetivo fazer a leitura do grafo a partir de um arquivo .txt e iniciar a lista de adjacências bem como instanciar a lista com todos arcos do grafo de um vértice A para um vértice B. Vide Programa 3 TGrafo cria_grafo_por_nome ( char ∗ nome ) { 7
  • 12. ∗ arqE ; char FILE ∗ buf , ∗ tok ; 5 int TGrafo g; char ∗ sizeof char numArestas , numVertices , vA , vB , peso , media_qtd_arestas ; buf = ( ) malloc ( ( ) ∗ BUFSIZ ) ; arqE = f o p e n ( nome , "r") ;10 if ( ! arqE ) { printf ( " Erro ao a b r i r o a r q u i v o de e n t r a d a %s " , nome ) ; g . q t d V e r t = − 1; return (g) ; while }15 ( ! f e o f ( arqE ) ) { if buf = f g e t s ( buf , BUFSIZ , arqE ) ; break ( buf == NULL) ;20 switch case p ( buf [ 0 ] ) { : tok = " ") ; s t r t o k ( buf , tok = s t r t o k (NULL, " ") ; tok = s t r t o k (NULL, " " ) ;25 numVertices = a t o i ( tok ) ; tok = s t r t o k (NULL, " ") ; numArestas = a t o i ( tok ) ; media_qtd_arestas = numArestas / numVertices + 1; break c o n s t r u i n d o L i s t a (& n u m V e r t i c e s , &m e d i a _ q t d _ a r e s t a s , &g ) ;30 case ; a : tok = s t r t o k ( buf , " ") ; tok = s t r t o k (NULL, " ") ; vA = a t o i ( tok ) ;35 tok = s t r t o k (NULL, " ") ; vB = a t o i ( tok ) ; tok = s t r t o k (NULL, " ") ; peso = a t o i ( tok ) ; break a d d I n t e r a c a o (&vA , &vB , &g , &p e s o ) ;40 default ; break : ; } }45 f c l o s e ( arqE ) ; return f r e e ( buf ) ; (g) ; } Programa 3: Função CriaGrafoPorNome para o dijkstra 2.1.2 Função ConstruindoLista A Função ConstruindoLista tem como objetivo inicializar a lista de adjacências para todos os nós. Vide Programa 4 void int ∗ int ∗ ∗ int construindoLista ( qtdV , m ed ia , TGrafo g) { i ; g−>q t d M e d i a = ∗ m e d i a ; g−>q t d V e r t = ∗ qtdV ; 8
  • 13. 5 −>v ∗ ) c a l l o c ( ∗ qtdV , sizeof for g = ( TVertice ( TVertice ) ) ; ( i = 0; i < ∗ qtdV ; i ++) { g−>v [ i ] . qtdAlloc = 0; −>v [ ∗ media ; int sizeof int g i ] . qtdFree = g− ∗ ) c a l l o c ( ∗ me d ia , int sizeof int >v [ i ]. vizinhos = ( ( )) ;10 g−>v [ i ]. pesos = ( ∗ ) c a l l o c ( ∗ m ed ia , ( )) ; } } Programa 4: Função ConstruindoLista 2.1.3 Função AddInteração A função AddInteração adiciona a interação lida do arquivo ao nó de origem da mesma. Vide Programa 5 void ∗ vA , int int ∗ vB , T G r a f o ∗ g , ∗ peso ) { int if addInteracao ( (!g−>v [ ( ∗ vA ) − 1 ] . q t d F r e e ) { g−>v [ ( ∗ vA ) − 1 ] . q t d F r e e + = g− int >q t d M e d i a ; g−>v [ ( ∗ vA ) − 1 ] . p e s o s = ( ∗ ) r e a l l o c ( g−>v [ ( ∗ vA ) − 1 ] . p e s o s , sizeof int ( ) ∗ ( g− >v [ ( ∗ vA ) − 1 ] . q t d F r e e + g− >v [ ( ∗ vA ) − 1 ] . int qtdAlloc ) ) ; 5 −>v [ ( ∗ vA ) − ∗ ) r e a l l o c ( g−>v [ ( ∗ vA ) − 1 ] . sizeof int g 1 ] . vizinhos = ( vizinhos , ( ) ∗ ( g−>v [ ( ∗ vA ) − 1 ] . q t d F r e e + g−>v [ ( ∗ vA ) − 1 ] . qtdAlloc ) ) ; } g−>v [ ( ∗ vA ) − 1 ] . vizinhos [ g −>v [ ( ∗ vA ) − 1 ] . qtdAlloc ] = ( ( ∗ vB ) − 1) ; g−>v [ ( ∗ vA ) − 1 ] . pesos [ g −>v [ ( ∗ vA ) − 1 ] . q t d A l l o c ++] = ∗ peso ; g−>v [ ( ∗ vA ) − 1 ] . q t d F r e e −−;10 } Programa 5: Função ConstruindoLista 2.2 Heap Binária A heap binaria é representada por uma árvore binária completa ou quase com- pleta. Para o caso do dijkstra, como a heap é mínima, o pai sempre é menor que seus lhos. Para representar a heap há duas estruturas possíveis, lista encadeada com ponteiros para os dois lhos e lista simples utilizando um vetor[8]. Na imple- mentação foi utilizada a segunda estrutura por ser mais simples de trabalhar. Vide Programa 6: #include "TGrafoD . h" typedef struct int ∗ ∗ Heap { v,∗ dist , pos , qtdV ; 5 } THeap ; int tamanho ( THeap ∗) ; void c r i a H e a p ( THeap int ∗ ∗, ) ;10 void reconstroi ( int int , , THeap ∗) ; void c o n s t r o i ( THeap ∗) ; 9
  • 14. 15 int p e g a r M e n o r ( THeap ∗) ; void d i m i n u i ( THeap ∗, int ∗ ) ; Caminho d i j k s t r a P ( TGrafo ∗, int ∗ ) ;20 void d i j k s t r a ( TGrafo ∗, int ∗ ) ; Programa 6: TAD Grafo Para representar uma árvore com vetor considera-se que para o vértice i seus lhos são (2 ∗ i + 1) e (2 ∗ i + 2), sendo sua raiz o nó de índice 0. O pai de um nó de índice i é representado pelo nó de índice ceil(i/2). 2.2.1 Inicialização da heap A função Criaheap 7 aloca todas os vetores da heap e inicializa seus valores para os esperados ao inicio do dijkstra. void ∗ int ∗ int c r i a H e a p ( THeap h, qtdD ) { i ; − ∗ qtdD ; int sizeof int h >qtdV = − ∗ ) c a l l o c ( ∗ qtdD , int sizeof int h >v = ( ( )) ; 5 h− d i s t = ( ∗ ) c a l l o c ( ∗ qtdD , int sizeof int > ( )) ; h− ∗ ) c a l l o c ( ∗ qtdD , for >p o s = ( ( )) ; ( i = 0; i < ∗ qtdD ; i ++) { h− d i s t [ i ] = INF ; > h− >v [ i ] = i ;10 h− >p o s [ i ] = i ; } } Programa 7: Criação da heap A Inserção para a heap binária consiste em colocar sua chave no vetor e refazer o posicionamento do nós no vetor seguindo os índices de forma a respeitar a pro- priedade da heap de que o pai é menor que todos os lhos. A ordem de complexidade da inserção é O(logn)[8]. Para o caso do dijkstra todos os nós são inseridos na heap logo no começo, para isso existe a função constrói que considera que as n/2 últimas posições do vetor já estão na heap, já que nenhuma posição representa o pai de outra já que i é pai de 2∗i+1 e 2∗i+2 e i é pai de n+1 e n+2, para i = n/2. Considerando isso os n/2 primeiros nós são inseridos na heap pela função reconstrói que verica a propriedade da heap, trocando o pai com seu menor lho, caso o lho seja menor que o pai. Na teoria são feitas n/2 inserções na heap, o que gera uma complexidade O(nlogn)[2]. Vide Programa 8 void ∗ int c o n s t r o i ( THeap h) { esq ; − while esq = h >qtdV / 2; ( e s q >= 0) { 5 r e c o n s t r o i ( esq , − h >qtdV − 1, h) ; esq −−; } }10 void reconstroi ( int esq , int dir , THeap ∗h ) { 10
  • 15. int int i = esq ; int j ; aux ; j = i ∗ 2 + 1;15 − while aux = h >v [ i ] ; if ( j <= dir ) { if ( j < dir ) − ( h > d i s t [ h >v [ j ] ]− > − − h > d i s t [ h >v [ j + 1]]) if j ++;20 − − − break ( h > d i s t [ aux ] <= h > d i s t [ h >v [ j ] ] ) ; − h >p o s [ h >v [ j ] ] − = i ; − h >v [ i ] − = h >v [ j ] ; i = j ;25 j = i ∗ 2 + 1; } − h >p o s [ aux ] = i ; − h >v [ i ] = aux ; } Programa 8: Inicialização da heap 2.2.2 Remove menor A remoção do menor é feita pegando sua chave e o trocando com o ultimo elemento válido do vetor, que será a folha extrema direita da árvore. Após isso a heap é refeita com a função reconstrói desconsiderando a posição onde estava o ultimo. Sua complexidade é O(logn)[8].Vide Programa 8 int ∗ int p e g a r M e n o r ( THeap h) { min ; − min = h >v [ 0 ] ; − h >v [ 0 ] = h− >v [( −− h−>qtdV ) ]; 5 h− >p o s [ h− >v [ 0 ] ] = 0 ; r e c o n s t r o i ( 0 , h− >qtdV − 1 , return h) ; min ; } Programa 9: Remove Menor 2.2.3 Diminui Para decrementar a chave, já que o dijkstra já altera o valor do vetor dist, a função apenas verica se o elemento com chave alterada fere a propriedade da heap e o troca com seu pai em caso armativo. Isso é feito até que a propriedade volte a ser obedecida pelo nó alterado. Vide Program 10 void ∗h , int ∗ int d i m i n u i ( THeap i ) { aux , pos ; pos − = h >p o s [ ∗ i ]; 5 while ( ( p o s ) >= 1 & − & h > d i s t [ h >v [ ( − int ) c e i l ( ( pos ) / 2.) − 1]] > h −> d i s t − int [ h >v [ ( p o s ) ] ] ) { aux = h−>v [ ( ) c e i l ( ( pos ) / 2.) − 1]; 11
  • 16. − int − − int int h >v [ ( ) c e i l ( ( pos ) / 2.) 1] = h >v [ ( p o s ) ] ;10 − h >p o s [ h >v [ ( − ) c e i l ( ( pos ) / 2.) − 1]] = ( ) c e i l ( ( pos ) / 2.) − 1; − h >v [ ( p o s ) ] = aux ; − int h >p o s [ aux ]= p o s ; pos = ( ) c e i l ( ( pos ) / 2.) − 1; }15 } Programa 10: Decrementa Chave 2.2.4 Tamanho Esta função apenas retorna o tamanho da heap. Usada para vericar a existencia de elementos na heap. Vide Programa 11 int ∗ return tamanho ( THeap h) { − h >qtdV ; } Programa 11: Tamanho 2.3 Dijkstra 2.3.1 Função Dijkstra Essa função é responsável pela simples execução do algoritmo de Dijkstra sem impressão de caminho. void d i j k s t r a ( TGrafo ∗ g , int ∗ s) { int THeap h; v, u, i , ∗ prev ; 5 prev = ( int ∗ ) calloc (g −>q t d V e r t , sizeof int ( )) ; c r i a H e a p (&h , &(g −>q t d V e r t ) ) ; h. dist [ ∗s] = 0; c o n s t r o i (&h ) ;10 while ( tamanho (&h ) ) { for v = p e g a r M e n o r (&h ) ; ( i = 0; i < g −>v [ v ] . qtdAlloc ; i ++) { −>v [ v ] . if u = g vizinhos [ i ] ; (h . dist [ u ] > h. dist [v] + g −>v [ v ] . pesos [ i ] ) {15 h. dist [u] = h. dist [v] + g −>v [ v ] . pesos [ i ] ; prev [ u ] = v; d i m i n u i (&h , &u ) ; } }20 } free (h . dist ) ; free (h . v) ; f r e e ( prev ) ; } Programa 12: Fijkstra sem Impressão 12
  • 17. 2.3.2 Função DijkstraP Essa função é responsável pela execução do algoritmo de Dijkstra imprimindo de caminho. O caminho que é calculado para cada vertice v percorrendo o vetor pred iniciando pelo pred[v] seguindo pelo pred até que ele seja igual ao nó fonte do dijkstra. Vide Programa 13 Caminho d i j k s t r a P ( TGrafo ∗ g , int ∗ s) { THeap h; Caminho c ; ∗ int FILE arq ; 5 v, w, u, aux , ∗ prev , i ; prev = ( int ∗ ) calloc (g −>q t d V e r t , sizeof int ( )) ; c r i a H e a p (&h , &(g −>q t d V e r t ) ) ; h. dist [ ∗s] = 0;10 c o n s t r o i (&h ) ; for (u = 0; u < g−>q t d V e r t ; u++) {15 prev [ u ] = − 1; while } ( tamanho (&h ) ) { for v = p e g a r M e n o r (&h ) ; ( i = 0; i < g−>v [ v ] . qtdAlloc ; i ++) {20 −>v [ v ] . if u = g vizinhos [ i ] ; (h . dist [ u ] > h. dist [v] + g −>v [ v ] . pesos [ i ] ) { h. dist [u] = h. dist [v] + g −>v [ v ] . pesos [ i ] ; prev [ u ] = v; d i m i n u i (&h , &u ) ;25 } } } w = INF ;30 for (u = 0; u < g −>q t d V e r t ; u++) { free (g −>v [ u ] . pesos ) ; f r e e ( g−>v [ u ] . vizinhos ) ; } arq = fopen ( " s p a t h s . t x t " , "w" ) ;35 if ( ! arq ) { " Erro ao e s c r e v e r no a r q u i v o " ) ; return printf ( ; int ∗ sizeof int }40 ∗ ( g−>q t d V e r t +1) ) ; for c . resultado = ( ) malloc ( ( ) −>q t d V e r t ; if (u = 0; u < g u++) { ∗s continue (u == || h . d i s t [ u]== w) ; c . qtdusada = 2;45 c . resultado [ 0 ] = h. dist [u ] ; c . resultado [ 1 ] = u; while aux = prev [ u ] ; ( aux != ∗s && aux != −1) { c . r e s u l t a d o [ c . q t d u s a d a ++] = aux ;50 aux = p r e v [ aux ] ; } 13
  • 18. c . r e s u l t a d o [ c . qtdusada ] = ∗s ; "[%d,%d ](% d ) " , ( ∗ s ) +1 , u +1 , c . r e s u l t a d o for f p r i n t f ( arq , [0]) ; ( i = c . qtdusada ; i > 0 ; i −−){55 f p r i n t f ( a r q , " %d" , c . r e s u l t a d o [ i ] + 1 ) ; } f p r i n t f ( arq , "n" ) ; } free ( c . resultado ) ;60 free (h . dist ) ; free (h . v) ; −>v ) ; return free (g c ; } Programa 13: Dijkstra com Impressão 2.3.3 Função Main para o Dijkstra Essa função efetua as chamadas para leitura de arquivos e execução do dijkstra. Note que foi feito uso de uma técnica denominada Loop Unrolling para aproveitarmos melhor o uso do Pipeline do processador[4], ganhando uma leve melhora no tempo de execução do programa. #include " T D i j k s t r a . h" int int main ( char ∗∗ argc , argv ) { 5 int flagDepuracao , nrExecucao , vertRand ; TGrafo g; if Caminho c ; ( argc < 3) { " C o n f i r a o numero de parametros " ) ; return printf (10 ( EXIT_FAILURE ) ; } srand ( 0 ) ; flagDepuracao = a t o i ( argv [ 3 ] ) ; nrExecucao = a t o i ( argv [ 2 ] ) ;15 if g = cria_grafo_por_nome ( a r g v [ 1 ] ) ; ( g . qtdVert = = − 1) { "n ∗∗ Erro ao c r i a r o g r a f o " ) ; return printf ( ( EXIT_FAILURE ) ;20 switch } case ( flagDepuracao ) { switch 0: case ( nrExecucao % 4) { while 0:25 ( nrExecucao ) { vertRand = rand ( ) % g . qtdVert ; d i j k s t r a (&g , &v e r t R a n d ) ; nrExecucao −−;30 vertRand = rand ( ) % g . qtdVert ; d i j k s t r a (&g , &v e r t R a n d ) ; nrExecucao −−; vertRand = rand ( ) % g . qtdVert ; 14
  • 19. 35 d i j k s t r a (&g , &v e r t R a n d ) ; nrExecucao −−; vertRand = rand ( ) % g . qtdVert ; d i j k s t r a (&g , &v e r t R a n d ) ;40 nrExecucao −−; break } case ; while 2: ( nrExecucao ) {45 vertRand = rand ( ) % g . qtdVert ; d i j k s t r a (&g , &v e r t R a n d ) ; nrExecucao −−; vertRand = rand ( ) % g . qtdVert ;50 d i j k s t r a (&g , &v e r t R a n d ) ; nrExecucao −−; break } ;55 default while : ( nrExecucao −−) { vertRand = rand ( ) % g . qtdVert ; d i j k s t r a (&g , &v e r t R a n d ) ; break }60 ; break } case ; 1:65 vertRand = 0; c = d i j k s t r a P (&g , &v e r t R a n d ) ; } return ( EXIT_SUCCESS ) ;70 } Programa 14: Programa principal do Dijkstra 2.4 Grafo do Floyd-Warshall Para a representação do grafo utilizamos a estrutura TGrafo 15, onde temos uma variável ehcicloNeg para a vericação se o grafo é negativo ou não bem como qtdVert, qtdAres para a quantidade de vértices e arestas respectivamente. O grafo, na verdade, é representado por uma matriz de adjacências do tipo TVertice** matriz, contendo um peso (distância) de um vértice A para um vértice B. Isso pode ser visto facilmente no Programa 15. Além de calcular a distância e a matriz de predecessores, para a impressão dos caminhos de todos os vértices para todos os demais, foi preciso utilizar a estrutura Caminho, onde qtdTotal, neg, s, t representam a quantidade total de vértices do grafo, vericação se o grafo é ou não negativo para a geração do caminho de ciclo negativo, s e t os vértices de início e nal do grafo, respectivamente. E, ainda, o resultado contendo a quantidade de vértices que fazem parte do caminho gerado e o próprio caminho de um vértice A para um vértice B. Isso pode ser visto na Figura 5 15
  • 20. #include " s t d a f x . h" typedef struct int ∗ { TP , qtdNos ; 5 } TPasseio ; typedef struct { ∗ int TPasseio resultado ; qtdTotal , neg , s , t ;10 } Caminho ; typedef struct int { peso ; } TVertice ;15 typedef struct int { short int qtdVert , qtdAres ; ehcicloNeg ; TVertice ∗∗ matriz ;20 } TGrafo ; TGrafo cria_grafo_por_nome ( char ∗ ) ; void i m p r i m i r _ s a l v a r ( Caminho ∗) ;25 void i n i c i a _ m a t r i z ( TGrafo ∗) ; void i n s t _ m a t r i z ( TGrafo ∗, int ∗ int ∗ int ∗ , , ) ;30 Caminho ∗ f l o y d P ( TGrafo ∗) ; void f l o y d ( TGrafo ∗, TVertice ∗∗ , int ∗ ∗ ) ; TVertice ∗∗ alocaMatriz ( TVertice ∗ ∗ int ∗ , ) ;35 int ∗∗ iniciaPred ( int ∗∗ , int ∗ ) ; Caminho ∗ f l o y d P N e g ( TGrafo ∗ ) ;40 void f l o y d N e g ( TGrafo ∗ TVertice ∗∗ , int ∗∗ ) ; Programa 15: TAD Grafo 2.4.1 Função CriaGrafoPorNome A Função 2.4.1 tem como objetivo fazer a leitura do grafo a partir de um arquivo .txt e ainda iniciar a matriz de adjacências 2.4.3 bem como instanciar a matriz com todos os pesos do grafo de um vértice A para um vértice B . E é claro, vericar para todos os vértices do grafo, durante a inserção, se o grafo contém aresta com peso negativo. Vide Programa 16 TGrafo cria_grafo_por_nome ( char ∗ nome ) { ∗ arqE ; char FILE ∗ buf , ∗ tok ; TGrafo g; 16
  • 21. 5 int char ∗ sizeof char numArestas , numVertices , vA , vB , peso , media_qtd_arestas ; ∗10) ; char ∗ sizeof char tok = ( ) malloc ( ( ) buf = ( ) malloc ( ( ) ∗100) ; "r") ; if arqE = f o p e n ( nome , ( ! arqE ) {10 printf ( " Erro ao a b r i r o a r q u i v o de e n t r a d a %s " , nome ) ; g . q t d V e r t = − 1; return (g) ; } while g . ehcicloNeg = 0;15 ( ! f e o f ( arqE ) ) { if buf = f g e t s ( buf , BUFSIZ , arqE ) ; break ( buf == NULL) switch ; case p ( buf [ 0 ] ) {20 : tok = " ") ; s t r t o k ( buf , tok = s t r t o k (NULL, " ") ; tok = s t r t o k (NULL, " " ) ; numVertices = a t o i ( tok ) ;25 tok = s t r t o k (NULL, " ") ; numArestas = a t o i ( tok ) ; g . qtdAres = numArestas ; g . qtdVert = numVertices ; break i n i c i a _ m a t r i z (& g ) ;30 case ; a : tok = s t r t o k ( buf , " ") ; tok = s t r t o k (NULL, " ") ; vA = a t o i ( tok ) − 1;35 tok = s t r t o k (NULL, " ") ; vB = a t o i ( tok ) − 1; tok = s t r t o k (NULL, " ") ; if peso = a t o i ( tok ) ; ( p e s o <0)40 g . ehcicloNeg = 1; break g . m a t r i z [ vA ] [ vB ] . p e s o = peso ; default ; break : ;45 } return } (g) ; } Programa 16: Função criagrafopornome 2.4.2 Função alocaMatriz Para a alocação da matriz, por padrão, seria feita em ordem de complexidade quadrática, no entanto, para otimizar o código zemos em ordem de complexidade linear. Para isso foi preciso alocar a matriz com a quantidade de linhas da matriz de adjacências e mais uma alocação para a posição matriz[0] com tamanho Linha ∗ Coluna, fazendo, em seguida, um redirecionamento dos endereços da matriz. Por exemplo, numa matriz 3x2 alocamos a matriz com 3 posições, sendo que para a matriz[0] alocaremos 6 posições. Assim, no redirecionamento dos ponteiros como, 17
  • 22. por exemplo, a posição matriz[1] receberá o endereço da matriz[0][i ∗ coluna], ouseja, matriz[0][1x2]. Para melhor entendimento, vide Figura 1 e Programa 17. Figura 1: Figura Repres. Alocação Matriz 18
  • 23. ∗∗ ∗∗ int ∗ int TVertice alocaMatriz ( TVertice matriz , tam ) { sizeof i , j ; ∗∗) ∗ tam ) ∗ ∗) ) ; if matriz = ( TVertice malloc (( ( TVertice ( matriz == NULL) { 5 " Erro ao a l o c a r a m a t r i z n" ) ; return printf ( 0; sizeof } matriz [ 0 ] = ( TVertice ∗) malloc ( ( ( ∗ tam ) ∗ ( ∗ tam ) ) ∗ ( TVertice ) ) if ; ( matriz [ 0 ] == NULL) {10 " Erro ao a l o c a r a m a t r i z n" ) ; return printf ( 0; for } ( i = 1; i < ( ∗ tam ) ; i ++) { matriz [ i ] = &( m a t r i z [ 0 ] [ i ∗ ( ∗ tam ) ] ) ;15 return } matriz ; } Programa 17: Função alocaMatriz 2.4.3 Função iniciaMatriz Função responsável por alocar 2.4.2 e inicializar a matriz de adjacências. Vide Programa 18 void ∗ int i n i c i a _ m a t r i z ( TGrafo g) { i , j ; − −>m a t r i z , &(g−>q t d V e r t ) ) ; for g >m a t r i z = alocaMatriz (g −>q t d V e r t ; i ++) for ( i = 0; i < g 5 ( j = 0; j < g− >q t d V e r t ; j ++) −>m a t r i z [ i ] [ j ] . p e s o = INF ; for g ( i = 0; i < g− >q t d V e r t ; i ++) g −>m a t r i z [ i ] [ i ] . peso = 0; } Programa 18: Função iniciamatriz 2.4.4 Função iniciaPred Função semelhante a Função iniciaMatriz 2.4.3. Vide Programa 19 int ∗∗ int ∗∗ int ∗ int iniciaPred ( pred , tam ) { if i , j ; int ∗ ∗ sizeof int ∗ ( pred == NULL) { ∗ tam ) ∗ if pred = ( ) malloc (( ( )) ; 5 ( pred == NULL) { " Erro ao a l o c a r a m a t r i z n" ) ; return printf ( 0; int ∗ sizeof int } ∗ tam ) ∗ ( ∗ tam ) ) ∗ if pred [ 0 ] = ( ) malloc ( ( ( ( )) ;10 ( pred [ 0 ] == NULL) { " Erro ao a l o c a r a m a t r i z " ) ; return printf ( 0; for } ( i = 1; i < ( ∗ tam ) ; i ++) { 19
  • 24. 15 pred [ i ] = &( p r e d [ 0 ] [ ( ∗ tam ) ∗ i ]) ; } for } ∗ tam ) ; i ++) for ( i = 0; i < ( ( j = 0; j < ( ∗ tam ) ; j ++)20 return pred [ i ] [ j ] = i ; pred ; } Programa 19: Função iniciaPred 2.5 Floyd-Warshall 2.5.1 Função oydP Função responsável por calcular a distância e predecessores de todos os vértices do grafo positivo, utilizando o Algoritmo de Floyd Warshall, note que não é preciso reinicializar a matriz de adjacências bem como a de predecessores uma vez que quando passarmos ao programa a ag 1 de impressão o programa executará somente uma única vez. Para uma ilustração da geração dos caminhos veja a Figura 5. Vide Programa 20 ∗ ∗ int Caminho f l o y d P ( TGrafo g) { k, i , j , aux , n = 0, pos ; ∗ int ∗∗ Caminho c ; pred ; 5 pred = NULL ; &(g− sizeof pred = i n i c i a P r e d ( pred , >q t d V e r t ) ) ; c = ( Caminho ∗) malloc (g −>q t d V e r t ∗ ( Caminho ) ) ; c−>n e g = 0; c−>s = 0;10 c− −>q t d V e r t ; for >t = g 0 ; k < g− for (k = >q t d V e r t ; k++) i < g− for ( i = 0; >q t d V e r t ; i ++) j < g− if ( j = 0; >q t d V e r t ; j ++) ( ( g− >m a t r i z [ i ] [ k ] . p e s o + g−>m a t r i z [ k ] [ j ] . peso ) < −> g matriz [ i ] [ j ] . peso ) {15 g −>m a t r i z [ i ] [ j ] . peso = g −>m a t r i z [ i ] [ k ] . peso + g −> matriz [ k ] [ j ] . peso ; pred [ i ] [ j ] = pred [ k ] [ j ] ; } −>q t d T o t a l = g−>q t d V e r t ; for c ( k = c− >s ; k < c− sizeof >t ; k++) {20 c [ k ] . resultado = ( TPasseio ∗) calloc (c −>q t d T o t a l , ( for TPasseio ) ) ; −>s ; −>t ; int ∗ sizeof ( i = c i < c i ++) { −>q t d T o t a l int c [ k ] . r e s u l t a d o [ i ] . TP = ( ) calloc (c , ( if )) ; continue ( i == k) ;25 c [ k ] . r e s u l t a d o [ i ] . TP [ 0 ] = g −>m a t r i z [ k ] [ i ] . peso ; c [ k ] . r e s u l t a d o [ i ] . qtdNos = 1; pos = 1; while aux = pred [ k ] [ i ] ; ( ( aux != i ) && ( aux != k) ) { 20
  • 25. 30 c [ k ] . r e s u l t a d o [ i ] . q t d N o s ++; c [ k ] . r e s u l t a d o [ i ] . TP [ p o s ++] = aux ; aux = p r e d [ k ] [ aux ] ; } }35 } f r e e ( pred [ 0 ] ) ; return f r e e ( pred ) ; c ; } Programa 20: Função oydP 2.5.2 Função oyd Análogo a Função oydP 2.5.1, porém sem geração de caminhos e ainda dois pontos importantes: • Matriz de Distâncias: criamos uma matriz auxiliar que é alocada somente uma única vez e desalocada somente no nal das n execuções, porém sempre que é executada, inicializamos a matriz de modo que que de acordo com a especicação proposta pelo trabalho e ainda com código mais otimizado. • Matriz de Predecessores: Optamos por reutilizá-la, porém reiniciando-a na Função mainF 2.5.6 a cada execução. A função responsável por alocar e / ou inicialização do Pred pode ser conferida na Seção 2.4.4. Vale lembrar que a cada execução a matriz de predecessores é reinicializada, logo está de acordo com a especicação proposta pelo trabalho e ainda mais otimizado. void ∗ ∗∗ int ∗∗ int f l o y d ( TGrafo g , TVertice auxMatriz , pred ) { for k, i , j ; −>q t d V e r t ; i ++) for ( i = 0; i < g ( j = < g− 0; j>q t d V e r t ; j ++) 5 a u x M a t r i z [ i ] [ j ] = g− for >m a t r i z [ i ] [ j ] ; = 0 ; k < g− for (k >q t d V e r t ; k++) { i < g− for ( i = 0; >q t d V e r t ; i ++) j < g− if ( j = 0; >q t d V e r t ; j ++) ( ( auxMatriz [ i ] [ k ] . peso + auxMatriz [ k ] [ j ] . peso ) < auxMatriz [ i ] [ j ] . peso ) {10 auxMatriz [ i ] [ j ] . peso = auxMatriz [ i ] [ k ] . peso + auxMatriz [ k ] [ j ] . peso ; pred [ i ] [ j ] = pred [ k ] [ j ] ; } } } Programa 21: Função oyd 2.5.3 Função oydPNeg Função responsável por calcular a distância e predecessores de todos os vértices do grafo negativo, utilizando o Algoritmo de Floyd Warshall, note que assim como o Programa20 não é preciso reinicializar a matriz de adjacências bem como a de 21
  • 26. predecessores uma vez que quando passarmos ao programa a ag 1 de impressão o programa executará somente uma única vez. Logo, bastará somente inicializá-la. Como o grafo é negativo (contém ciclos com pesos negativos), então será necessário sair da execução do algoritmo de Warshall e identicar o ciclo de peso negativo, gerando o caminho desse ciclo para futura impressão em arquivo. Isso é feito de modo análogo à geração de caminho da Seção 2.5.1, mas, para isso, bastará percor- rer e gerar o caminho da posição da matriz que foi identicado o ciclo negativo, ou seja, a posição de uma das diagonais principais da matriz de adjacências do grafo. Obs.: Para contornar a condição de parada do programa para ciclos negativos, incrementamos uma unidade na quantidade da posição em que a matriz sua diagonal principal foi modicada, isso somente para a representação do vértice nal. Para uma ilustração da geração dos caminhos veja a Figura 14. Vide Programa 22 ∗ ∗ int Caminho f l o y d P N e g ( TGrafo g) { k, i , j , aux , n = 0, pos ; ∗ int ∗∗ Caminho c ; pred ; 5 pred = NULL ; &(g− sizeof pred = i n i c i a P r e d ( pred , >q t d V e r t ) ) ; c = ( Caminho ∗) malloc (g −>q t d V e r t ∗ ( Caminho ) ) ; c−>n e g = 0; c−>s = 0;10 c− −>q t d V e r t ; for >t = g 0 ; k < g− for (k = >q t d V e r t ; k++) { i < g− for ( i = 0; >q t d V e r t ; i ++) j < g− if ( j = 0; >q t d V e r t ; j ++) { ( ( g− >m a t r i z [ i ] [ k ] . p e s o + g− >m a t r i z [ k ] [ j ] . peso ) < −> g matriz [ i ] [ j ] . peso ) {15 g−>m a t r i z [ i ] [ j ] . peso = g −>m a t r i z [ i ] [ k ] . peso + g −> matriz [ k ] [ j ] . peso ; if pred [ i ] [ j ] = pred [ k ] [ j ] ; (g −>m a t r i z [ i ] [ i ] . peso < 0) { c−>n e g = 1 ; c−>s = i ;20 c− goto >t = i + 1 ; NEG ; } } }25 } NEG : −>q t d T o t a l = g−>q t d V e r t ; for c ( k = c− >s ; k < c− sizeof >t ; k++) { c [ k ] . resultado = ( TPasseio ∗) calloc (c −>q t d T o t a l , ( for TPasseio ) ) ;30 −>s ; −>t ; int ∗ sizeof ( i = c i < c i ++) { −>q t d T o t a l int c [ k ] . r e s u l t a d o [ i ] . TP = ( ) calloc (c , ( )) ; c [ k ] . r e s u l t a d o [ i ] . TP [ 0 ] = g −>m a t r i z [ k ] [ i ] . peso ; c [ k ] . r e s u l t a d o [ i ] . qtdNos = 1; pos = 1;35 while aux = pred [ k ] [ i ] ; ( ( aux != i ) && ( aux != k) ) { c [ k ] . r e s u l t a d o [ i ] . q t d N o s ++; c [ k ] . r e s u l t a d o [ i ] . TP [ p o s ++] = aux ; 22
  • 27. aux = p r e d [ k ] [ aux ] ;40 } } } f r e e ( pred [ 0 ] ) ; return f r e e ( pred ) ;45 c ; } Programa 22: Função oydPNeg 2.5.4 Função oydNeg Análogo a Função oydPNeg 2.5.3, porém sem geração de caminhos e ainda com o mesmo ponto importante da Seção 2.5.2. void ∗ ∗∗ int ∗∗ int f l o y d N e g ( TGrafo g , TVertice auxMatriz , pred ) { for k, i , j ; −>q t d V e r t ; i ++) for ( i = 0; i < g ( j = < g− 0; j >q t d V e r t ; j ++) 5 a u x M a t r i z [ i ] [ j ] = g− for >m a t r i z [ i ] [ j ] ; = 0 ; k < g− for (k >q t d V e r t ; k++) i < g− for ( i = 0; >q t d V e r t ; i ++) j < g− if ( j = 0; >q t d V e r t ; j ++) ( ( auxMatriz [ i ] [ k ] . peso + auxMatriz [ k ] [ j ] . peso ) < auxMatriz [ i ] [ j ] . peso ) {10 auxMatriz [ i ] [ j ] . peso = auxMatriz [ i ] [ k ] . peso + auxMatriz [ k ] [ j ] . peso ; if pred [ i ] [ j ] = pred [ k ] [ j ] ; return ( auxMatriz [ i ] [ i ] . peso < 0) { ; }15 } } Programa 23: Função oydNeg 2.5.5 Função imprimirsalvar Função utilizada para impressão dos resultados, isto é, distância e peso de todos os vértices para os demais vértices do grafo bem como o caminho entres os vértices de início e nal. Obs.: Como os caminhos de cada vértice são acessados e armazenados em ordem inversa a impressão dos caminhos é feita em ordem inversa para que os caminhos de saída estejam na ordem correta. Um exemplo dessa geração de caminhos pode ser vista na Figura 5. Vide Programa 24 void i m p r i m i r _ s a l v a r ( Caminho ∗ c) { ∗ int FILE arqS ; i , j , k; " s p a t h s . t x t " , "w" ) ; if arqS = fopen ( 5 ( ! arqS ) { " Erro ao e s c r e v e r no a r q u i v o " ) ; return printf ( ; if } (c −>n e g ) 23
  • 28. 10 " C i c l o N e g a t i v o n" ) ; for f p r i n t f ( arqS , −>s ; c− for (k = c k < >t ; k++) { = c− i < c− if ( i >s ; >t ; i ++) { ( ! c− if >n e g ) continue ((k == i ) || ( c [ k ] . r e s u l t a d o [ i ] . TP [ 0 ] == INF ) )15 ; f p r i n t f ( arqS , "[%d,%d ](% d ) " , k + 1, i + 1, c [ k ] . resultado [ i ] . TP [ 0 ] ) ; " %d" , for f p r i n t f ( arqS , k + 1) ; ( j = c [ k ] . r e s u l t a d o [ i ] . qtdNos − 1; j >= 1; j −−) f p r i n t f ( arqS , " %d" , c [ k ] . r e s u l t a d o [ i ] . TP [ j ] + 1) ;20 f p r i n t f ( arqS , " %dn" , i + 1) ; } f p r i n t f ( arqS , "n" ) ; } } Programa 24: Função imprimirsalvar 2.5.6 Função mainF Função Main do programa responsável por chamar as demais funções. Note que novamente zemos uso do Loop Unrolling para aproveitarmos melhor o uso do Pipeline do processador[4]. Vide Programa 25. #include " s t d a f x . h" #include #include "TGrafoF . h" <t i m e . h> int int main ( char ∗∗ argc , argv ) { 5 int flagDepuracao , nrExecucao , vertRand ; TGrafo g; Caminho ∗ c ; ∗∗ int ∗∗ TVertice auxMatriz ;10 pred ; if pred = NULL ; ( argc < 3) { " C o n f i r a o numero de parametros " ) ; return printf ( ( EXIT_FAILURE ) ;15 } srand ( 0 ) ; flagDepuracao = a t o i ( argv [ 3 ] ) ; nrExecucao = a t o i ( argv [ 2 ] ) ; if g = cria_grafo_por_nome ( a r g v [ 1 ] ) ;20 ( g . qtdVert = = − 1) { "n ∗∗ Erro ao c r i a r o g r a f o " ) ; return printf ( ( EXIT_FAILURE ) ; } auxMatriz = NULL ;25 auxMatriz = a l o c a M a t r i z ( auxMatriz , &( g . q t d V e r t ) ) ; switch case (g . ehcicloNeg ){ switch 0: case ( flagDepuracao ) {30 switch 0: ( nrExecucao % 4) { 24
  • 29. case while 0: ( nrExecucao ) { pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ;35 f l o y d (&g , auxMatriz , pred ) ; nrExecucao −−; pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d (&g , auxMatriz , pred ) ;40 nrExecucao −−; pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d (&g , auxMatriz , pred ) ; nrExecucao −−;45 pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d (&g , auxMatriz , pred ) ; nrExecucao −−; break }50 case ; 2: while { ( nrExecucao ) { pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ;55 nrExecucao −−; f l o y d (&g , auxMatriz , pred ) ; pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; nrExecucao −−;60 f l o y d (&g , auxMatriz , pred ) ; break } ; default }65 while : ( nrExecucao −−) { pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d (&g , auxMatriz , pred ) ; break }70 ; } f r e e ( pred [ 0 ] ) ; break f r e e ( pred ) ; case ;75 1: c = f l o y d P (& g ) ; imprimir_salvar ( c ) ; break } case ;80 switch 1: case ( flagDepuracao ) { switch 0: case ( nrExecucao % 4) { while 0:85 ( nrExecucao ) { pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d N e g (&g , auxMatriz , pred ) ; nrExecucao −−; 25
  • 30. 90 pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d N e g (&g , auxMatriz , pred ) ; nrExecucao −−; pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; 95 f l o y d N e g (&g , auxMatriz , pred ) ; nrExecucao −−; pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d N e g (&g , auxMatriz , pred ) ;100 nrExecucao −−; break } case ; 2: while {105 ( nrExecucao ) { pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; nrExecucao −−; f l o y d N e g (&g , auxMatriz , pred ) ;110 pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; nrExecucao −−; f l o y d N e g (&g , auxMatriz , pred ) ; break } ;115 default } while : ( nrExecucao −−) { pred = i n i c i a P r e d ( pred , &( g . q t d V e r t ) ) ; f l o y d N e g (&g , auxMatriz , pred ) ;120 break } ; } f r e e ( pred [ 0 ] ) ; break f r e e ( pred ) ;125 case ; 1: c = f l o y d P N e g (& g ) ; imprimir_salvar ( c ) ; }130 if } ( flagDepuracao ) free (c) ; f r e e ( auxMatriz [ 0 ] ) ; return f r e e ( auxMatriz ) ;135 0; } Programa 25: Função mainF 26
  • 31. 3 Testes3.1 Exemplo de teste para o Floyd-Warshall Para uma simples conferência e facilidade na implementação foram elaborados2 (dois) grafos de teste para o Floyd-Warshall, sendo um deles com peso negativo,vide 3.1.2, e outro com peso positivo, vide 3.1.1.3.1.1 Grafo com Peso Positivo Vide na Figura 2 a representação e um grafo com pesos positivos, a matriz dedistâncias de todos os vértices 3 e a matriz de predecessores dos vértices 4. A Figura 5 ilustra a geração de caminho dos vértices 1→2 com peso 6, onde ocaminho gerado é: 1→3→4→2 Figura 2: Figura Grafo com Peso Positivos Figura 3: Figura Matriz Dist 27
  • 32. Figura 4: Figura Matriz PredFigura 5: Figura Exemplo de Caminho 28
  • 33. 3.1.2 Grafo com Peso Negativo Vide na Figura 6 a representação e um grafo com peso negativo, a matriz dedistâncias de todos os vértices 7 e a matriz de predecessores dos vértices 8. A Figura 14 ilustra a geração de caminho dos vértices 5→5 com peso -2, ondeo caminho gerado é: 5→4→1→2→5 Figura 6: Figura Grafo com Peso Negativo Figura 7: Figura Matriz Dist 29
  • 34. Figura 8: Figura Matriz PredFigura 9: Figura Exemplo de Caminho Neg 30
  • 35. 3.2 Testes em massa Os testes foram realizados computacionalmente, programa demonstrado em 26,dez vezes para cada valor de n execuções, com n = [1...9, 10, 20...90, 100, 200...1000].Após isso é calculada a média dos tempos, o desvio padrão e a variância. Nosgrácos estão marcados pontos que representam intervalo de conança dos tempos,ou seja, a média menos a variância e a média mais a variância de cada determinadaquantidade de execução. Cada gráco representa dois testes, o método proposto na preliminar, em ver-melho, e a nova implementação, em azul. Além dos pontos há uma reta que repre-senta a tendência das médias.3.2.1 Floyd-Warshall rg300_768 Figura 10: Graco para Floyd-Warshall sobre o grafo rg300_768 31
  • 36. Como pode ser observado, todos os grafos que não possuem ciclos negativos no FloydWarshall tendem a ser mais rápidos. O que mostra que mesmo a matriz não sendoreiniciada na versão preliminar, a nova implementação é ainda melhor.rg300_4730 Figura 11: Graco para Floyd-Warshall sobre o grafo rg300_4730Como pode ser observado, o tempo do Floyd Warshall foi ligeiramente melhor naotimização do que na versão das preliminares.comp-2007-2-22c 32
  • 37. Figura 12: Graco para Floyd-Warshall sobre o grafo comp-2007-2-22c 33
  • 38. Como pode ser observado no gráco a nova versão por vezes é mais rápida. Issoocorre principalmente porque na versão preliminar não tratava duas vezes um ciclonegativo, já que não reiniciava a matriz dos custos a cada nova interação.3.2.2 Dijkstra rome99c Figura 13: Graco para Dijkstra sobre o grafo rome99c Dentre os testes realizados os resultados que mostraram maior diferença nostempos foi o Dijkstra. Com uma melhoria linear de, aproximadamente, cinco vezesrepresenta ainda uma estabilidade grande com grandes execuções, já que o intervalode conança é estritamente pequeno( 0,02201 para 1000 execuções). 34
  • 39. USA-road-d-NYc Figura 14: Graco para Dijkstra sobre o grafo USA-road-d-NYcSendo o USA-road-d.NYc.gr um grafo extremamente grande para a execução com aimplementação antiga, tendendo, segundo uma conta média de resultados, 2,5 diaspara mil execuções foi necessário para-lo após a execução de 30. Apesar de pareceruma reta vertical a média dos resultados, cada valor de 1 à 30 foi computado e salvo.Isso demonstra a grande melhoria do algoritmo. 35
  • 40. 4 Conclusão O problema de caminhos mínimos, apesar de ser um problema NP-Completo,há soluções ótimas com algoritmos relativamente rápidos para algumas instanciase por vezes otimizações podem melhorar consideravelmente a função complexidadedeles, tal como o Dijkstra, que com a Heap de Fibonacci implementada para grafosmuito grandes torna-se mais rápido. Entretanto, como todos os algoritmos são ditosgulosos, ou seja, não acham a solução ótima a princípio, ainda há muito a serpesquisado nesta área, partindo do princípio que a quantidade de aplicações desteproblema é inimaginável. 36
  • 41. Referências[1] John Mark Gurney. b, 2003. http://resnet.uoregon.edu/~gurney_j/jmpc/ fib.html, acessado em 07/10/2010.[2] David Menotti. Aula 19 ordenação iv http:// heapsort, 2010. www.decom.ufop.br/menotti/edI101/slides/aula-ORDHeapSort.ppt, aces- sado em 22/09/2010.[3] Rosane Minghim. Grafos parte 2, 2010. https://docs.google.com/viewer? url=http://wiki.icmc.usp.br/images/5/5d/AlgII_Rosane_02_Grafos2. pdf&pli=1, acessado em 01/10/2010.[4] David A. Patterson and John L. hennessy. Computer Organization and Design. Morgan Kaufmann Publishers, 4th edition, 2008.[5] Haroldo Gambini Santos. Grafos com pesos - computando caminhos mínimos, 2010. http://grafos-ufop.googlegroups.com/web/grafos_04.pdf?gda= Sx3MV0MAAACp509PEQE-F0yARdQXL36CtbRu5bCtxrbcvuUDlY-ViORczfpiWbs5z6OtNHg3VURtxVPd acessado em 26/08/2010.[6] Ronald L. Rivest Thomas H. Cormen, Charles E. Leiserson. Algoritmos: Teoria e Prática. Editora Campus, segunda edição edition, 2002.[7] the free encyclopedia Wikipedia. Fibonacci heap, 2010. http://en.wikipedia. org/wiki/Fibonacci_heap, acessado em 24/09/2010.[8] N. Ziviani. Projeto de Algoritmos: com implementações em Pascal e C. Cengage Learning (Thomson / Pioneira), São Paulo, 1st edition, 2004. 37
  • 42. Anexo Este algoritmo gera um programa para executar os testes em massa para os algoritmos Dijkstra e Floyd-Warshall #include #include < s t d i o . h> #include < s t d l i b . h> #include < s t r i n g . h> <math . h> 5 int leArquivo ( float ∗ tempo , int ∗i) { char ∗ char ∗ tok ; buf ;10 ∗ int FILE arqE ; float min ; char ∗ sizeof char seg ; buf = ( ) malloc ( ( ) ∗ BUFSIZ ) ;15 arqE = fopen ( " log " , "r") ; if ( arqE == NULL) { " Erro ao a b r i r a r q u i v o de e n t r a d a n" ) ; return printf ( 0;20 } buf = f g e t s ( buf , BUFSIZ , arqE ) ; tok = s t r t o k ( buf , ":") ;25 min = a t o i ( tok ) ; tok = s t r t o k (NULL, ":") ; s s c a n f ( tok , "%f " , &s e g ) ; tempo [ ∗i ] = seg + min ∗ 60; ( ∗ i ) ++;30 return f c l o s e ( arqE ) ; 1; }35 int estatistica ( float ∗ tempo , int ∗n , char ∗ name ) { ∗ int FILE arqS ; double i ; x, me di a , var ; v a r=x = 0 ;40 "a+" ) ; if arqS = f o p e n ( name , ( arqS == NULL) { " Erro ao a b r i r a r q u i v o de s a i d a n" ) ; return printf ( 0; for }45 ( i = 0; i <10; i ++) x += tempo [ i ] ; for media = x / 10; double ( i = 0; i <10; i ++) var += pow ( ( ) ( tempo [ i ] − media ) , 2) ;50 var = s q r t ( var /9) ; f p r i n t f ( arqS , "%d % l f n" , ( ∗n) , media − var ) ; f p r i n t f ( arqS , "%d % l f n" , ( ∗n) , media + var ) ; fflush ( stdin ) ; 38
  • 43. f c l o s e ( arqS ) ;55 } int main ( int argc , char ∗∗ argv ) { int char ∗ n, i , j , k;60 float ∗ string ; int ∗ tempo ; float ∗ sizeof float pos ; char ∗ sizeof char ∗ tempo = ( ) c a l l o c (10 , ( )) ; string = ( ) malloc ( ( ) 150) ;65 int ∗ sizeof int ∗ k = 0; for pos = ( ) malloc ( ( ) 28) ; ∗= for ( i = 1; i < 1000; i 10) ( j = 1; j < 10; j ++) p o s [ k++] = i ∗ j ;70 pos [ k ] = 1000; for (n = 0; n < 28; n++) { printf ( "mà c todo : %s e n t r a d a : %s q t d de e x e c u c o e s : %dn" , argv [1] , argv [ 2 ] , pos [ n ] ) ; for k = 0;75 ( i = 0; i < 10; i ++) { sprintf ( string , "/ u s r / b i n / time −o l o g − f %s ./% s i n p u t/%s %d 0" , " %E " , argv [ 1 ] , argv [ 2 ] , pos [ n ] ) ; system ( s t r i n g ) ; l e A r q u i v o ( tempo , &k ) ; }80 e s t a t i s t i c a ( tempo , &( p o s [ n ] ) , argv [ 3 ] ) ; } return 0;85 } Programa 26: Programa de Teste 39