Apostila Completa

Faculdade de Filosofia, Cincias e Letras de Mandaguari Departamento de Informtica
APOSTILA DA DISCIPLINA ANLISE DE ALGORITMOS

Profa. Camilla Brandel Martins
2 Mandaguari, 2004
Faculdade de Filosofia, Cincias e Letras de Mandaguari Curso: Informtica Disciplina: Anlise de Algoritmos
Ementa da Disciplina
Estudo de conceitos e anlise da complexidade de algoritmos. Programa: 1. Introduo 1.1 Objetivo da Disciplina 1.2 Medidas de Desempenho de Algoritmos 2. Teoria dos Grafos 2.1. Introduo 2.2. Sucessores e Antecessores de um Grafo Dirigido 2.3. Representao de Grafos em um Computador 2.4. Caminho e Conexidade 2.5. Localizao de Centros 2.6. Algoritmos e problemas clssicos com grafos 2.7. Busca em Grafos 2.8. Fluxo em rede 3.Complexidade de Algoritmos 3.1.Definies 3.2. Notao O, Omega e Theta 3.3. Crescimento assinttico de funes 4. Anlise da Complexidade de Algoritmos 4.1 Estimativas de Tempo de Execuo 4.2. Regras para Anlise de Algoritmos 4.3. Relaes de recorrncia 5. Tcnicas de Projeto de Algoritmos 5.1 Algoritmos de Ordenao 5.1.1 Algoritmos de Ordenao por insero 5.1.2 Algoritmos de Ordenao por seleo 5.1.3 Algoritmos de Ordenao por troca 5.2 Algoritmo da Fora Bruta 5.3 Algoritmo Minmax 5.4 Algoritmo dividir e conquistar 5.5 Algoritmo Guloso 6. Teoria da Complexidade 6.1. Tipos de Problemas 6.2. Classes de Problemas 6.2.1. Problemas P, NP e NP-Completos
Previso de Avaliaes:
1o. Bimestre Uma prova escrita valendo 7,0 e um trabalho valendo 3,0 2o. Bimestre Uma prova escrita valendo 7,0 e um trabalho valendo 3,0 3o. Bimestre Uma prova escrita valendo 7,0 e um trabalho valendo 3,0 4o. Bimestre Uma prova escrita valendo 7,0 e um trabalho valendo 3,0
NDICE
APOSTILA DA DISCIPLINA........................................................................................................................1 ANLISE DE ALGORITMOS.......................................................................................................................1 1 INTRODUO..............................................................................................................................................6 1.1 OBJETIVO DA DISCIPLINA...............................................................................................................................6 1.2 MEDIDAS DE DESEMPENHO DE ALGORITMOS.....................................................................................................6 2 TEORIA DOS GRAFOS................................................................................................................................8 2.1 INTRODUO.................................................................................................................................................8 2.1.1 Representao Grfica.....................................................................................................................9 2.1.2 Representao Matemtica..............................................................................................................9 2.1.3 Definies Bsicas............................................................................................................................9 2.1.4 Tipos de Grafos..............................................................................................................................10 2.2 SUCESSORES E ANTECESSORES DE UM GRAFO DIRIGIDO....................................................................................13 2.3 REPRESENTAO DE GRAFOS EM UM COMPUTADOR..........................................................................................13 2.3.1 Matriz de Adjacncia......................................................................................................................13 2.3.2 Matriz de Custo..............................................................................................................................14 2.3.3 Matriz de Incidncia.......................................................................................................................14 2.3.4 Lista de Arestas..............................................................................................................................15 2.3.5 Estrutura de Adjacncia.................................................................................................................15 2.4 CAMINHO E CONEXIDADE.............................................................................................................................16 2.4.1 Caminho..........................................................................................................................................16 2.4.2 Cadeia.............................................................................................................................................16 2.4.3 Comprimento..................................................................................................................................16 2.4.4 Caminho Simples x Trajetria........................................................................................................17 2.4.5 Grafo Conexo.................................................................................................................................17 2.4.6 Caminhos abertos e fechados.........................................................................................................17 2.4.7 Circuito e Ciclo..............................................................................................................................17 2.4.8 Algoritmo de Goodman..................................................................................................................18 2.5 LOCALIZAO DE CENTROS (EM GRAFOS NO VALORADOS)...............................................................................19 2.5.1 Distncia.........................................................................................................................................19 2.5.2 Pista................................................................................................................................................20 2.5.3 Excentricidade................................................................................................................................20 2.5.4 Raio.................................................................................................................................................20 2.5.5 Centro.............................................................................................................................................20 2.5.6 Centro de um grafo dirigido...........................................................................................................21 2.5.7 Localizao de Centros de Emergncia.........................................................................................21 2.6 ALGORITMOS E PROBLEMAS CLSSICOS COM GRAFOS.........................................................................................24 2.6.1 Algoritmo de Floyd ..............................................................................................................24 2.6.1 Algoritmo de Dijkstra.....................................................................................................................31 2.6.2 Grafos de Euler..............................................................................................................................33 2.6.3 Problema do Carteiro Chins.........................................................................................................33 2.6.4 Caminho e Circuito Hamiltoniano.................................................................................................37 2.6.5 Problema do Caixeiro Viajante......................................................................................................37 2.7 BUSCA EM GRAFO.......................................................................................................................................47 2.7.1 Algoritmo Bsico ou Busca Geral..................................................................................................48 2.7.2 Busca em Profundidade..................................................................................................................49 2.7.3 Busca em Largura..........................................................................................................................52 2.8 FLUXO EM REDE.........................................................................................................................................56 3 EFICINCIA E CORRETUDE DE ALGORITMOS..............................................................................57 3.1 DEFINIES................................................................................................................................................57 3.1.1 O que um algoritmo?...................................................................................................................57 3.1.2 Instncias de execuo de algoritmos............................................................................................58 3.1.3 Avaliao de Algoritmos................................................................................................................58
3.1.4 Associando uma funo a um algoritmo........................................................................................59 3.2 NOTAO O, OMEGA E THETA.....................................................................................................................60 3.2.1 Notao O.......................................................................................................................................60 3.2.2 Notao ......................................................................................................................................61 3.2.3 Notao ......................................................................................................................................61 3.3 CRESCIMENTO ASSINTTICO DE FUNES.........................................................................................................62 3.3.1 Principais Classes de Complexidade.............................................................................................62 4 ANLISE DA COMPLEXIDADE DE ALGORITMOS..........................................................................63 4.1 ESTIMATIVAS DE TEMPO DE EXECUO..........................................................................................................63 4.1.1 Regras para Anlise de Algoritmos................................................................................................63 BIBLIOGRAFIA............................................................................................................................................68 FONTES DA INTERNET:............................................................................................................................68
1 Introduo
1.1 Objetivo da Disciplina
Nesta altura do curso, a maioria dos alunos j deve ter compreendido que o desenvolvimento de algoritmos uma atividade fundamental da computao. Assim, esta mais uma disciplina que ir ajud-lo a aprimorar suas habilidades de programao. Nas disciplinas de engenharia de software, aprende-se vrios mtodos e procedimentos que devem ser adotados para produzir um software eficiente e de qualidade, utilizando o menor tempo possvel e a menor quantidade possvel de recursos. A disciplina Anlise de Algoritmos est, portanto, relacionada com a engenharia de software, pois um de seus objetivos a produo de softwares eficientes. A diferena que a engenharia se preocupa com diversos aspectos do software, como o paradigma utilizado, qual a melhor linguagem de preocupao, como montar uma equipe de programadores, etc. J a anlise de algoritmos se preocupa unicamente com uma atividade: a codificao. Assim, o objetivo final desta disciplina fazer com que os alunos produzam no apenas cdigos que funcionem, mas que sejam tambm eficientes. Para isso, vamos estudar alguns tipos de problemas que podem ser resolvidos computacionalmente. Em seguida, vamos ver como a abordagem adotada para resolver pode influenciar, levando a um algoritmo mais ou menos eficiente. Em longo prazo, espera-se que o aluno consiga naturalmente compreender quais estruturas e tcnicas so mais adequadas para cada problema e as utilize de forma a produzir programas o mais eficientes possvel.
"Ao verificar que um dado programa est muito lento, uma pessoa prtica pede uma mquina mais rpida ao seu chefe. Mas o ganho potencial que uma mquina mais rpida pode proporcionar tipicamente limitado por um fator de 10, por razes tcnicas ou econmicas. Para obter um ganho maior, preciso buscar melhores algoritmos. Um bom algoritmo, mesmo rodando em uma mquina lenta, sempre acaba derrotando (para instncias grandes do problema) um algoritmo pior rodando em uma mquina rpida. Sempre."
- S. S. Skiena, The Algorithm Design Manual
1.2
Medidas de Desempenho de Algoritmos
Uma possvel definio para algoritmo a de que um algoritmo um mtodo para resolver uma classe de problemas utilizando um computador. A complexidade de um algoritmo seria ento o custo de se utilizar o algoritmo para resolver um desses problemas, sendo que custo pode ser medido em tempo de processamento, armazenamento, ou outra unidade de medida (Wilf, 1994). Os programas utilizados nos computadores domsticos geralmente executam rapidamente. Mas quem j compilou um grande programa sabe que o tempo gasto nessa atividade pode ser bastante longo. Quem j tentou fazer um programa para calcular o valor de pi ( ) sabe que atualmente essa uma tarefa impossvel. O estudo do montante de esforo computacional necessrio para executar alguma computao chamado de estudo da complexidade.
Um dos fatores que influencia o tempo de processamento o volume de dados. No difcil perceber que calcular a soma de 2 nmeros mais rpido do que fazer a soma de 2000 nmeros. Assim, uma das medidas para se verificar a complexidade de um algoritmo o tempo de execuo em relao ao volume de dados. Por exemplo, suponha que voc escreveu um pequeno programa que pede ao usurio para digitar quantos nomes ele quiser. Em seguida, o programa apresenta os nomes em ordem alfabtica. Ao executar o programa e digitar 100 nomes, voc percebe que o programa demorou 1 segundo. Ao digitar 1000 nomes, voc percebe que ele demorou 9 segundos (quando, por uma regra de 3 simples, voc pudesse achar que ele iria demorar 10 segundos). O que isso quer dizer? Bom, isso quer dizer que no assim to simples prever quanto tempo o programa demorar para executar quando voc utilizar grandes volumes de dados. Assim, para que possamos prever o seu comportamento com grandes volumes, preciso analisar o algoritmo e fazer alguns clculos. Para aprender a fazer esses clculos, naturalmente tomaremos alguns problemas computacionais como exemplo. E como vrios dos problemas clssicos da computao envolvem o uso de grafos, iniciaremos o curso estudando teoria dos grafos.
2 Teoria dos Grafos

2.1 Introduo
Os grafos, ou problema em grafos, so estudados h muitos anos. J em 1736, Euler descreveu o seguinte problema: Dada a configurao abaixo1, tendo um rio com duas ilhas, duas margens e 7 pontes, possvel passar por todas as pontes sem repetir nenhuma? Como provar?
Para resolver esse problema, Euler o representou com o grafo ilustrado na Figura 1. Com essa representao, e considerando as propriedades do grafos que sero apresentadas mais tarde nesse curso, possvel resolver facilmente esse problema.
Figura 1 . Representao grfica do problema de Euler
Esse tem sido considerado o primeiro problema do que hoje chamamos de teoria dos grafos. No entanto, at o fim do sculo 19 houve poucos trabalhos na rea. Por exemplo, em 1847, Kirchhoff utilizou modelos de grafos no estudo de circuitos eltricos. Em 1857, Cayley utilizou grafos na qumica orgnica. Em 1859, Hamilton inventou um jogo que consistia na busca de um percurso fechado envolvendo todos os vrtices de um dodecaedro regular, de tal modo que cada um deles fosse visitado uma nica vez. Para mais exemplos, consulte, por exemplo, Boaventura Neto, 1996.
1
Figura retirada do site http://www.inf.ufpr.br/~andre/Disciplinas/BSc/CI065/michel/Intro/intro.html
2.1.1 Representao Grfica Visualmente, os grafos so representados por um conjunto de pontos e um conjunto de linhas ou setas ligando esses pontos. Exemplos:
Vrtices so os pontos, ou ns Arestas so as linhas ou setas, ou arcos. 2.1.2 Representao Matemtica Um grafo G definido como G(V,A) onde V um conjunto finito e no vazio de vrtices e A um conjunto finito de pares de V, isto , A (VxV). Os elementos de A so chamados de arestas do grafo. 2.1.3 Definies Bsicas Lao uma aresta que incide com um nico vrtice chamada de lao. Orientao a direo para a qual uma seta aponta. Se a aresta no tiver seta, diz-se que ela no tem orientao Incidente Diz-se que uma aresta incidente com os vrtices que ela liga (no importa a orientao). Vrtices Adjacentes dois vrtices so adjacentes se esto ligados por uma aresta. Vrtice isolado Um vrtice dito isolado se no existe aresta incidente sobre ele. Arestas paralelas Duas arestas incidentes nos mesmos vrtices (no importa a orientao). Ou seja, se a1 = (v,w) e a2 = (v,w), ento as arestas a1 e a2 so paralelas.
a3 A B C D
Lao no vrtice A
A aresta a3 incide no vrtice C e no vrtice D.
Os vrtices A e B so adjacentes. os vrtices C e D tambm so adjacentes.
a1 E Vrtice E isolado. a2 v1 v2 As arestas a1 e a2 so paralelas
10
2.1.4 Tipos de Grafos 2.1.4.1 Grafo Rotulado Um grafo dito rotulado quando seus vrtices e/ou arestas so distinguidos uns dos outros por rtulos (que pode ser um nome, um nmero ou conjunto de letras ou nmeros. Caso contrrio o grafo no rotulado. Nos exemplos abaixo, o primeiro grafo no tem nenhum rtulo. O segundo grafo possui rtulos nos vrtices e o terceiro grafo possui rtulos nas arestas. x1 a1 x2 Grafo no rotulado x3 Grafo rotulado a2
Grafo rotulado
Exemplo 1 Represente graficamente um grafo definido matematicamente como segue: Grafo G(V,A), onde V = {v1,v2,v3,v4} e A = {(v1,v2),(v2,v3),(v3,v3),(v3,v1)}. H varias formas grficas semelhantes de se representar esse grafo, mantendo as definies, pois a posio dos vrtices no espao irrelevante. Vou fazer de duas formas diferentes. v1 v2 v3 v4 v3 v1 v2 v4
2.1.4.2 Subgrafos Seja G(V,A) um grafo. Um subgrafo G de G um grafo G(V,A), tal que V V e A A.
Grafo G
Grafo G
2.1.4.3 Ordem A ordem de um grafo definida por |V| = n. Ou seja, a ordem de um grafo o nmero de vrtices.
11
2.1.4.4 Grafos simples, completos e multgrafos Multgrafo grafo que contm arestas paralelas ou aos Grafo simples grafo que no contm nenhum par de arestas paralelas ou laos. Grafo completo um grafo simples ser completo quando existir uma aresta entre cada par de seus vrtices. Exemplos de grafos completos de 2, 3 e 4 vrtices:
Um grafo completo com n vrtices possui m = 2 arestas ou (n-1)! Um grafo completo de n vrtices denominado cliques.
2.1.4.5 Grafo Complementar Um grafo G dito complementar de G se possui a mesma ordem de G e se uma aresta (v,w) G, ento (v,w) G e vice-versa. Exemplo: Grafo G a b c d Grafo G a b c d
No caso de grafos dirigidos, o grafo complementar G ser aquele que possui os mesmos vrtices de G, possui todas as arestas no presentes em G e possui o reverso das arestas de G. Por exemplo: Grafo G a b c c d b Grafo G a d
2.1.4.6 Grafo Bipartite Se G(V1 V2,A) tal que, para V1 V2 = e para toda aresta (vi,vj) A, tem-se que vi V1 e vj V2, ento o grafo denominado bipartite. Ou seja, o grafo pode ser dividido logicamente em dois conjuntos de vrtices, tal que toda aresta comea no vrtice de um dos conjuntos e termina no vrtice do outro conjunto.
12
c d
V1 = {a.,b} V2 = {c,d,e}
2.1.4.7 Grafo Dirigido Um grafo chamado de dirigido (ou dgrafo) se suas arestas possuem orientao. Caso contrrio o grafo no dirigido. Em termos leigos: ser dirigido se suas arestas forem flechas que apontam o vrtice inicial e final de cada aresta. 2.1.4.8 Grafos Isomorfos Dois grafos so isomorfos se coincidirem os vrtices de suas representaes grficas, preservando as adjacncias das arestas. Em outras palavras, so isomorfos se tm a mesma representao matemtica, mas so representados diferentemente graficamente. Formalmente pode-se dizer que G1(V1,A1) e G2(V2,A2) so isomorfos se satisfizerem as seguintes condies: 1) |V1| = |V2| = n. 2) Existe uma funo bijetora f: V1 V2, tal que (v,w) A1 ((f(v),f(w)) A2 v,w V1. a b c a b c c c b b a a
2.1.4.9 Grau e Grafos Regulares O grau de um vrtice v V denotado por gr(v) = nmero de arestas incidentes a v (sendo que um lao equivale a duas arestas). Um grafo dito regular de grau r se todos os vrtices possuem grau r. Ou seja, todos os vrtices possuem o mesmo grau. Teorema 1 A soma dos graus dos vrtices de um grafo igual a duas vezes o nmero de arestas. Teorema 2 Em qualquer grafo existe sempre um nmero par de vrtices de grau mpar.
2.1.4.10 Grafo Valorado Seja pi um nmero associado a cada aresta e qj um nmero associado a cada vrtice de um grafo G(V,A). Ento G denominado de grafo valorado e o nmero pi chamado de custo da aresta e o nmero qj chamado de custo do vrtice. Custo da aresta pode significar distncia, altitude, capacidade, fluxo etc.
13
Custo do vrtice pode significar capacidade, entradas, etc. 10km 8km 16km
2.2
Sucessores e Antecessores de um Grafo Dirigido
Formalmente, os vrtices sucessores e antecessores de um grafo dirigido so definidos da seguinte forma: v sucessor de w <=> (w,v) A v antecessor de w <=> (v,w) A Os conjuntos de todos os vrtices sucessores e antecessores de um dos vrtices de um grafo so formalmente definidos da seguinte forma: +(v) = {w/(v,w) A --> conjunto de sucessores de v -(v) = {w/(w,v) A --> conjunto de antecessores de v Exemplo: b a c +(a) = {b,c} -(a) = { } +(b) = {c} -(b) = {a} +(c) = {d} -(c) = {a,b} +(d) = { } -(d) = {c} d
2.3
Representao de Grafos em um Computador
Para que um grafo seja armazenado em um computador, necessrio definir dois aspectos: Quais informaes devem ser consideradas Como armazenar as informaes no computador, ou seja, definir a estrutura de dados que ser utilizada. A estrutura de dados particularmente importante, pois a eficincia de um algoritmo que ir trabalhar sobre o grafo vai depender da escolha certa de como representar o grafo. De uma forma geral, pode-se representar um grafo utilizando matrizes ou listas, como veremos a seguir. 2.3.1 Matriz de Adjacncia Dado um grafo G(V,A), a matriz de adjacncia A = [aij] uma matriz n x n tal que aij = 1 se e somente se existe (vi, vj) Aj 0 caso contrrio Exemplo:
14
a2 a1 a2
a4 a3 a3 1 2 3 4
1 0 1 0 0
2 1 0 1 1 1 1 0 0 0
3 0 1 0 1 j 2 1 0 0 1 j 2 2 0 0 1
4 0 1 1 0 3 0 1 0 0 4 0 0 1 0
a1
a4
1 2 3 4
c 1 2 3 4 1 0 0 0 0
3 0 1 0 0
4 0 0 1 0
2.3.2 Matriz de Custo Um grafo valorado pode ser representado por uma matriz de custo w = {wij}, onde wij = custo da aresta, se (vi, vj) A caso (vi, vj) A (ou seja, caso no exista aresta) Exemplo: a2 1 5 a1 a4 i 2 a3 8 1 2 3 4 1 1 j 2 1 2 5 3 2 8 4 5 8
2.3.3 Matriz de Incidncia Dado um grafo G(V,A) de n vrtices e m arestas a matriz de incidncia de G denotada por B = [bij] uma matriz n x m definida por: bij = 1 se vi vrtice de aj 0 caso contrrio
15
Se o grafo G for orientado (dgrafo), ento poder ser definida como: bij = 1 se vi for vrtice inicial de aj (ou se existir um lao no vrtice vi) -1 se vi for vrtice final de aj 0 se o vrtice vi no pertence aresta aj Exemplo: 2 a d 1 e 1 a 2 d 4 b c 3 1 2 vrtices 3 4 a 1 -1 0 0 4 b 3 c 1 2 vrtices 3 4 a 1 1 0 0 arestas b c 0 0 1 0 1 1 0 1 arestas b c 0 0 1 0 -1 1 0 -1 d 0 1 0 1 e 1 0 0 0
d 0 -1 0 1
2.3.4 Lista de Arestas Pode-se representar um grafo em um computador utilizando-se duas listas de vrtices, representando as arestas do grafo. As listas podem ser vetores simples. A primeira lista contm os vrtices de incio de cada aresta. A segunda lista contm os vrtices onde cada uma delas termina. Por exemplo: v2 v5 v1 v4 v3 L1 = (v2,v3,v3,v4,v5,v5) L2 = (v1,v2,v5,v3,v2,v4)
2.3.5 Estrutura de Adjacncia Um grafo pode ser representado por uma lista de vrtices e, para cada vrtice da lista, associada uma lista dos seus respectivos sucessores. Exemplo: 2 1 5 3 4 1 2 3 4 5 3 1 3 1 5 2 3 3
16
2.4
Caminho e Conexidade
2.4.1 Caminho Formalmente temos o seguinte: Definio: seja G(V,A) um grafo. Ento define-se um caminho de G como sendo uma seqncia de arestas da forma (u,v),(v,w),(w,x),...,(y,z), onde cada aresta pertence ao grafo G. O caminho denotado acima definido, tambm, como o caminho entre u e z e pode ser representado por: u v w x ... y z. O exemplo abaixo mostra um caminho entre d e c. O caminho denotado por d a b c. a b c
2.4.2 Cadeia Definio: uma cadeia uma seqncia de arestas de um grafo G, tal que qualquer par de arestas subseqentes possuem um vrtice de incidncia comum. Ao contrrio da definio de caminho, uma cadeia ignora a orientao das arestas. Portanto, todo caminho uma cadeia, porm a recproca nem sempre verdadeira. Veja o seguinte exemplo: b a d c A seqncia a b c d um caminho, tambm uma cadeia. A seqncia a b d c uma cadeia, mas no um caminho.
Caminho: segue a orientao Cadeia: no precisa seguir a orientao

2.4.3 Comprimento Definio: o nmero de arestas k que compem um caminho (ou cadeia) denominado de comprimento do caminho (ou da cadeia). Exemplo. b O caminho a b c d um caminho entre a e d de comprimento igual a 3 a c d
17
2.4.4 Caminho Simples x Trajetria Definio: se os vrtices de um caminho (ou cadeia) forem distintos (com exceo do vrtice inicial e o vrtice final), ento a seqncia recebe o nome de caminho simples (ou cadeia simples). Se as arestas da seqncia forem distintas, ento a seqncia recebe o nome de trajeto ou trajetria. Exemplo: 2 1 6 4 5 3 A seqncia 1 2 3 4 5 um caminho simples. A seqncia 1 2 3 4 2 uma trajetria. A seqncia 1 2 3 4 2 1 apenas uma seqncia.
2.4.5 Grafo Conexo Definio: um grafo G conexo se existe pelo menos um caminho (ou cadeia) entre qualquer par de vrtices de G. Caso contrrio o grafo desconexo. Exemplo:
a) Grafo conexo b) Grafo desconexo Todo grafo desconexo composto por subgrafos conexos chamados de componentes. Por exemplo, o grafo b) um grafo desconexo composto por 2 componentes. 2.4.6 Caminhos abertos e fechados Um caminho em G denominado fechado se o vrtice final o mesmo que o vrtice inicial. Caso contrrio, o caminho denominado aberto. Exemplo: b a e d c Caminho aberto: b d c e Caminho fechado: b d c e b
De forma semelhante a um caminho fechado, uma cadeia fechada de um grafo uma cadeia de G tal que a aresta inicial e a aresta final possuem um vrtice de incidncia em comum, ou em outras palavras, se o vrtice inicial e o vrtice final se confundem. 2.4.7 Circuito e Ciclo Um circuito um caminho simples fechado. Um ciclo uma cadeia simples fechada. Exemplo:
18
b a d
c Circuito: a b c d a Ciclo: d c b d
Um grafo que no contm nenhum ciclo chamado de grafo acclico. 2.4.8 Algoritmo de Goodman Esse algoritmo verifica se um grafo conexo e identifica seus componentes no caso de ser desconexo. A idia consiste em reduzir cada componente a um nico ponto. Nesse algoritmo necessitamos da definio de fuso de dois vrtices Fuso Dados dois vrtices u e v adjacentes de um grafo G, a fuso de v com u feita eliminando-se a aresta (v,u) e em seguida tornando v e u um nico vrtice. O vrtice resultante desta fuso um vrtice w adjacente a todos os vrtices anteriormente adjacentes a u e/ou v. Exemplo: a u v b Aps a fuso de u e v w a b
O procedimento consiste da escolha de um vrtice inicial v0 e a fuso de um vrtice com ele. Isto repetido at que no reste qualquer vrtice adjacente a v0. Caso reste algum vrtice no adjacente a v0, ento novo vrtice v0 selecionado e o processo repetido. Se no final o grafo resultante for apenas um vrtice, ento o grafo conexo. Caso contrrio, o nmero de vrtices representar o nmero de componentes do grafo. Entrada: grafo G(V,A) Sada: varivel c contendo o nmero de componentes. P0. [inicialize] H G; c 0; P1. [Gere a prxima componente] Enquanto H 0 faa Selecione um vrtice v0 H; Enquanto v0 for adjacente a algum vrtice u H faa H grafo resultante da fuso de u com v0. Remova v0, isto , faa H H v0; c c + 1; P2.[Teste do Tipo de conexidade] Se c>1 ento G desconexo. Seno G conexo.
19
Exemplo: a f c a f c a f d a f d d f Vrtice d. Fuso com a. d b Vrtice d. Fuso de d com b. e d b Vrtice d. Fuso de d com c. b 1o. passo: escolher um vrtice. Vrtice d. Fuso de d com e.
2.5
Localizao de Centros (em grafos no valorados)
2.5.1 Distncia Dados dois vrtices v e w pertencentes ao grafo G(V,A), denomina-se distncia entre v e w, o comprimento do menor caminho entre dois vrtices v e w. No caso da no existncia desse caminho, considera-se a distncia infinita. Notao: d(v,w) = distncia entre os vrtices v e w = comprimento do menor caminho entre v e w Denotamos por D(G) a matriz de distncias de um grafo, onde dij=(vi,vj) Em um grafo conexo, distncia uma mtrica, isto , para todo vrtice de G(V,A) tem-se que: i) d(u,v)>=0 com d(u,v)=0 se e somente se u=v. ii) d(u,v) = d(v,u) ocorre apenas quando o grafo no orientado; iii) d(u,v) + d(v,w) >= d(u,w)
20
2.5.2 Pista Uma pista (xi,xj) ou (ij) ou ij um caminho de comprimento mnimo entre xi e xj, ou seja, um caminho de comprimento igual a d(xi,xj). Por exemplo, considere o grafo abaixo: b f a c g
Qual a distncia entre a e g? d(a,g) = 3, (a,g) = (a,b,f,g) (a,e) = (a,b,f,e) ou (a,c,d,e) 2.5.3 Excentricidade A excentricidade de um vrtice v, denotado por e(v), a mxima das distncias d(v,u), isto : e(v) = Max{d(v,u), u G} Em outras palavras, a excentricidade de um vrtice v a maior distncia existente a partir de v. 2.5.4 Raio O raio de um grafo G, denotado por r(g), o mnimo das excentricidades dos vrtices de G Min(e(v)). Assim, r(G) = Min{e(v), v G}. 2.5.5 Centro O centro de um grafo G definido pelo conjunto de vrtices v tais que e(v) = r(g), isto , centro = {v G / e(v) = r(G) }. Em uma rede de comunicao, a localizao de um ponto importante (uma rede de transmisso, por exemplo) em um centro do grafo que representa a rede , a priori, uma providncia no sentido de procurar reduzir ao mximo o nmero de transmisses de mensagens ou de equipamentos de conexo envolvidos. Exemplo: localizar o centro do grafo abaixo. a b c e d a b c d e a 0 1 1 2 1 b 1 0 1 2 2 c 1 1 0 1 1 d 2 2 1 0 1 e 1 2 1 1 0 e(v) 2 2 1 2 2
21
raio = r(G) = 1 centro = {c} 2.5.6 Centro de um grafo dirigido Em um grafo dirigido, define-se excentricidade de um vrtice v por es = Max{d(v,u), u G} Define-se excentricidade de retorno de um vrtice v por er = Max{d(u,v), u G} O raio de um dgrafo G definido por: r(G) = Min{es(v), er(v)} Centro de um dgrafo G definido pelo conjunto de vrtices v tais que es(v) = r(G) ou er(v) = r(G), isto : centro = {v G / es(v) = r(G) ou er(v) = r(G)} Por exemplo, localize o centro do grafo G abaixo: a b c e d a a 0 b 3 c 2 d 2 e 1 er(v) 3 raio = r(G) = 2 centro = {a,e} 2.5.7 Localizao de Centros de Emergncia Aqui o interesse determinar o centro de um grafo de tal modo que o tempo de ida e de volta seja mnimo ( o caso da localizao de hospitais, polcia, bombeiro, etc). Observe que, neste caso, os vrtices representam uma populao e, como tal, devem ser levados em considerao. Definio: A excentricidade de sada e retorno de um vrtice definida por: esr(xi) = Max {pj [d(xi,xj) + d(xj,xi)]} onde j o peso do vrtice xj. Este peso pode ser entendido como a importncia do vrtice. Por exemplo, para localizao de um hospital, o tamanho da populao num bairro pode ser uma informao importante. b 1 0 3 3 2 3 c 1 1 0 3 2 3 d 2 2 1 0 3 3 e 2 2 1 1 0 2 es(v) 2 3 3 3 3
22
Definio: O raio de um grafo G considerando ida e volta definido por r(G) = Min{esr(xi)}. Definio: O centro de emergncia de um grafo G definido pelo conjunto de vrtices v tal que esr(v) = r(G). Centro de emergncia = {v G/ esr(v) = r(G)} Por exemplo, considere o seguinte dgrafo. Localize o centro de emergncia do grafo. x1 x6 x2
x5 x4
x3
D(G) x1 x2 x3 x4 0 1 2 3 3 0 1 2 4 3 0 1 3 2 3 0 2 1 2 3 1 2 3 4
D(G) + DT x5 x6 x5 x6 x x x x x x esr 1 2 3 4 5 6 2 3 2 1 0 4 6 6 4 4 6 1 2 1 2 4 0 4 4 2 4 4 2 3 2 3 6 4 0 4 4 6 6 1 2 3 4 6 4 4 0 4 6 6 0 1 0 3 4 2 4 4 0 4 4 3 0 1 0 4 4 6 6 4 0 6 Como o peso de cada vrtice igual a 1, ento podemos calcular a excentricidade diretamente da matriz D(G) + DT(G). Portanto, o centro de emergncia do grafo formado pelo conjunto {x2,x5}. Exerccios: 1 Desenhe o grafo cuja matriz de adjacncia dada por: 1 0 1 1 0 0 1 1 0 1 0 1 0 2 3 1 1 0 1 0 0 4 0 0 1 0 1 1 5 0 1 0 1 0 1 6 1 0 0 1 1 0
DT x1 x2 x3 x4 0 3 4 3 1 0 3 2 2 1 0 3 3 2 1 0 2 1 2 1 3 2 3 2
23
2 Desenhe o grafo a partir da lista de adjacncia: 1 21 1 3 4 2 4 2 2 3 4
3 Localize o centro dos grafos abaixo. Para isso, determine o raio do grafo e a excentricidade dos vrtices. a a b c d e c e f b d
24
2.6
Algoritmos e problemas clssicos com grafos
Existem vrios algoritmos e problemas considerados clssicos na rea de Teoria dos Grafos. Um desses problemas o de encontrar um caminho mnimo entre dois vrtices. Existem vrios algoritmos que resolvem esse problema. Um deles o algoritmo de Floyd. 2.6.1 Algoritmo de Floyd Inicialmente, esse algoritmo faz uma matriz de custo do grafo. Ou seja, ele verifica a distncia entre cada par de vrtices. Se existir uma aresta, o valor que ele coloca naquela posio da matriz o custo da aresta. Se no existir uma aresta entre o par de vrtice, ele coloca o valor . Em seguida, ele verifica se existe um caminho de menor custo entre cada par de vrtices, ao passar por um vrtice intermedirio. Ou seja, suponha um grafo com 5 vrtices. De um modo geral, aps montar a matriz de distncias, ele far 5 iteraes: 1. Iterao: descobrir se h caminhos que ficam menores ao passar pelo vrtice 1 2. Iterao: descobrir se h caminhos que ficam menores ao passar pelo vrtice 2 3. Iterao: descobrir se h caminhos que ficam menores ao passar pelo vrtice 3 4. Iterao: descobrir se h caminhos que ficam menores ao passar pelo vrtice 4 5. Iterao: descobrir se h caminhos que ficam menores ao passar pelo vrtice 5 Algoritmo: Parte1 Construir a matriz de distncia e a matriz de roteamento 0, se i=j D0ij = , se no existe aresta entre o vrtice i e o vrtice j custo da aresta entre o vrtice i e o vrtice j R0ij = j, se dij < 0, caso contrrio
Parte2 Verificar, para cada posio da matriz, se existe um caminho mais curto Considerando que n o nmero de vrtices: Para k:= 1 to n do Begin Para i:=1 to n do Begin Para j:=1 to n do Begin If (Dk-1 ik + Dk-1 kj < Dk-1 ij) then Begin Dkij := Dk-1 ik + Dk-1kj; Rkij := Rk-1ik; End End; End; End;
25
Por exemplo, considerando o grafo abaixo, vamos aplicar o algoritmo de Floyd para encontrar a matriz de custo mnimo. v2 v3
v1 v4
v5
O primeiro passo, ento, construir as matrizes de distncia e a matriz de roteamento: v1 v2 v3 v4 v5 v1 0 1 v1 1 0 0 1 0 v2 5 0 1 1 v2 2 2 0 2 2 v3 3 0 v3 0 3 3 0 0 v4 3 0 1 v4 4 0 0 4 4 v5 5 1 0 v5 0 0 5 5 5
v1 v2 v3 v4 v5
26
Agora, ento, o algoritmo far vrias iteraes para tentar verificar se existe um caminho mais curto entre cada pares de vrtices. No incio temos: K=1, i=1, j=1 se D011 + D011 < D011? 0 + 0<0? No! K=1, i=1, j=2 se D011 + D012 < D012? 0 + 5 < 5? No! K=1, i=1, j=3 se D011 + D013 < D013? 0 + < ? No! K=1, i=1, j=4 se D011 + D014 < D014? 0 + 3 < 3? No! K=1, i=1, j=5 se D011 + D015 < D015? 0 + < ? No! O significado aqui o seguinte. Para ir do vrtice 1 para qualquer outro, o caminho fica mais curto se eu passar primeiro pelo vrtice 1? Como j chegou em n, que igual a 5 (nmero de vrtices), ento a execuo sai do lao. Ento i incrementado para 2. Temos ento: K=1, i=2, j=1 se D021 + D011 < D021? + 0 < ? No! K=1, i=2, j=2 se D021 + D012 < D022? + 5 < 0? No! K=1, i=2, j=3 se D021 + D013 < D023? + < 3? No! K=1, i=2, j=4 se D021 + D014 < D024? + 3 < ? No! K=1, i=2, j=5 se D021 + D015 < D025? + < ? No! O significado aqui o seguinte: na ltima iterao que vimos, por exemplo, o que eu estou querendo saber se, para ir do vrtice v2 ao vrtice v5, mais perto ir primeiro do v2 pro v1, e ento do v1 pro v5, em vez de ir direto. Ou seja, estou verificando se utilizar o vrtice 1 como intermedirio encurta o caminho. Em outras palavras, para ir do vrtice 2 para qualquer outro, o caminho fica mais curto se eu passar primeiro pelo vrtice 1? Vimos que, para este grafo, no. Continuando ento, i incrementado para 3. Temos ento: K=1, i=3, j=1 se D031 + D011 < D031? + 0 < ? No! K=1, i=3, j=2 se D031 + D012 < D032? + 5 < ? No! K=1, i=3, j=3 se D031 + D013 < D033? + < 0? No! K=1, i=3, j=4 se D031 + D014 < D034? + 3 < ? No! K=1, i=3, j=5 se D031 + D015 < D035? + < 5? No! Continuando, i incrementado para 4. Temos ento: K=1, i=4, j=1 se D041 + D011 < D041? 1 + 0 < 1? No! K=1, i=4, j=2 se D041 + D012 < D042? 1 + 5 < 1? No! K=1, i=4, j=3 se D041 + D013 < D043? 1 + < ? No! K=1, i=4, j=4 se D041 + D014 < D044? 1 + 3 < 0? No! K=1, i=4, j=5 se D041 + D015 < D045? 1 + < 1? No! Continuando, i incrementado para 5. Temos ento: K=1, i=5, j=1 se D051 + D011 < D051? + 0 < ? No! K=1, i=5, j=2 se D051 + D012 < D052? + 5 < 1? No! K=1, i=5, j=3 se D051 + D013 < D053? + < ? No! K=1, i=5, j=4 se D051 + D014 < D054? + 3 < 1? No! K=1, i=5, j=5 se D051 + D015 < D055? + < 0? No!
27
Agora, i j chegou ao valor n, ou seja, i=5. Neste caso, o loop chega ao fim. Agora, a varivel k incrementada e passa ser 2. Isso significa que agora vamos ver, para cada par de vrtices, se o uso do v2 como intemedirio torna o caminho mais curto. K=2, i=1, j=1 K=2, i=1, j=2 K=2, i=1, j=3 K=2, i=1, j=4 K=2, i=1, j=5 se D012 + D021 < D011? se D012 + D022 < D012? se D012 + D023 < D013? se D012 + D024 < D014? se D012 + D025 < D015? 5 + < 0? No! 5 + 0 < 5? No! 5 + 3 < ? Sim!!!!!!!!!! 5 + < 3? No! 5 + < ? No!
No momento em que eu achei um curto, ento gero a minha matriz D 1. Na prtica, no algoritmo, possvel apenas sobrescrever os valores anteriores. A minha matriz de distncias e a de roteamento passam a ser: v1 v2 v3 v4 v5 v1 0 1 v2 5 0 1 1 v3 8 3 0 v4 3 0 1 v5 5 1 0 v1 v2 v3 v4 v5 v1 1 0 0 1 0 v2 2 2 0 2 2 v3 2 3 3 0 0 v4 4 0 0 4 4 v5 0 0 5 5 5
Reparem que a matriz de roteamento agora indica que, para ir do vrtice v1 para o vrtice v3, preciso primeiro passar pelo vrtice v2.
Continuando temos: K=2, i=2, j=1 se D022 + D021 < D021? K=2, i=2, j=2 se D022 + D022 < D022? K=2, i=2, j=3 se D022 + D023 < D023? K=2, i=2, j=4 se D022 + D024 < D024? K=2, i=2, j=5 se D022 + D025 < D025? Continuando temos: K=2, i=3, j=1 se D032 + D021 < D031? K=2, i=3, j=2 se D032 + D022 < D032? K=2, i=3, j=3 se D032 + D023 < D033? K=2, i=3, j=4 se D032 + D024 < D034? K=2, i=3, j=5 se D032 + D025 < D035? Continuando temos: K=2, i=4, j=1 se D042 + D021 < D041? K=2, i=4, j=2 se D042 + D022 < D042? K=2, i=4, j=3 se D042 + D023 < D043? K=2, i=4, j=4 se D042 + D024 < D044? K=2, i=4, j=5 se D042 + D025 < D045?
0 + < ? No! 0 + 0 < 0? No! 0 + 3 < 3? No! 0 + < ? No! 0 + < ? No! + < ? No! + 0 < ? No! + 3 < 0? No! + < ? No! + < 5? No! 1 + < 1? 1 + 0 < 1? 1 + 3 < ? 1 + < 0? 1 + < 1? No! No! Sim!!!!! No! No!
28
As matrizes passam a ser, ento: v1 v2 v3 v4 v5 v1 0 1 v1 1 0 0 1 0 v2 5 0 1 1 v2 2 2 0 2 2 v3 8 3 0 4 v3 2 3 3 2 0 v4 3 0 1 v4 4 0 0 4 4 v5 5 1 0 v5 0 0 5 5 5
v1 v2 v3 v4 v5
29
Continuando temos: K=2, i=5, j=1 se D052 + D021 < D051? K=2, i=5, j=2 se D052 + D022 < D052? K=2, i=5, j=3 se D052 + D023 < D053? K=2, i=5, j=4 se D052 + D024 < D054? K=2, i=5, j=5 se D052 + D025 < D055? As matrizes passam a ser, ento: v1 v2 v3 v4 v5 v1 0 1 v1 1 0 0 1 0 v2 5 0 1 1 v2 2 2 0 2 2 v3 8 3 0 4 4 v3 2 3 3 2 2 v4 3 0 1 v4 4 0 0 4 4 v5 5 1 0 v5 0 0 5 5 5
1 + < ? No! 1 + 0 < 1? No! 1 + 3 < ? Sim!!! 1 + < 1? No! 1 + < 0? No!
v1 v2 v3 v4 v5
30
Repetindo ento o processo para k=3, k=4 e k=5, no final teremos as duas seguintes matrizes: v1 v2 v3 v4 v5 v1 0 10 7 1 2 v2 4 0 6 1 1 v3 7 3 0 4 4 v4 3 9 6 0 1 v5 4 8 5 1 0 v1 v2 v3 v4 v5 v1 1 3 5 1 4 v2 4 2 5 2 2 v3 4 3 3 2 2 v4 4 3 5 4 4 v5 4 3 5 5 5
Assim, a matriz da esquerda indica qual ser o custo mnimo pra ir de um vrtice a outro, enquanto a matriz da direita mostra qual o caminho que dever ser percorrido para ir de um vrtice a outro com o custo mnimo. Por exemplo: Para ir do vrtice v1 para o vrtice v2, o caminho mais curto, de custo 4, passando pelo vrtice v4. Ou seja, v1-v4-v2. Para ir do vrtice v1 para o vrtice v3, o caminho mais curto, de custo 7, passando pelo vrtice v4. No entanto, vemos na matriz de roteamento que no podemos ir direto do v4 para o v3, preciso passar pelo vrtice v2. Assim, a rota ento v1-v4-v2-v3. Olhando apenas para essa matriz, responda: a) Qual a rota de custo mnimo entre o vrtice v1 e o vrtice v5? b) Qual a rota de custo mnimo entre o vrtice v4 e o vrtice v3? c) Qual a rota de custo mnimo entre o vrtice v5 e o vrtice v1? Exerccio Utilizando o algoritmo de Floyd, encontre a matriz de custo mnimo e a matriz de roteamento para o grafo abaixo:
31
2.6.1 Algoritmo de Dijkstra O algoritmo de Dijkstra semelhante ao de Floyd. Inicialmente, o usurio tambm deve entrar com a matriz de custo do grafo. No entanto, este algoritmo considera que o grafo tem um vrtice inicial. Assim, ele s calcula o caminho mnimo do vrtice inicial para todos os outros. Portanto, o usurio deve definir em seguida qual o vrtice inicial. O algoritmo gera ento dois vetores simples: 1)uma matriz de rota e 2)uma matriz de custo mnimo. Leia (Custo[ ]); Leia (vert); Para i = 1 .. n faa Begin Rota[i] = vert; Dist[i] = Custo[vert,i] End Para a = 1.. n faa Para todo k +(a) Begin P = mn(D[k], D[a]+Custo[a,k]); If (P < D[k]) Then Begin Rota[k] = a; Dist[k] = P; End //ler matriz de custo //ler vrtice inicial // n o nmero de vrtices // Rota do vrtice inicial at o vrtice i // Custo inicial do vrtice inicial at o vrtice i //Para todo vrtice k que sucessor do vrtice a
S lembrando que os vrtices sucessores de a sero aqueles que tm um valor de custo diferente de 0 (ou seja, no o prprio vrtice) e diferente de (ou seja, no existe aresta entre eles e, portanto, o vrtice no um sucessor). Considere por exemplo o seguinte grafo: 1 10 7 8 5 5 4 Inicialmente, o algoritmo solicita que o usurio entre a matriz de custo do grafo. 1 2 3 4 5 1 0 2 10 2 0 3 7 3 0 4 4 0 5 8 5 0 4 3 2 2 3
32
Em seguida, pergunta qual o vrtice inicial. Vamos considerar que o vrtice inicial o vrtice 1. Temos ento: Vert = 1 Rota[1,1,1,1,1]. Dist[0,2, ,,10] Ou seja, inicialmente ele inicializa todas as posies do vetor Rota com o vrtice inicial. Em seguida, coloca o custo das arestas do vrtice inicial para todas as outras. Quando a aresta no existe, o valor colocado. a = 1, k=1 k=2 k=3 k=4 k=5 vrtice 1 no sucessor de 1 D[2] x D[1] + Custo[1,2] 2 x 0+2 p=2. p < D[k]?? 2 <2 ? No! vrtice 3 no sucessor de 1 4 no sucessor de 1 D[5] x D[1] + Custo[1,5] 10 x 0+10 p=10 p < D[k]? 10 < 10? No!
a = 2, k=1 vrtice 1 no sucessor de 2 k=2 vrtice 2 no sucessor de 2 k=3 D[3] x D[2] + Custo[2,3] x 2+3 p=5 p<D[k]? 5<? Sim!! Rota[3]=2, Dist[3]=5 Rota[1,1,2,1,1] e Dist[0,2,5, ,10] k=4 4 no sucessor de 2 k=5 D[5] x D[2] + Custo[2,5] 10 x 2+7 p=9 p < D[k]? 9 < 10? Sim! Rota[5]=2, Dist[5]=9 Rota[1,1,2,1,2] e Dist[0,2,5, ,9] a = 3, k=1 vrtice 1 no sucessor de 3 k=2 vrtice 2 no sucessor de 3 k=3 vrtice 3 no sucessor de 3 k=4 D[4] x D[3] + Custo[3,4] x 5+4 p=9 p < D[4]? 9 < ? Sim! Rota[4]=3, Dist[4]=9 Rota[1,1,2,3,2] e Dist[0,2,5, 9,9] k=5 vrtice 5 no sucessor de 3 a = 4, k=1 k=2 k=3 k=4 k=5 a = 5, k=1 k=2 k=3 k=4 k=5 vrtice 1 no sucessor de 4 vrtice 2 no sucessor de 4 vrtice 3 no sucessor de 4 vrtice 4 no sucessor de 4 vrtice 5 no sucessor de 4 vrtice 1 no sucessor de 5 vrtice 2 no sucessor de 5 D[3] x D[5] + Custo[5,3] 5 x 9+8 p=5 p < D[3]? 5 < 5? No! D[4] x D[5] + Custo[5,4] 9 x 9+5 p=9 p < D[4]? 9 < 9? No! vrtice 5 no sucessor de 5
Assim, no final temos:
33
Rota[1,1,2,3,2] e Dist[0,2,5,9,9]. Exerccio 1 Para o mesmo grafo, repita o procedimento acima, mas considerando que o vrtice inicial o vrtice 2. Exerccio 2 Para o seguinte grafo, aplique o algoritmo passo a passo, de forma a descobrir a matriz de rota e a matriz de custo mnimo. Considere que o vrtice 1 vrtice inicial. Determine ento a pista do vrtice 1 para todos os outros vrtices 2 10 1 5 5 2 3 2 9 7 4 4 6 1 3
2.6.2 Grafos de Euler Define-se um caminho de Euler como sendo um caminho fechado passando uma nica vez por cada aresta do grafo (percorrendo todas as arestas do grafo). Todos os grafos que admitem um caminho de Euler so chamados de grafos de Euler. TEOREMA: Um grafo conexo G (simples, no orientado) um grafo de Euler se e somente se todos os seus vrtices so de grau par. TEOREMA: Um dgrafo G contm um circuito de Euler se e somente se os graus de entrada e sada de cada vrtice forem iguais. Exemplos:
a) No grafo de Euler
b)No grafo de Euler
c) Grafo de Euler
2.6.3 Problema do Carteiro Chins A noo de grafos de Euler e caminhos de Euler so utilizadas quando necessrio atender seqencialmente a um conjunto de usurios, sendo que todos devem ser atendidos. Exemplo so: entrega de correio, coleta de lixo, etc. O problema do carteiro chins consiste em encontrar um caminho que passe por TODAS AS ARESTAS do grafo G(V,A) pelo menos uma vez, de preferncia uma nica vez. H dois tipos de soluo para esse problema: Soluo 1 Quando o grafo de Euler. Nesse caso, o caminho pode ser achado (e tambm seu respectivo custo). Para isso, utiliza-se o algoritmo de Fleury.
34
Soluo 2 Quando o grafo no de Euler. Nesse caso, algumas arestas tero que ser repetidas e utiliza-se um algoritmo diferente. 2.6.3.1 Algoritmo de Fleury Este algoritmo parte do pressuposto de que G um grafo de Euler. Para executar o algoritmo, deve-se iniciar em qualquer vrtice v e atravessar as arestas de maneira arbitrria, seguindo as seguintes regras: Regra 1 Apague a aresta que foi visitada e, se algum vrtice ficar isolada, apague-o tambm. Regra 2 Em cada estgio, use uma ponte (istmo) somente se no houver alternativa. Isto , nunca atravesse uma aresta se essa aresta divide o grafo em duas componentes (excluindo o vrtice isolado. Observao: uma ponte (istmo) uma aresta do grafo G cuja remoo divide o grafo G em duas componentes conexas de ordem maior que 1. Por exemplo, no exemplo abaixo, a aresta d uma ponte. b a c d e g f
Vamos considerar, por exemplo, o grafo abaixo e aplicar o algoritmo de Fleury, considerando o vrtice 6 como vrtice inicial (que, conseqentemente, deve ser tambm o vrtice final. 1 2 3 a g 4 5 b c h 6 d e i 7 f
Pode-se iniciar o algoritmo por qualquer aresta que saia do vrtice 6. Por exemplo, as arestas d, e, h, i. Conforme a implementao, pode-se deixar a escolha aleatria, ou pegar sempre o primeiro vrtice, conforme a ordem em que o usurio digitou. Por exemplo, vamos iniciar pela aresta d, que deve ento ser removida. Temos ento a configurao da Figura 2. Em seguida a nica aresta possvel que pode ser removida a c. Ao removermos a aresta c, o vrtice 2 fica isolada, sendo removido. Temos ento a configurao da Figura 3. 1 a g 4 5
Figura 2
2 b c h 6 e
3 f i 7 4 a
1 b g 5
Figura 3
3 e h 6 i 7 f
35 e
3 f i 7
O processamento est agora no vrtice 5. Como a aresta h g uma ponte, no se pode h escolh-la. Pode-se ento passar pela aresta b ou g. Vamos percorrer a5aresta b, gerando 4 6 ento a configurao da Figura 4. Em seguida, a nica opo percorrer a aresta a. Ao eliminarmos essa aresta, o vrtice 1 fica isolado e, portanto, tambm eliminado. A configurao do grafo mostrada na Figura 5. 1 a g 4 5
Figura 4
3 e h 6 i 7 3
Figura 5
e O processamento do algoritmo est agora no vrtice 4. A nica opo, portanto, a aresta g, que percorrida e eliminada. Como o vrtice 4 ficou isolado, tambm eliminado 6 (Figura 6). No vrtice 5, a nica opo a aresta h, que percorrida e eliminada, juntamente com o vrtice 5. Temos ento a configurao da Figura 7. 3 e h 5
Figura 6
f i 7
f i 7
Figura 7
No vrtice 6, novamente h duas opes: a aresta e e a aresta i. Como estvamos seguindo sempre a aresta de menor ordem alfabtica, vamos percorrer a aresta e, que eliminada (Figura 8). Em seguida, a nica opo a aresta f, que eliminada juntamente com o vrtice 3. Temos ento a configurao da Figura 9. 3 f i 6
Figura 8
i 7
Figura 9
36
No vrtice 7, a nica opo a aresta i, que percorrida e eliminada, juntamente com o vrtice 7. Chegamos ento no vrtice final, que tambm o final, e o algoritmo acaba.
6 O algoritmo de Fleury, propriamente dito, pode ser expresso da seguinte forma: Ler grafo G(V,A) G' := G v0 := um vrtice de G' C := [v0] //Inicialmente, o caminho de Euler contm s o vrtice inicial v0 Enquanto A' no vazio //Ou seja, enquanto ainda existirem arestas vi := ltimo vrtice de C Se vi tem s uma aresta incidente; ai := a aresta incidente a vi em G' Seno ai := uma aresta incidente a vi em G' e que no uma ponte Retirar a aresta ai do grafo G' Acrescentar ai no final de C vj := vrtice ligado a vi por ai Acrescentar vj no final de C Retornar C No caso do exemplo mostrado, ento, as variveis do algoritmo teriam o seguinte comportamento: A = {a,b,c,d,e,f,g,h,i} V = {1,2,3,4,5,6,7} C == [6] Figura 2 Vi:= 6 ai := d A = {a,b,c,e,f,g,h,i} C = [6,d] vj := 2 C = [6,d,2] Figura 3 Vi:=2 Ai:= c A = {a,b,e,f,g,h,i} C = [6,d,2,c] Vj:= 5 C = [6,d,2,c,5]
37
... Exerccio Considere o grafo abaixo. a) Mostre por que um grafo de Euler. b) Aplique o algoritmo de Flery, considerando o vrtice x1 como inicial. c) Aplique o algoritmo novamente, considerando o vrtice x4 como inicial. Nos itens b) e c), mostre o grafo sendo percorrido passo a passo, juntamente com o valor das variveis do algoritmo no momento. x1
x7
x6
x2
x8
x5
x3
x4 2.6.4 Caminho e Circuito Hamiltoniano De forma resumida, um caminho que passa exatamente uma vez por cada vrtice de um grafo chamado hamiltoniano. Se o caminho comea e termina no mesmo vrtice, temos um circuito hamiltoniano. Um grafo que contm um ciclo hamiltoniano um grafo hamiltoniano. De forma formal: um circuito hamiltoniano em um grafo conexo G pode ser definido como um caminho simples fechado que passa em cada vrtice de G exatamente uma vez. Portanto, um circuito hamiltoniano de um grafo conexo de n vrtices consiste exatamente de n arestas. possvel, tambm, que um nico grafo contenha vrios caminhos hamiltonianos. Teorema de Dirac: Uma condio suficiente, mas no necessria, para que um grafo simples G possua um ciclo hamiltoniano que o grau de cada vrtice de G seja pelo menos igual a n/2, onde n o nmero de vrtices. 2.6.5 Problema do Caixeiro Viajante Suponha que um caixeiro viajante tenha de visitar n cidades diferentes, iniciando e encerrando sua viagem na primeira cidade. Suponha, tambm, que no importa a ordem com que as cidades so visitadas e que de cada uma delas pode-se ir diretamente a qualquer outra. Assim, o problema do caixeiro viajante consiste em descobrir a rota que torna mnima a viagem total.
38
O custo pode ser expresso em termos de dinheiro, distncia, etc. Na prtica, trata-se de achar um circuito hamiltoniano de custo mnimo para o grafo representando o problema. 2.6.5.1 Complexidade do problema O problema do caixeiro viajante nos mostra que alguns problemas computacionais ainda so difceis de serem resolvidos computacionalmente, mesmo com os computadores potentes que temos atualmente. Para entender isso, devemos notar que um mesmo grafo pode conter diversos caminhos hamiltonianos. Ou seja, conforme as arestas percorridas, teremos caminhos diferentes, com custos diferentes. Assim, no basta achar um circuito hamiltoniano, devese achar um de custo mnimo. Suponha ento que existem 4 cidades a serem percorridas, A, B, C e D, como demonstrado pelo grafo abaixo. A 2 C 3 6 5 4 B 4 D
Supondo que de cada cidade pode-se ir diretamente a qualquer outra, ento, s saindo de A existem seis rotas possveis:

ABCDA (custo 18) ABDCA (custo 16) ACBDA (custo 14) ACDBA (custo 16) ADBCA (custo 15) ADCBA (custo 18)o
Assim, no basta apenas achar uma rota qualquer, deve-se ainda encontrar a de menor custo, neste caso a de custo 14. Ou seja, o melhor procedimento, teoricamente, encontrar todas as possveis rotas e, em seguida, verificar qual delas tem o menor custo. Mas embora isso parea simples, na prtica nem sempre possvel. Considere novamente este exemplo. Alm das 6 rotas iniciando pela cidade A, temos ainda seis possibilidades comeando com B, mais seis possibilidades comeando com C e mais seis iniciando com D. Ou seja so 24 combinaes, ou (n!), onde n o nmero de cidades. Supondo que eu considere apenas uma cidade inicial, por exemplo a cidade A, temos as 6 combinaes acima, ou (n-1)!. Se eu criar um algoritmo para encontrar todas as rotas, ele vai executar perfeitamente com grafos com poucos vrtices, como esse acima. No entanto, conforme o nmero de grafos cresce, o tempo para encontrar todas as rotas pode ser impraticvel. Suponha um computador que seja capaz de fazer 1 bilho de somas por segundo e um grafo com 20 cidades. Assim, esse computador gastar 19 adies para calcular uma rota qualquer, apenas concatenando cidades aleatrias. Portanto, se em 1 segundo ele consegue fazer 1 bilho de adies e para cada rota eu preciso apenas de 19 adies, portanto em cada segundo possvel calcular aproximadamente 53 milhes de rotas por segundo (1bilho/19).
39
Embora isso possa parecer razovel primeira vista, vamos ver ento quantas rotas existem com 20 cidades. Considerando apenas uma cidade inicial, ento so (n-1)! rotas possveis, ou seja, 19!, que equivale a 121 645 100 408 832 000, ou 121 quadrilhes. Ora, se em 1 segundo eu calculo 53 milhes de rotas, para calcular esse nmero de rotas eu preciso de 2.3 x 109 segundos, o que equivale a aproximadamente 73 anos.
1 segundo -------------- 53 milhes de rotas x -------------- 121 645 100 408 832 000 rotas X = 121 645 100 408 832 000 53.000.000 = 2.3 x 109 segundos
A tabela a seguir demonstra o tempo que demora para calcular todas as rotas necessrias considerando grafos com 5, 10, 15, 20 e 25 cidades. Cidades(n) Rotas por segundo Nmero de rotas( n - 1 )! Tempo para o clculo 5 10 15 20 25 250 milhoes 110 milhoes 71 milhoes 53 milhoes 42 milhoes 24 362 880 87 bilhoes 1.2 x 1017 6.2 x 1023 insignificante 0.003 seg 20 min 73 anos 470 milhoes de anos
Esse problema demonstra, portanto, que mesmo com os computadores potentes existentes atualmente, para alguns problemas no basta conseguir fazer um algoritmo para resolver um problema. O algoritmo deve ser eficiente. 2.6.5.2 Aplicaes Algumas aplicaes prticas de algoritmos que resolvem o problema do caixeiroviajante so as seguintes: Programao de operaes de mquinas em manufatura (Finke e Kusiak, 1985) Programao do movimento de ferramentas de corte (Chauny et al., 1987) Problemas de roteamento de veculos (Bodin et al., 1983) Soluo de problemas de seqenciamento de uma forma geral (Whitley et al, 1991) Soluo de problemas de programao (Salomon et al, 1997) Distribuio de tarefas em plantas industriais (Salomon et al, 1997) Trabalhos administrativos (Laporte et al, 1996) Minimizao do tempo que um rob industrial gasta para soldar a carcaa de um automvel Diminuio do tempo ou combustvel na distribuio diria de um jornal produzido numa grande cidade.
40
2.6.5.3 Tipos de solues Em grafos pequenos, possvel achar vrios (ou todos) os circuitos hamiltonianos e, em seguida, pegar aquele com o menor custo. No entanto, com grafos muito grandes no possvel encontrar todos os circuitos hamiltonianos. Assim, existem dois tipos de soluo para este problema: Soluo 1 Mtodos exatos. Encontram a melhor soluo, ou seja, de custo mnimo. Soluo 2 Mtodos aproximados (heursticas). Geram solues satisfatrias, mas sem garantias de que aquele circuito hamiltoniano o melhor possvel. Embora existam mtodos exatos, eles no so muito eficientes, devido dificuldade mostrada anteriormente. Assim, normalmente so utilizados os mtodos aproximados. Alguns exemplos de solues so as seguintes: Heurstica greedy (algoritmo guloso) Vizinho mais prximo Insero mais prximo Insero mais distante Insero mais econmica K-opt ou K-melhoramento Simulated Annealing Algoritmos Genticos Busca Tabu Heurstica Clarke-Wright 1. ALGORITMO VIZINHO MAIS PRXIMO O algoritmo consiste basicamente dos seguintes passos: Escolher um vrtice i qualquer e iniciar a rota. Repetir os seguintes passos at incluir todos os vrtices o Procure, considerando apenas os vrtices j ainda no includos na rota, aquele que seja o mais prximo do ltimo vrtice considerado. o Acrescente o vrtice ao roteiro Acrescentar o primeiro vrtice selecionado ao final da rota Pode-se observar que, embora esse algoritmo funcione para grafos onde todos os vrtices tm ligao com todos os vrtices, pode no funcionar caso contrrio. Considere por exemplo o seguinte grafo. b 4 a 2 e 4 2 4 3 f 5 4 d 3 5 c
Aplicando o algoritmo, temos: 1. Escolher, por exemplo, o vrtice a. 2. O vrtice mais prximo o e. Portanto a rota fica a e.
41
3. A partir do vrtice e, o mais prximo o f. A rota, portanto, fica a e f. 4. A partir do vrtice f, o mais prximo o b. A rota, portanto, fica a e f b. 5. A partir do vrtice b, o nico vrtice possvel o c. A rota, portanto, fica a e f b c 6. A partir do vrtice c, o nico vrtice possvel o d. A rota, portanto, fica a e f b c d. 7. Como todos os vrtices foram inseridos, agora deveria-se acrescentar primeiro vrtice (a) ao final da rota. No entanto, no h uma ligao direta entre d e a e, portanto, essa rota no vlida. Assim, pudemos perceber que esse algoritmo nem sempre encontra uma soluo vlida. Alm disso, vale lembrar que, mesmo que se encontre uma soluo, nem sempre ela tima. Por exemplo, a rota c d e a b f c tem custo 21, enquanto a rota f e a b c d f tem custo 20. 2. ALGORITMO MAIS ECONMICA (Insero do mais prximo) Este algoritmo bastante similar ao anterior. Ou seja, inicia-se considerando um vrtice inicial e buscando o vrtice mais prximo. A diferena que, a cada vez que eu procuro um novo vrtice para inserir, vou escolher aquele que esteja mais perto de qualquer um dos vrtices que j faam parte do roteiro. Ou seja, o algoritmo consiste dos seguintes passos: 1. Escolher um vrtice i qualquer. 2. Selecionar um vrtice k mais prximo de i e criar um roteiro passando por k, ou seja, i k i (Se o grafo orientado, o vrtice selecionado deve ser tal que a ida e a volta so as menores possveis, ou seja o menor valor para dik + dki). 3. Repetir at que todos os vrtices do grafo sejam inseridos: A)Considerando o roteiro j formado, selecione um novo vrtice k mais prximo de qualquer um dos vrtices do roteiro B)Considerando s as arestas que fazem parte do roteiro j formado, encontrar a aresta (x,y) do roteiro que apresenta o menor valor para (Dxk + Dky Dxy). C)Inserir o vrtice k entre x e y. No passo b) do item 3, se no for encontrada nenhuma aresta, o procedimento vai depender da implementao do algoritmo. O algoritmo pode a) ser finalizado ou b) procurar outro vrtice k para inserir no roteiro. Exemplo: Considere o mesmo grafo do exemplo anterior, reproduzido a seguir. Vamos aplicar o algoritmo insero do mais prximo. b 4 a 2 4 2 3 f 5 4 3 5 c
4 e d Passo 1: Escolher inicialmente o vrtice a. Passo 2. Selecionamos o vrtice mais prximo, que o vrtice e. Formamos ento o roteiro a e a. Passo 3:
42
Considerando esse roteiro, o vrtice mais prximo o vrtice f. Visualmente, fcil perceber que tanto faz montar o roteiro da forma afea ou aefa. Mas seguindo o algoritmo, temos ento: Aresta ae X=c, y=e, k=f Daf+ Dfe-Dae = 4 +2 -2 = 4 Aresta ea X=e, y=a, k=f Def + Dfa - Dea = 2 + 4 -2 = 4 Como os dois roteiros tm o mesmo custo, vamos selecionar o primeiro. Temos ento o roteiro a f e a. Considerando esse roteiro, o vrtice mais prximo o vrtice b. Temos ento: Aresta af X=a, y=f, k=b Dab+ Dbf-Daf = 4 +3 -4 = 3 Aresta fe X=f, y=e, k=b Dfb + Dbe - Dfe = 3 + - 2 = Aresta ea X=e, y=a, k=b Db + Dba Dea = + 4 -2 = Portanto, o menor roteiro obtido inserindo-se o vrtice b entre os vrtices a e f. Portanto, o roteiro formado a b f e a. Considerando esse roteiro, o vrtice mais prximo o vrtice d. Temos ento: Aresta ab X=a, y=b, k=d Dad+ Ddb-Dab = + -4 = Aresta bf X=b, y=f, k=d Dbd + Ddf - Dbf = + 4 - 3 = Aresta fe X=f, y=e, k=d Dfd + Dde Dfe = 4 + 4 -2 = 6 Aresta ea X=e, y=a, k=d Ded + Dda Dea = 4 + -2 = Portanto, o menor roteiro obtido inserindo-se o vrtice d entre os vrtices f e e. Portanto, o roteiro formado a b f d e a. Considerando esse roteiro, o vrtice mais prximo o vrtice c. Temos ento: Aresta ab X=a, y=b, k=c Dac+ Dcb-Dab = +5 -4 = Aresta bf X=b, y=f, k=c Dbc + Dcf - Dbf = 5 + 5 - 3 = 7 Aresta fd X=f, y=d, k=c Dfc + Dcd Dfd = 5 + 3 -4 = 4 Aresta de X=d, y=e, k=c Ddc + Dce Dde = 3 + -4 = Aresta ea X=e, y=a, k=c Dec + Dca Dea = + -2 =
43
Portanto, o menor roteiro obtido inserindo-se o vrtice c entre os vrtices f e d. Portanto, o roteiro formado a b f c d e a, com um custo total de 21. Deve-se notar que, embora este algoritmo encontre um roteiro com custo baixo, que certamente no ser o maior custo possvel, pode acontecer de existir um roteiro com custo ainda menor. Por exemplo, neste caso um possvel caminho heuleriano seria abcdfea, com custo 20 e outro seria abcfdea, com custo 24.
Exerccio 1. O que um grafo hamiltoniano? 2. Qual a diferena entre o problema do carteiro chins e o problema do caixeiro viajante? 3. Considere os grafos A e B abaixo. Para cada um eles, descubra um caminho hamiltoniano utilizando o algoritmo vizinho mais prximo. b 5 a 4 d Grafo A 5 e 3 3 2 4 c b 2 a Grafo B 4 6 4 2 c 4 3 d 5 e
4. Considere os mesmos grafos A e B da questo anterior. Para cada um eles, descubra um caminho hamiltoniano utilizando o algoritmo insero do mais prximo. 3. ALGORITMO INSERO DO MAIS DISTANTE Este algoritmo consiste dos seguintes passos: 1. Escolher um vrtice i qualquer. 2. Selecionar um vrtice k mais afastado de i e criar um roteiro passando por k, ou seja, i k i 3. Repetir at que todos os vrtices do grafo sejam inseridos. Considerando os vrtices que j fazem parte do roteiro, verificar qual vrtice no-inserido est mais prximo de cada vrtice do roteiro. Forma-se ento um conjunto Temp com vrtices e suas distncias. Selecionar do conjunto Temp o vrtice k com a maior distncia. Considerando s as arestas que fazem parte do roteiro j formado, encontrar a aresta (x,y) do roteiro que apresenta o menor valor para (Dxk + Dky Dxy). Inserir o vrtice k entre x e y. Para exemplificar esse algoritmo, vamos considerar novamente o mesmo grafo anterior, reproduzido abaixo:
44
b 4 a 2 4 2 3 f 5 4 3 5 c
4 e d Passo 1: escolho o vrtice a Passo 2: O vrtice adjacente a a mais afastado so o b e o f, com distncia 4. Vou escolher o vrtice b, por ser o primeiro. Formo ento o roteiro a b a. Passo 3: Passo 3.1 Vrtice a o mais prximo o vrtice e, com custo 2. Vrtice b o mais prximo o vrtice f, com custo 3. Temp {(e,2), (f,3)} Passo 3.2. O vrtice de Temp com a maior distncia o f, com distncia 3. Passo 3.3. Aresta ab Daf + dfb dab = 4+3-4 = 3 Aresta ba Dbf + dfa dba = 3 + 4 -4 = 3 Como deu empate, escolho a primeira aresta, ab. Passo 3.4. Inserir o vrtice f no roteiro, entre a aresta ab. Roteiro: afba. Passo 3.1 Vrtice a o mais prximo o vrtice e, com custo 2. Vrtice f o mais prximo o vrtice e, com custo 2 Vrtice b o mais prximo o vrtice c, com custo 5. Temp {(e,2), (e,2),(c,5)} Passo 3.2. O vrtice de Temp com a maior distncia o c, com distncia 5. Passo 3.3. Aresta af Dac + dcf daf = + 5 4 = Aresta fb
45
Dfc + dcb dfb = 5 + 5 - 3 = 7 Aresta ba Dbc + dca dba = 5 + - 4 = A aresta que acrescenta menor custo a fb. Passo 3.4. Inserir o vrtice c no roteiro, entre a aresta fb. Roteiro: afcba. Passo 3.1 Vrtice a o mais prximo o vrtice e, com custo 2. Vrtice f o mais prximo o vrtice e, com custo 2 Vrtice c o mais prximo o vrtice d, com custo 3 Vrtice b todos os vrtices adjacentes j foram inseridos. Temp {(e,2), (e,2),(d,3)} Passo 3.2. O vrtice de Temp com a maior distncia o d, com distncia 3. Passo 3.3. Aresta af Dad + ddf daf = + 4 4 = Aresta fc Dfd + ddc dfc = 4 + 3 - 5 = 4 Aresta cb Dcd + ddb dcb = 3 + - 5 = Aresta ba Dbd + dda dba = + - 4 = A aresta que acrescenta menor custo a fc. Passo 3.4. Inserir o vrtice c no roteiro, entre a aresta fb. Roteiro: afdcba. Passo 3.1 Vrtice a o mais prximo o vrtice e, com custo 2. Vrtice f o mais prximo o vrtice e, com custo 2 Vrtice d o mais prximo o vrtice e, com custo 4 Vrtice c todos os vrtices adjacentes j foram inseridos Vrtice b todos os vrtices adjacentes j foram inseridos. Temp {(e,2), (e,2),(e,4)} Passo 3.2. O vrtice de Temp com a maior distncia o e, com distncia 4. Passo 3.3. Aresta af Dae + def daf = 2 + 2 4 = 0 Aresta fd Dfe + ded dfd = 2 + 4 - 4 = 2 Aresta dc
46
Dde + dec ddc = 4 + - 3 = Aresta cb Dce + deb dcb = + - 3 = Aresta ba Dbe + dea dba = + 2 - 4 = A aresta que acrescenta menor custo a af Passo 3.4. Inserir o vrtice e no roteiro, entre a aresta af. Roteiro final : aefdcba. 4. HEURSTICA DE MELHORAMENTO 2-OPT Vimos que os mtodos anteriores nem sempre conseguem encontrar o melhor caminho possvel. Em virtude disso, este algoritmo, na verdade, no utilizado para encontrar um caminho hamiltoniano, mas sim para melhorar um caminho hamiltoniano j existente. Assim, dado um grafo e um caminho hamiltoniano nesse grafo, este algoritmo tenta melhorar esse caminho trocando duas arestas do caminho por outras duas arestas. O algoritmo basicamente o seguinte: 1. Considere uma matriz de distncias de um grafo e um vetor contendo o caminho inicial. 2. Selecione duas arestas do caminho: (a,b) e (c,d). 2. Verifique se existem 2 arestas alternativas (x,y) (z,w) utilizando apenas os vrtices a, b, c e d tal que o custo d(x,y)+d(z,w) seja menor do que o custo inicial d(a,b)+d(c,d) Por exemplo, considere o grafo abaixo: a 5 e 4 2 3 5 1 4 4 3 b
d 5 c Vamos supor que, aplicando um mtodo qualquer, o caminho encontrado tenha sido a b c d e a, com custo 21. O caminho, portanto, composto das arestas (a,b), (b,c), (c,d), (d,e) e (e,a). Assim, escolhemos aleatoriamente as arestas (a,b) e (c,d) para serem trocadas. Vamos verificar ento se as arestas (a,c) e (b,d) so melhores escolhas. D(a,b) + d(c,d) = 4 + 5 = 9 D(a,c) + d(b,d) = 1 + 4 = 5 Verificamos, assim, que as novas arestas reduzem o custo do caminho. Vamos ento, trocar as arestas, de forma que o novo caminho seja: a c b d e a, com custo 17. Conforme a implementao, o algoritmo pode ser aplicado vrias vezes, para verificar se no existe uma soluo ainda melhor. Neste caso, por exemplo, outra alternativa, considerando o grafo original, seria trocar as arestas (e,a) e (b,c) pelas arestas (a,c) e (e,b). Vamos verificar como ficam os custos neste caso: D(e,a) + d(b,c) = 5 + 3 = 8 D(a,c) + d(e,b) = 1 + 2 = 3
47
Portanto, fazemos a troca e o caminho final fica: a,c, d, e, b, a, com custo 16. Os grafos abaixo mostram os possveis caminhos hamiltonianos. a a a 5 e 4 d 5 c 3 4 b e 4 d 4 c 3 5 1 b e 4 d 5 c 2 1 4 b
5. HEURSTICA DE MELHORAMENTO 3-OPT2 A heurstica 3-opt praticamente idntica 2-opt, com a diferena de que, em vez de movermos apenas 2 arestas, movemos 3. Por exemplo, considerando o mesmo grafo anterior, poderamos remover as arestas (a,b), (c,d) e (d,e) e inserir as arestas (a,d), (d,b) e (c,e). Neste caso o custo total seria 20, o que mais vantajoso que os 21 iniciais. O caminho percorrido no grafo exemplificado a seguir: a 5 e 3 d 5 4 3 c b
Tanto para a heurstica 2-opt quanto para a 3-opt, repare que, embora algumas arestas tenham seu sentido modificado, a heurstica no considera essas mudanas no algoritmo por estarmos considerando apenas grafos no dirigidos e, portanto, o custo no alterado. No entanto, lembre-se que ao implementar o algoritmo necessrio fazer modificaes no vetor que armazena o caminho.
2.7
Busca em Grafo
At agora, vimos que os grafos podem ser utilizados ajudar a solucionar diversos problemas, tais como encontrar o menor caminho entre dois pontos ou encontrar a melhor rota para passar por diversos pontos. Outra possibilidade, ento, utilizar a representao na forma de grafos para a busca. Pode-se buscar um vrtice especfico ou um vrtice que atenda a alguma caractersticas. Por exemplo, suponha que voc tenha um grafo representando as cidades brasileiras e, em cada vrtice do grafo, o nmero de habitantes. Voc poderia fazer uma busca para tentar encontrar todas as cidades com menos de 5.000 habitantes. Ou ento fazer uma busca para verificar se existe pelo menos alguma cidade com menos de 1.000 habitantes. Mas qual , ento, o mtodo mais eficiente para se fazer uma busca? Vejamos ento alguns possveis mtodos:
2
Verifique novamente um exemplo de implementao http://www.dcc.ufmg.br/~krusty/pcva/heuristico.htm.
da
heurstica
3-opt
na
pgina
48
2.7.1 Algoritmo Bsico ou Busca Geral Seja G um grafo conexo. 1. Escolhe-se um vrtice qualquer como vrtice inicial. Marca-se esse vrtice como j visitado. 2. Repetir os seguintes passos at que a condio seja satisfeita ou todas as arestas tiverem sido exploradas: 2.1. Selecionar um vrtice j visitado v que seja incidente a alguma aresta (v,w) no visitada. 2.2. Marca-se a aresta (v,w) como visitada. 2.3. Se o vrtice w ainda no tiver sido marcado, marca-se como visitado. A condio de parada depende do objetivo do programa e, portanto, pode ser qualquer uma, tal como: A distncia percorrida maior do que 10.000 Foi encontrado um vrtice com valor 57. Foi encontrado um vrtice com o nome x. Todos os vrtices j foram percorridos. Por exemplo, vamos supor que queremos fazer uma busca no grafo abaixo at que todos os vrtices tenham sido visitados, de modo a fazer uma contagem da soma dos valores das arestas. e 5 f 5 a 4 b 5 4 7 5 d 6 c 6
1. Iniciar com o vrtice a. Vrtices visitados = {a}. Arestas visitadas = {} Soma = 0 2. Escolho o vrtice visitado a e (aleatoriamente) a aresta no visitada (a,b). Vrtices visitados = {a,b} Arestas visitadas = {(a,b)} Soma = 4 3. Escolho (aleatoriamente) o vrtice visitado b e a aresta no visitada (b,d). Vrtices visitados = {a,b,d} Arestas visitadas = {(a,b),(b,d)} Soma = 9 4. Escolho o vrtice visitado a e a aresta no visitada (a,e). Vrtices visitados = {a,b,d,e} Arestas visitadas = {(a,b),(b,d),(a,e)} Soma = 14
49
5. Escolho o vrtice visitado a e a aresta no visitada (a,d). Vrtices visitados = {a,b,d,e} Note que o vrtice j tinha sido visitado Arestas visitadas = {(a,b),(b,d),(a,e),(a,d)} Soma = 21 6. Escolho o vrtice visitado e e a aresta no visitada (e,f) Vrtices visitados = {a,b,d,e,f} Arestas visitadas = {(a,b),(b,d),(a,e),(a,d),(e,f)} Soma = 26 7. Escolho o vrtice visitado b e a aresta no visitada (b,c). Vrtices visitados = {a,b,d,e,f,c} Arestas visitadas = {(a,b),(b,d),(a,e),(a,d),(e,f),(b,c)} Soma = 32 8. Como todos os vrtices j foram visitados, a condio de parada alcanada e o algoritmo sai do lao. 2.7.2 Busca em Profundidade A nica diferena para o algoritmo bsico o critrio para escolher o prximo vrtice a ser visitado. Neste algoritmo, considera-se a cada iterao apenas os vrtices j visitados que so incidentes a alguma aresta ainda no percorrida. Escolhe-se ento aquele mais recentemente visitado. Vamos implementar esse algoritmo de forma recursiva: 1. Definir uma pilha P; 2. Escolher um vrtice qualquer r para servir de vrtice inicial (raiz); 3. Prof(r). Fim. Procedimento P(v) 4. Marcar r como j visitado; 5. Colocar r na pilha P; 6. Para w +(v) (para todos os vrtices w que pertencem aos sucessores de v) Se w no foi visitado ento: 7. Visitar(v,w); 8. P(w); Seno se w pertence pilha e v e w no so consecutivos na pilha ento: 9. Visitar(v,w); Fim-para 10. Retirar v da pilha P; Fim-procedimento Vejamos ento como ficaria a busca utilizando como exemplo o mesmo grafo anterior, reproduzido a seguir: e 4 d 5 f 5 a 4 b 5 7 5 6 c 6
50
1. Pilha P = {} 2. Vrtice r = a 3. P(a). 4. Visitados = {a} 5. Pilha P = {a} 6. +(a) = {b,d,e,f} 7. Visitar (a,b). 8. P(b). 4.Visitados = {a,b} 5. Pilha P = {a,b} 6. +(b) = {a,c,d} Vrtice a - a j marcado e a e b so consecutivos na pilha. Vrtice c: 7. Visitar (b,c) 8. P(c) 4. Visitados = {a,b,c} 5. Pilha P = {a,b,c} 6. +(c) = {b,d} Vrtice b b j foi visitado e b e c so consecutivos na pilha Vrtice d: 7. Visitar (c,d) 8. P(d) 4. Visitados = {a,b,c,d} 5. Pilha P = {a,b,c,d} 6. +(d) = {a,b,c,e} Vrtice a j foi visitado mas a e d no so consecutivos 9. Visitar (d,a). Vrtice b j foi visitado mas b e d no so consecutivos 9. Visitar (d,b) Vrtice c j foi visitado e so consecutivos Vrtice e: 7. Visitar (d,e). 8. P(e) 4. Visitados = {a,b,c,d,e} 5. Pilha P = {a,b,c,d,e} 6. +(e) = {a,d,f} Vrtice a j visitado mas a e e no consecutivos 9. Visitar (e,a) Vrtice d j visitado e so consecutivos Vrtice f no visitado: 7. Visitar (e,f). 8. P(f). 4. Visitados = {a,b,c,d,e,f} 5. Pilha = {a,b,c,d,e,f} 6. +(f) = {a,e} Vrtice a visitado mas no consecutivos 9. Visitar (f,a) Vrtice e visitado mas consecutivos
51
Como j visitei todos os sucessores de f, chego ao fim do lao para. Saindo do lao ento: 10. Pilha = {a,b,c,d,e} Como cheguei ao fim do procedimento, volto para o ponto onde foi feita a ltima chamada recursiva. Ou seja, a chamada a P(f). Neste ponto, eu estava verificando os sucessores de e. Como todos os sucessores j foram verificados, chego novamente ao fim do lao para. Ento: 10. Pilha = {a,b,c,d}. Chego ao fim do procedimento e, portanto, volto para o ponto anterior onde foi feita uma chamada recursiva. Ou seja, a chamada a P(e). Neste ponto, eu estava verificando os sucessores de d. Como todos os sucessores j foram verificados, chego novamente ao fim do lao para. Ento: 10. Pilha = {a,b,c}. Chego ao fim do procedimento e, portanto, volto para o ponto anterior onde foi feita uma chamada recursiva. Ou seja, a chamada a P(d). Neste ponto, eu estava verificando os sucessores de c. Como todos os sucessores j foram verificados, chego novamente ao fim do lao para. Ento: 10. Pilha = {a,b}. Chego ao fim do procedimento e, portanto, volto para o ponto anterior onde foi feita uma chamada recursiva. Ou seja, a chamada a P(c). Neste ponto, eu estava verificando os sucessores de b. Notem que os sucessores de b so {a,c,d}. No entanto, quando eu estava verificando c foi feita a chamada recursiva. Portanto, o vrtice d ainda no foi verificado. Vrtice d: O vrtice d j foi visitado, e d no pertence mais pilha. Agora sim todos os sucessores de b j foram verificados. Chego ento ao fim do lao para. Ento: 10. Pilha = {a}. Chego ao fim do procedimento e, portanto, volto para o ponto anterior onde foi feita uma chamada recursiva. Ou seja, a chamada a P(b). Neste ponto, eu estava verificando os sucessores de a. Notem que no primeiro sucessor de a j foi feita uma chamada recursiva. Portanto, ainda no foram verificados os vrtices d, e e f. Vrtice d: O vrtice j foi visitado e no pertence mais pilha. Vrtice e: O vrtice j foi visitado e no pertence mais pilha. Vrtice f: O vrtice j foi visitado e no pertence mais pilha. Agora todos os sucessores de a j foram verificados. Chego ento ao fim do lao para. Ento: 10. Pilha = {}. Chego ao fim do procedimento e, portanto, volto para o ponto anterior onde foi feita uma chamada recursiva. Ou seja, a chamada a P(a). Chego finalmente, ento, ao fim do programa. Resumindo essa seqncia de passos de forma grfica, temos:
52
Vrtice a b d e f Fim
Vrtice b a c d
Vrtice c b d
Vrtice d a b c e
Vrtice e a d f
Vrtice f a e
2.7.3 Busca em Largura Vimos que, na busca em profundidade, cada vez que eu encontrava um vrtice no visitado, eu pulava para ele e passava a verificar seus sucessores. Se encontrasse outro no vrtice, pulava para esse outro e assim por diante. Na busca em largura, para cada vrtice selecionado eu visito todos os seus descendentes. S ento vou verificar os outros vrtices. O algoritmo formal o seguinte: 1. Escolher um vrtice r qualquer como raiz. 2. Definir uma pilha P vazia. 3. Marcar r como j visitado. 4. Inserir r em P. 5. Enquanto P {} (enquanto a pilha no estiver vazia) 6. v = primeiro elemento na pilha; 7. Para w +(v) faa (para todos os sucessores de v, faa) Se w ainda no foi visitado, ento: 8. visitar (v,w). 9. marcar w como j visitado; 10. Inserir w em P. Seno, se w P, ento: 11. Visitar (v,w). Fim-para. 12. Retirar v de P; Fim-enquanto. Fim-algoritmo.
53
Tomemos novamente como exemplo o grafo a seguir: e 5 f 5 5 4 7 5 d 6 c 6
4 a b 1. Escolher o vrtice a como raiz. 2. P = {}. 3. Visitados = {a} 4. P = {a} 5. Enquanto P {}: 6. v = a. (v recebe o primeiro vrtice da pilha 7. Primeiro sucessor: b. 8. visitar (a,b). 9. Visitados = {a,b}. 10. P = {a,b}. 7. Segundo sucessor: d. 8. visitar (a,d). 9. Visitados = {a,b,d}. 10. P = {a,b,d}. 7. Terceiro sucessor: e. 8. visitar (a,e). 9. Visitados = {a,b,d,e}. 10. P = {a,b,d,e}. 7. ltimo sucessor: f: 8. visitar(a,f). 9. Visitados = {a,b,d,e,f}. 10. P = {a,b,d,e,f} 12. P = {b,d,e,f}. 6. v = b (v recebe o primeiro vrtice da pilha) 7. Primeiro sucessor: a. a j foi visitado e no pertence pilha. 7. Segundo sucessor: c. 8. visitar (b,c). 9. Visitados = {a,b,d,e,f,c}. 10. P = {b,d,e,f,c}. 7. Terceiro sucessor: d. a j foi visitado mas pertence pilha. Ento: 11. visitar (b,d). 12. P = {d,e,f,c}. 6. v = d. 7. Primeiro sucessor: a. a j foi visitado e no pertence pilha. 7. Segundo sucessor: b. b j foi visitado e no pertence pilha. 7. Terceiro sucessor: c. c j foi visitado e pertence pilha. Ento:
54
11. visitar (d,c). 7. ltimo sucessor: e. e j foi visitado mas pertence pilha. Ento: 11. visitar (d,e). 12. P = {e,f,c}. 6. v = e. 7. Primeiro sucessor: a. a j foi visitado e no pertence pilha. 7. Segundo sucessor: d. d j foi visitado e no pertence pilha. 7. Terceiro sucessor: f. f j foi visitado e pertence pilha. Ento: 11. visitar (e,f). 12. P = {f,c}. 6. v = f. 7. Primeiro sucessor: a. a j foi visitado e no pertence pilha. 7. Segundo sucessor: e. e j foi visitado e no pertence pilha. 12. P = {c}. 6. v = c. 7. Primeiro sucessor: b. b j foi visitado e no pertence pilha. 7. Segundo sucessor: d. d j foi visitado e no pertence pilha. 12. P = {}. Fim do enquanto. Fim.
Vrtice a b d e f
Vrtice b a c d
Vrtice c b d Fim
Vrtice d a b c e
Vrtice e a d f
Vrtice f a e
Exerccio:
1 Considerando o grafo a seguir: a) Faa uma busca geral b) Faa uma busca em profundidade c) Faa uma busca em largura O critrio de parada ter percorrido todos os vrtices. Inicie pelo vrtice f. d) Verifique quantas arestas foram percorridas em cada uma das buscas. Com base no resultado, decida se, para esse grafo, alguma das buscas foi mais eficiente do que as outras. a
55
d c 2 Considerando o grafo a seguir, faa uma busca em profundidade, mas mostrando em cada passo o valor das variveis do algoritmo, como exemplificado na apostila.
56
2.8
Fluxo em Rede
57
3 Eficincia e Corretude de Algoritmos

Vimos no comeo da disciplina que o objetivo da Anlise de Algoritmos inicialmente possibilitar que o aluno aprenda algoritmos bsicos e diferentes tcnicas utilizadas para resolver problemas computacionalmente. Em seguida, o objetivo que ele consiga utilizar esse conhecimento para fazer algoritmos que sejam os mais eficientes possveis. No entanto, para desenvolver algoritmos realmente eficientes, no basta conhecer tcnicas e alternativas para problemas comuns. O programador deve ter a capacidade de prever, ao desenvolver um algoritmo, qual ser o seu comportamento, quer com poucos ou com muitos dados de entrada. A tentativa de prever o comportamento do algoritmo consiste em avaliar sua complexidade. Para isso, so feitos clculos, que podem ser simples ou complexos. Como esses clculos envolvem definies e notaes especficas, como analis-las, para s ento vermos como proceder para analisar a complexidade de um software. Temos ento trs objetivos para a anlise de algoritmos: 1. Avaliar um algoritmo para verificar se ele eficiente 2. Verificar se um algoritmo correto ou incorreto 3. Comparar vrios algoritmos (que resolvem o mesmo problema) para decidir qual o mais eficiente.
3.1
Definies
3.1.1 O que um algoritmo? Um algoritmo definido pela matemtica como um processo de clculo, ou de resoluo de um grupo de problemas semelhantes, em que se estipulam regras formais para a obteno do resultado, ou da soluo do problema. Em computao, comum definirmos um algoritmo como um conjunto de passos necessrios para resolver um problema. Outra definio a de que um algoritmo, intuitivamente, uma seqncia finita de instrues ou operaes bsicas(...), cuja execuo, em tempo finito, resolve um problema computacional(Salvetti e Barbosa, 1998). Um algoritmo, na computao, qualquer procedimento computacional que recebe como entrada um valor (ou conjunto de valores) e produz como sada outro valor (ou um conjunto de valores). Finalmente, ento, podemos dizer que um algoritmo uma seqncia de passos computacionais que transforma entrada em sada. Esse, portanto, o objeto que ser estudado a partir de agora. Trechos de cdigo s podem ser considerados algoritmos quando eu consigo definir claramente: 1) o problema, 2) os dados de entrada e 3)os dados de sada. Por exemplo, eu posso ter um trecho de cdigo no qual eu identifico os seguintes elementos: Problema: Encontrar o maior e o menor valor de um vetor com n elementos. Entrada: Vetor com n elementos Sada: O elemento com o menor valor de todos e o elemento com o maior valor de todos.
Figura 10: Exemplo de elementos de um algoritmo
58
Neste caso, se o trecho tem apenas essa funo, pode ser considerado um algoritmo e possvel analis-lo individualmente. 3.1.2 Instncias de execuo de algoritmos Uma instncia de um problema consiste de um conjunto de dados de entrada e sada utilizado durante uma nica execuo. Por exemplo, as figuras 11 e 12 mostram diferentes instncias da execuo do mesmo algoritmo, cujo problema foi especificado na Figura 10. Problema: Encontrar o maior e o menor valor de um vetor com n elementos. Entrada: {1,34,56,32,3,54,3,356,3,2,23,78,65,32,11,1,43,356,66} Sada: Menor valor = 1 Maior valor = 356
Figura 11. Exemplo de instncia da execuo de um algoritmo
Problema: Encontrar o maior e o menor valor de um vetor com n elementos. Entrada: {2,54,67,93,54,23,345,67,42,447,4,983,10,76,31,15,57,83,45,794,346,44} Sada: Menor valor = 2 Maior valor = 983
Figura 12. Exemplo de outra instncia da execuo de um algoritmo
Por esses exemplos podemos verificar que em diferentes instncias de execuo, os dados de entrada podem ser bastante variados, podendo inclusive ter uma grande variao de volume. Ou seja, na instncia apresentada na Figura 11 o vetor de entrada tinha 19 valores, enquanto na instncia apresentada na Figura 12 o vetor de entrada tinha 22. Da mesma, em uma outra instncia possvel que eu tenha 500 elementos de entrada. A questo que se levanta ento : dado um algoritmo que funciona de forma eficiente para 10 elementos, ele continuar funcionando de forma eficiente para 10.000 ou mais? O algoritmo deve trabalhar corretamente sobre todas as instncias para as quais foi projetado para solver. Portanto, um algoritmo para o qual possvel achar uma instncia de dados de entrada para a qual ele no consegue achar uma resposta correta um algoritmo incorreto. No entanto, provar o contrrio, que o algoritmo correto para qualquer instncia, no to simples. Para isso, o algoritmo deve ser avaliado utilizando alguns critrios. 3.1.3 Avaliao de Algoritmos Algoritmos podem ser avaliados utilizando-se vrios critrios. Geralmente o que interessa a taxa de crescimento ou espao necessrio para resolver instncias cada vez maiores de um problema. Podemos associar um problema a um valor chamado de tamanho do problema, que mede a quantidade de dados de entrada. O tempo que um algoritmo necessita expresso como uma funo do tamanho do problema chamado de complexidade temporal do algoritmo. O comportamento assinttico dos algoritmos (ou funes) representa o limite do comportamento de custo quando o tamanho cresce. O comportamento assinttico pode ser definido como o comportamento de um algoritmo para grandes volumes de dados de entrada. A complexidade temporal de um algoritmo pode ser dividida em 3 aspectos:
59
1. Melhor caso o melhor caso representa uma instncia que faz o algoritmo executar utilizando o menor tempo possvel. 2. Pior caso o maior tempo demorado pelo algoritmo para executar alguma instncia. 3. Caso mdio a mdia de tempo que o algoritmo demora para executar. Geralmente, o mais importante avaliar o pior caso (porque pode inviabilizar o algoritmo) e o caso mdio, porque representa como o programa vai se comportar, na prtica, na maioria dos casos. 3.1.3.1 Avaliao Emprica A forma mais simples de se avaliar um algoritmo implement-lo em um computador e execut-lo com vrias instncias do problema. Define-se ento um critrio para a eficincia, como por exemplo o tempo gasto para execuo. Esse tipo de avaliao chamada de emprica. Com base na observao, pode-se calcular o pior caso (a instncia de execuo que levou mais tempo), o melhor caso (a instncia de execuo que gastou menos tempo) e o caso mdio (a mdia do tempo gasto em todas as instncias de execuo). O problema com esse tipo de avaliao que o tempo gasto vai depender do computador utilizado, do compilador, da linguagem de programao, etc. 3.1.3.2 Avaliao Terica Na avaliao terica, que a que vai ser focalizada aqui, consiste em encontrar uma frmula matemtica que expresse o recurso (por exemplo, o tempo) necessrio para o algoritmo executar em funo do tamanho dos dados de entrada. 3.1.4 Associando uma funo a um algoritmo Para encontrar uma frmula matemtica que expresse quanto tempo ser necessrio para cada volume de dados de entrada, podemos utilizar primeiramente uma avaliao emprica. Para isso, deve-se montar uma tabela relacionando volumes de dados com seus respectivos tempos de execuo. Considere por exemplo um programa fictcio Raiz, que recebe como entrada um vetor de inteiros e devolve como sada um vetor com a raiz quadrada de cada um dos elementos do vetor. Suponha que o programa executado vrias vezes, com diferentes nmeros de elementos de entrada, tendo seu tempo cronometrado, como apresentado na Tabela 1. Tempo gasto para execuo (segundos) 1 0,001 10 0,01 50 0,05 100 0,1 500 0,5 1.000 1 5.000 5 10.000 10 50.000 50 100.000 100 Tabela 1: Relao volume de dados de entrada x tempo de execuo Nmero de elementos no vetor
60
Se colocarmos esses valores em um grfico (vide Grfico 1), veremos que esses valores so representados por uma reta. Lembrando um pouco das aulas de geometria, temos que uma reta pode ser representa por uma funo linear do tipo ax+b.
7000 6000 5000 4000 3000 2000 1000
0,001 0,01 0,05 0,1 0,5
Grafico 1 Assim, se conseguirmos encontrar uma frmula como essa que represente o comportamento temporal do algoritmo em relao ao nmero de dados de entrada, ento podemos saber o seu comportamento para qualquer volume de dados de entrada! Basta aplicar o valor na frmula.
3.2
Notao O, Omega e Theta
Aps obter a funo que representa o comportamento de um software, basta analis-la para termos uma medida da complexidade do software. Para isso se utiliza as trs notaes a seguir: O, Omega e Theta. Elas so utilizadas tambm para comparar funes de diferentes algoritmos. 3.2.1 Notao O Esta notao utilizada para analisar o pior caso. Uma funo g(n) O(f(n)) se c>0 e n0 tais que g(n) <= c f(n) para n>=n0. Explicao: uma funo g(n) da ordem de complexidade de f(n) se existe uma constante c e um valor n0 tal que para qualquer valor de n maior do que n0 g(n) menor ou igual a c.f(n). Isso significa que: f(n) um limite superior para g(n) f(n) denomina assintoticamente g(n) Propriedades: f(n) = O(f(n)) c. f(n) = O(f(n)), c=constante O(f(n)) = O(f(n)) = O(f(n))
61
O(O(f(n))) = O(f(n)) O(f(n)) = O(g(n)) = O(max(f(n),g(n)) O(f(n)) . O(g(n)) = O (f(n) . g(n))
n>=no.
3.2.2 Notao Esta notao utilizada para analisar o melhor caso. Uma funo f(n) = (g(n)) se existem constantes c e no, tal que c.g(n) <=f(n) para Isso significa que: f(n) um limite inferior para g(n)
3.2.3 Notao Esta notao utilizada para analisar o caso mdio. Uma funo f(n) = (g(n)) se existem constantes c1, c2 e no tais que c1. g(n) <= f(n) <= c2.g(n) para n>=no.
62
A notao O a mais utilizada, porque geralmente o mais importante descobrir o pior caso, para saber se existe alguma possibilidade de o algoritmo falhar, isto , no conseguir executar caso se entre com um volume de dados demasiado grande. Fazendo uma analogia para melhor compreenso das notaes, temos o seguinte, considerando que f e g so funes que representam o comportamento de dois algoritmos diferentes. F(n) = O (g(n)) f<=g F(n) = (g(n)) f>=g F(n) = (g(n)) f=g
3.3
Crescimento assinttico de funes
A complexidade assinttica de um algoritmo geralmente determina o tamanho dos problemas que podero ser resolvidos por esse algoritmo. Assim, se um algoritmo processa dados de tamanho n em um tempo cn2 para uma constante c, ento dizemos que a complexidade temporal do algoritmo O(n2) (leia-se: da ordem de n2). Por exemplo, suponha os cinco algoritmos abaixo: Algoritmo A1 A2 A3 A4 A5 Complexidade n n log n n2 n3 2n
A complexidade de tempo o nmero de unidades de tempo necessrias para processar uma entrada de tamanho n. Assim, assumindo por exemplo a unidade de tempo como sendo um millisegundo, o algoritmo A1 precisa, para processar 1000 entradas, de 1000 millisegundos, ou seja, 1 segundo. J o algoritmo A3 precisa de 1 milho de segundos. Enquanto o A1 consegue processar 1000 entradas em um segundo, o A5 s consegue processar 9 entradas em 1 segundo. 3.3.1 Principais Classes de Complexidade A tabela a seguir mostra as principais classes de complexidade de funes. Quanto mais abaixo na tabela, mais complexo o algoritmo que a funo representa. Funo 1 log n log2 n n n log n n2 n3 2n Nome Constante Logartmica Log quadrtico Linear n log n Quadrtica Cbica exponencial
63
4 Anlise da Complexidade de Algoritmos

4.1 Estimativas de Tempo de Execuo
Sabemos que os principais recursos ocupados por um software em execuo so espao em disco, espao em memria e tempo. Mas enquanto o espao uma questo que pode ser facilmente resolvida, o tempo que um programa gasta para executar pode inviabilizar o seu uso. Portanto, vamos focalizar na estimativa de tempo de execuo. J vimos que o mais importante tentar avaliar o tempo de execuo para grandes volumes de dados de entrada. Para isso, vamos tentar achar uma frmula que expresse o tempo de execuo em funo do volume de dados de entrada. Dependendo da frmula encontrada, podemos classificar e comparar a complexidade de diferentes algoritmos. Exerccios 1. Qual a ordem de complexidade das seguintes funes (utilize a notao O). a) f(n) = n2 + 2 b) g(n) = 503 c) g(n) = 2 log n + n d) g(n) = 10. 2n e) f(n) = n log n + log n 2. Qual dessas funes possui a maior ordem de complexidade? 3. Arranje as seguintes expresses de acordo com a taxa de crescimento (da menor para a maior): 4n2, n!, log3n, 3n, 20n, 2, log2n. Vejamos ento algumas regras simples para se obter essa frmula a partir de um algoritmo. 4.1.1 Regras para Anlise de Algoritmos 1 Atribuies simples, declaraes, etc Analise os exemplos de comandos a seguir: int x=1; x= (1+y); readln( ); writeln(Digite um nmero); Podemos facilmente notar que qualquer desses comandos, a no ser que esteja dentro de um lao, ser executado uma nica vez. Ou seja, so comandos que no dependem do volume de dados de entrada. Portanto, dizemos que esses comandos tm ordem de complexidade constante, ou O(1).
64
2 Laos, For-to-do, while, repeat, ... O tempo de execuo de um lao , no mximo, a soma dos tempos de execuo de todas as instrues dentro do lao (incluindo todos os testes) multiplicado pelo nmero de iteraes. Por exemplo, considere o lao a seguir: For (i=1;i<=10;i++) { vetor[i]=i; vetor[i+1]=x; }
O(1) O(1)
Para encontrar a complexidade desse trecho de cdigo, devemos inicialmente somar o tempo de execuo de todas as instrues dentro do lao. Temos portanto: O(1) + O(1) = O(1+1) = O(2). Agora multiplicamos esse valor pelo nmero de iteraes do lao. Como o lao vai de 1 at 10, o nmero de iteraes 10. Portanto, temos: O(10) x O(2) = O(10x2) = O(20). Ou seja, esse trecho de cdigo vai demorar 20 unidades de tempo para ser executado. Como o tempo constante, isto , independente do volume de dados de entrada, poderamos simplificar ainda mais e dizer que a complexidade simplesmente O(1). 3 Laos aninhados Devem ser analisados de dentro para fora. O tempo total de execuo de uma instruo dentro de um grupo de laos aninhados o tempo de execuo da instruo multiplicado pelo produto do tamanho de todos os laos. Exemplo: For(i=1;i<n;i++) { For(j=1;j<n,j++) { k= k+1; } }
O(1)
Neste caso, s temos um comando propriamente dito, que constante e, portanto, tem ordem O(1). Esse valor corresponde ao tempo total de execuo dentro do grupo de laos. Agora necessrio, portanto, multiplic-lo pelo produto do tamanho de todos os laos. O primeiro lao ser executado n vezes e, portanto, tem tamanho n. O mesmo vale para o segundo lao, que tambm ser executado n vezes. Portanto, temos: O(n) . O(n) = O(n . n) = O(n2) O(1) . O(n2) = O(1. n2) = O(n2) 4 Instrues consecutivas Simplesmente soma-se a complexidade de cada instruo, sendo que os termos de menor ordem so ignorados. Exemplo:
65
for(i=1;i<n;i++){ a[i] = 0; } for (i=1;i<n;i++) { for(j = 1;j<n; j++) { a[i] = a[j] + 1; } }
Se calcularmos, veremos que a ordem de complexidade do primeiro lao O(n), enquanto a ordem de complexidade do segundo lao O(n2). Portanto, como os dois laos so consecutivos e independentes, simplesmente soma-se a complexidade de cada instruo. Assim, a equao que descreve a complexidade desse trecho de cdigo seria n2 +n. No entanto, como sabemos que o mais importante o maior tempo, podemos simplificar essa frmula. Vimos acima, no item Propriedades, que a soma de duas complexidades o maior valor. Portanto: O(n) + O(n2) = O(max(n, n2)) = O(n2) 5 If-then-else Considere o exemplo abaixo: If condio then expresso1; Else expresso2; O tempo de execuo de um comando do tipo if-then-else nunca maior do que o tempo de execuo do teste condicional em si mais o tempo de execuo da maior entre as expresses 1 e 2. Assim, se a expresso1 O(n3) e a expresso 2 O(n), ento a complexidade O(n3) + O(n) = O(n3). 6 Chamadas de Funo A anlise segue a mesma regra de laos aninhados: analise tudo de dentro para fora. Ou seja, para calcular a complexidade de um programa com vrias funes, calcule primeiramente a complexidade de cada uma das funes e depois considere cada uma das funes como uma instruo, com a complexidade da funo. 7 - Recurso Existem dois tipos de casos. No caso de algoritmos recursivos mais simples, podese simular uma linearizao, substituindo-se a chamada recursiva por alguns laos aninhados ou por uma outra subrotina extra e eventualmente uma pilha para control-la. Neste caso, o clculo simples e pode ser feito depois da linearizao. O segundo caso com algoritmos recursivos mais complexos, quando no possvel realizar a linearizao.
66
Neste caso obtemos uma relao de recorrncia que tem que ser resolvida e uma tarefa matemtica menos trivial. Vejamos ento, inicialmente, um exemplo do primeiro caso, que mais simples. Exemplo: fatorial recursivo e fatorial linearizado: Fatorial _recursivo(n); Incio Se n<= 1 ento retorne 1; Seno Retorne (n* fatorial_recursivo(n-1)); Fim Fatorial_linear(n); Incio Fatorial 1; Para i de 2 at n Fatorial fatorial * i; Retorne fatorial; Fim Como podemos perceber, as duas funes fazem a mesma coisa: isto , calculam o fatorial de n. No entanto, o primeiro algoritmo o faz de forma recursiva, j o segundo o faz de forma linear, com complexidade O(n). Exerccio: analisar a complexidade assinttica dos seguintes algoritmos: Procedure exemplo1(var a: vetor); Begin For i:= 1 to n-1 do Begin min:= i; for j:= i+1 to m do if a[j] < a[min] then min:= j; x:= a[min]; a[min]:= a[i]; a[i] = x; end; end;
67
Procedure exemplo2(var a:vetor); Begin read(x); if (x<0) a[1]:= 0; else if (x<5) a[1]:= 1; else for i:= 1 to n do begin a[i]:= i+1; end; End; Procedure exemplo3(var a: vetor); Begin For i:= 1 to n do Begin For j=1 to 10 do Begin min:= i; for k:= i+1 to m do if a[k] < a[min] then min:= k; x:= a[min]; a[min]:= a[i]; a[i] = x; end; end; end;
68
Bibliografia
Laporte, G., Asef-Vazir, A. And Sriskandarajah, C. Some applications of the generalized traveling salesman problem. JORS 47, 1996. Salomon, M., Solomon, M., van Wassenhove, L., Dumas, Y and Dauzre-Prs, S. Solving the discrete lotsizing and scheduling problem with sequence dependent set-up costs and set-up times using the traveling salesman problem with time windows. EJOR, 100, 1997. Whitley, D., Starkwheather, T. and Shaner, D. The traveling salesman and sequence scheduling: quality solutions using genetic recombinations. Handbook of Genetics Algorithms. Edt. L. Davis van Nostrand, 1991. Bodin, L., Golden, B., Assad, A. and Ball, M. Routing and Scheduling of vechicles and crews: the state of the art. Special Issue. England: Pergamon Press, 1983. Chauny, F., Haurie, A., Wagneur, E. e Loulou, R. Punch Operations in a Flexible Manufacturing Cell a Three-Dimentional Space-Filling Curve Approach. INFOR 25(1), 1987. Finke, G and Kusiak, A. Network Approach to Modeling of Flexible Manufacturing Modules and Cells. APPII 0399-0516. Department of Applied Mathematics Technical Report. University of Nova Scotia, Nova Scotia, Canad, 1985.
Fontes da Internet:
http://www.inf.ufpr.br/~andre/Disciplinas/BSc/CI065/michel/Intro/intro.html

Apostila Completa

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Apostila Completa

Uploaded by

Copyright:

Available Formats

Faculdade de Filosofia, Cincias e Letras de Mandaguari Departamento de Informtica

APOSTILA DA DISCIPLINA ANLISE DE ALGORITMOS

Medidas de Desempenho de Algoritmos

2 Teoria dos Grafos

Figura 1 . Representao grfica do problema de Euler

Figura retirada do site http://www.inf.ufpr.br/~andre/Disciplinas/BSc/CI065/michel/Intro/intro.html

A aresta a3 incide no vrtice C e no vrtice D.

Os vrtices A e B so adjacentes. os vrtices C e D tambm so adjacentes.

a1 E Vrtice E isolado. a2 v1 v2 As arestas a1 e a2 so paralelas

Sucessores e Antecessores de um Grafo Dirigido

Representao de Grafos em um Computador

Caminho: segue a orientao Cadeia: no precisa seguir a orientao

Localizao de Centros (em grafos no valorados)

2 Desenhe o grafo a partir da lista de adjacncia: 1 21 1 3 4 2 4 2 2 3 4

Algoritmos e problemas clssicos com grafos

O primeiro passo, ento, construir as matrizes de distncia e a matriz de roteamento: v1 v2 v3 v4 v5 v1 0 1 v1 1 0 0 1 0 v2 5 0 1 1 v2 2 2 0 2 2 v3 3 0 v3 0 3 3 0 0 v4 3 0 1 v4 4 0 0 4 4 v5 5 1 0 v5 0 0 5 5 5

As matrizes passam a ser, ento: v1 v2 v3 v4 v5 v1 0 1 v1 1 0 0 1 0 v2 5 0 1 1 v2 2 2 0 2 2 v3 8 3 0 4 v3 2 3 3 2 0 v4 3 0 1 v4 4 0 0 4 4 v5 5 1 0 v5 0 0 5 5 5

Assim, no final temos:

b)No grafo de Euler

Verifique novamente um exemplo de implementao http://www.dcc.ufmg.br/~krusty/pcva/heuristico.htm.

Tomemos novamente como exemplo o grafo a seguir: e 5 f 5 5 4 7 5 d 6 c 6

3 Eficincia e Corretude de Algoritmos

Notao O, Omega e Theta

O(O(f(n))) = O(f(n)) O(f(n)) = O(g(n)) = O(max(f(n),g(n)) O(f(n)) . O(g(n)) = O (f(n) . g(n))

Crescimento assinttico de funes

4 Anlise da Complexidade de Algoritmos

for(i=1;i<n;i++){ a[i] = 0; } for (i=1;i<n;i++) { for(j = 1;j<n; j++) { a[i] = a[j] + 1; } }

You might also like