DEPARTAMENTO DE TELEMÁTICA

Transcrição

1 DEPARTAMENTO DE TELEMÁTICA FACULDADE DE ENGENHARIA ELÉTRICA E DE COMPUTAÇÃO UNIVERSIDADE ESTADUAL DE CAMPINAS OTIMIZAÇÃO LINEAR Teoria dos Grafos e Fluxos em Redes Autor: Tiago Agostinho de Almeida 1

2 I. FUNDAMENTAÇÃO TEÓRICA 1. Grafos 1.1. O que é um grafo? Quando analisamos um conjunto de elementos de dados (não necessariamente dados computacionais), podemos estar preocupados com o seu conteúdo ou com as relações existentes entre eles. A Teoria dos Grafos preocupa-se com o estudo das relações existentes entre diversos objetos de análise, podo ser utilizada em qualquer área que necessite de organização de dados: sociologia, pesquisa operacional, química, etc. O grafo propriamente dito é uma representação gráfica das relações existentes entre elementos de dados. Ele pode ser descrito num espaço euclidiano de n dimensões como so um conjunto V de vértices e um conjunto A de curvas contínuas (arestas). Um vértice é representado por um círculo e uma curva é representada pela representação gráfica plana característica, ou seja, um segmento de reta. Quando uma curva possui indicação de sentido (uma seta), ela é chamada de arco, caso contrário é chamada de linha. As principais características desta estrutura são: 1. toda curva fechada de A tem apenas um ponto de V ; 2. toda curva aberta de A tem exatamente dois pontos de V ; 3. as curvas de A não têm pontos comuns exceto os elementos do conjunto V. Quando um grafo possui arcos, o mesmo denomina-se grafo dirigido ou dígrafo. Ex.: Quando um elemento do conjunto A (curvas) tem o mesmo elemento do conjunto V (vértices) como ponto inicial e final, dizemos que este elemento é um laço. Ex.: 2

3 1.2. O que podemos fazer com um grafo? Nós podemos aplicar operações sobre um grafo para que ele melhor represente as operações que sofrem os seus componentes: os dados. São elas: Operações elementares inserção de uma curva ou vértice; retirada de curvas e/ou vértices; rotação ou redesignação dos vértices pela troca entre eles num dos sentidos; fusão ou junção de dois vértices em um; 3

4 inversão ou troca do sentido dos arcos Operações binárias São operações como as realizadas na Teoria dos Conjuntos. Seu objetivo é fazer operações sobre os elementos dos grafos (vértices e arestas). Sejam os grafos G1(V1, A1), G2(V2, A2) e G3(V3, A3), onde V1, V2 e V3 são os conjuntos de vértices e A1, A2 e A3 são os conjuntos de arestas dos grafos. Sobre eles serão realizadas as seguintes operações: A. União É a junção de dois grafos através de vértices em comum, se existentes. G'(V', A') U G"(V", A") = G(V, A), V = V' U V" e A = A' U A". Ex.: B. Intersecção Tem como resultado os elementos em comum entre dois grafos. G'(V', A') G"(V", A") = G(V, A), V = V' V" e A = A' A". Ex.: G1 G2: G1 G3: Ø C. Diferença É a retirada de elementos comuns do primeiro grafo em relação ao segundo. G'(V', A') - G"(V", A") = G(V, A), V = V' - V" e A = A' - A". Ex.: 4

5 1.3. Como melhor podemos caracterizar os grafos? Para podermos discernir melhor as características dos grafos, temos um conjunto de conceitos que expressam a peculiaridade de cada grafo Cardinalidade A cardinalidade de um conjunto de vértices é igual à quantidade de seus elementos. É também chamada de ORDEM. Ex.: C(V) = 4 A cardinalidade de um conjunto de curvas é igual ao número e elementos que o compõe. Ex.: Para G(V, A) do exemplo anterior: C(A) = Vértices Adjacentes Dois vértices são adjacentes se existir uma curva entre eles. Dado dois nós x e y, a representação de uma linha é dada por xy e de um arco por xy Vértices Conexos Dois vértices são conexos se são adjacentes ou possuem uma relação de adjacência, ou seja, dados dois vértices x e y, existe um nodo x1 que é adjacente a x, outro x2 que é adjacente a x1, e assim sucessivamente. Ex.: No grafo ao lado, C é conexo a D Cadeia É um conjunto qualquer de linhas de um grafo. Ex.: Para o exemplo anterior, são cadeias DAB, CB Ciclo É uma cadeia fechada, onde a extremidade inicial e final coincidem. 5

6 Ex.: Os ciclos ABCDA e CBADC foram retirados do grafo Caminho É um conjunto qualquer de arcos de um grafo. Ex.: Para o grafo são caminhos DA e BCDA Número Cromático É o menor valor de cores necessárias para colorir os vértices de um grafo, sem que vértices adjacentes tenham a mesma cor. Ex.: número de cores (n) = 2 e n = Que tipos de grafos existem? Grafo parcial: Se G2 é um grafo parcial de G1, então G2 possui um mesmo conjunto de vértices, mas não o mesmo de arestas, do grafo G1. Ex.: Subgrafo: Se o grafo G2 é um subgrafo de G1, então G2 possui um número de vértices inferior aos de G1, embora manto o número de curvas entre os vértices existentes. Ex.: 6

7 Subgrafo parcial Se o grafo G2 é um subgrafo parcial de G1, então G2 é um subgrafo que não mantém todas as curvas entre os vértices existentes. Ex.: Grafo valorado É o grafo que possui valores nos vértices e nas curvas. Ex.: Multigrafo É o grafo que possui ao menos um par de vértices ligados por duas ou mais curvas. Ex.: Grafo denso É o grafo que possui alta cardinalidade de vértice ou curva Grafo pouco povoado É o grafo que possui baixa cardinalidade de vértice ou curva Grafo conexo É aquele onde qualquer par de vértice for conexo. 7

8 Ex.: Contra-exemplo: Grafo-árvore É aquele que possui uma das seguintes características: 1. é conexo e sem ciclos; 2. é conexo e tem n vértices e n-1 linhas; 3. sem ciclos e tem n vértices e n-1 linhas; 4. sem ciclos e, inserindo uma nova linha, é possível formar um ciclo. Ex.: Grafo planar É aquele que permite a representação no plano sem que as linhas se cruzem. Ex.: Grafo de Kuratowski É um tipo de grafo aceito como não-planar. Exs.: Rede de PERT É um grafo dirigido valorado que possui uma entrada, uma saída e não tem laços nem ciclos. A entrada é o vértice que serve como extremidade final para arcos e saída é o vértice que serve apenas como extremidade inicial para arcos. 8

9 Este tipo de grafo é utilizado na análise de eventos temporais, que necessitam do acompanhamento do fluxo de dados em relação ao tempo. Ex.: Uma fábrica possui cinco módulos de processamento robotizado. Cada módulo possui uma identificação e uma função específica. A rede de PERT ao lado representa o tempo de uma peça so processada entre os módulos Como podemos representar os grafos? Há diversas formas de representação de grafos em estruturas de dados: podemos representar as adjacências entre os vértices, as arestas, e assim por diante. A seguir vamos analisar a forma de representação através da matriz de adjacências e lista de adjacências, onde descreve-se a relação entre os vértices Matriz de Adjacências Podemos representar um grafo através de uma matriz de dimensão C(V) x C(V), onde o conteúdo poderá ser de números binários (0;1) ou inteiros (-1;0;1). Para exemplificarmos, analisemos o grafo G : A cardinalidade de vértices do grafo G é 6, portanto, para sua representação, deveremos ter uma matriz de adjacências 6x6. Utilizando valores binários, podemos representar desta forma: ma[i,j] = Conforme observamos, a matriz de adjacências ao lado foi formada seguindo a regra: ma[i,j] = 1, se i é adjacente a j, 0 caso contrário. Como estamos trabalhando com um dígrafo, devemos estabelecer qual é a origem e qual é o destino. No exemplo apresentado, a origem está definida pela letra indicadora de linha. Por exemplo, A está conectado com B, mas não o contrário, por isso ma[a,b] é 1 e ma[b,a] é 0. Para resolvermos isso, podemos fazer uma representação alternativa: ma[i,j] = -1 se i é origem da adjacência com j, 1 se i é o destino da adjacência com j e 0 para os demais vértices não envolvidos na adjacência. Isso é sintetizado na seguinte matriz: ma[i,j] = 9

10 Como exemplo, observemos o elemento ma[a,b], ma[a,c] e ma[a,d], que possuem valor -1. Isto indica que A é origem de arcos para C, D e E. Também observemos ma[f,d] e ma[f,e], com valor 1, indicando que F recebe os arcos de D e E. Apesar da metodologia empregada, observa-se que a dada aplicação que necessite de alteração de grafo, seria inadequada a representação através de estruturas fixas, exigindo, então, estrutura dinâmica Lista de Adjacências Para que seja possível a remodelagem de um grafo em tempo de execução, torna-se necessária a alocação dinâmica de sua representação. Por isso, a representação de adjacências entre vértices pode ser feita através de listas lineares. Sua constituição é realizada por um vetor dinâmico ou lista encadeada formando um índice de vértices. De cada elemento de índice parte uma lista encadeada descrevo os vértices adjacentes conectados. Como exemplo, para o grafo G apresentado na seção anterior, visualizaremos a seguinte representação: A lista encadeada é formada por nodos que contém o dado do vértice (letra) e o ponteiro para o vértice adjacente ao indicado no índice (vetor descritor dos vértices). Eventualmente os nodos poderão exigir outros campos, tais como marcação de visita ao vértice, dados adicionais para processamento da seqüência do grafo, etc. Esta é a forma de representação mais flexível para a representação de grafos. Obviamente que aplicações específicas permitirão o uso de outras formas de representação. Cabe aqui salientar que é possível a descrição de grafos através de suas arestas, o que pode exigir uma matriz para sua descrição Matriz de Incidência Este tipo de matriz representa um grafo a partir de suas arestas. Como exige muitas vezes a alocação de uma matriz maior do que no método da matriz de adjacências, não é tão utilizada quanto aquela. A matriz alocada deverá ter dimensões C(V) x C(A). O princípio desta representação está na regra: mi[i,j] = 1 se o vértice i incide com a aresta j, 0 caso contrário. Exemplificando a partir do grafo G anteriormente apresentado, teremos uma matriz: 2. Algoritmos 2.1. Dijkstra: i[i,j] = O método de Dijkstra é um método muito eficiente. Basta colocar os dados (no caso do problema apresentado, os dados são as distâncias entre as cidades) e o método retorna o caminho que deverá ser percorrido de modo que a distância seja mínima. Um problema desse método, é que 10

11 ele torna-se muito complicado de ser resolvido manualmente, o que torna indispensável o uso do computador O algoritmo de Dijkstra identifica, a partir de um vértice do grafo, qual é o custo mínimo entre esse vértice e todos os demais vértices do grafo. No início, o conjunto S contém somente esse vértice, chamado origem. Seleciona-se, a cada passo, dentre os vértices não pertencentes S (vértices temporários), aquele que apresentar menor custo de deslocamento até a origem. A seguir, este nó é identificado como permanente (incluído no conjunto S) e todas as distâncias são atualizadas Ford Moore Bellman: O algoritmo de Ford-Moore-Bellman tem a mesma finalidade que o algoritmo de Dijkstra, porém, diferentemente do primeiro, este algoritmo trabalha com vetor distância. Sua principal característica é a avaliação e reavaliação dos custos de cada um dos nós ao nó raiz; o algoritmo chega ao fim, quando a variação entre a avaliação atual e a anterior é nula para todos os nós. Assim, o algoritmo pode convergir em menos n iterações, ao passo que para o algoritmo de Dijkstra o número de iterações é sempre n Prim: O objetivo deste algoritmo é gerar a árvore mínima para cada instância fornecida. A cada iteração, busca-se a aresta de menor custo ainda não contida na árvore mínima e que não forme ciclo com as arestas já escolhidas como parte da árvore mínima. O nó raiz é fornecido, e a partir dele, gera-se a árvore mínima (de custo mínimo) Prim Colorido: Este procedimento é essencialmente o mesmo apresentado na seção 2.3, com a diferença de que, neste algoritmo a árvore mínima é colorida de azul, os arcos examinados são coloridos de verde e os nós que formam ciclos e que apresentam custo alto se comparados aos vizinhos são coloridos de vermelho, não so mais sondados. Segue o fluxograma deste algoritmo Kruskal: Este algoritmo é aplicado a grafos cujas ligações são todas unidirecionais e tem como base a seguinte metodologia: Escolhe-se o arco de menor custo do grafo e inicia-se a construção da árvore; A partir daí, busca-se iterativamente o próximo arco de menor custo, incluindo-os sucessivamente na árvore; O passo anterior é repetido até que todos os nós estejam incluídos na árvore, isto é, até que se forme a árvore mínima, evitando-se sempre a formação de ciclos Boruϋska: Este algoritmo trabalha de forma similar ao algoritmo de Kruskal. Mas ao contrário do primeiro, o algoritmo de Boruvska identifica o arco de menor custo fora de todos os componentes conectados pela face. Isto elimina a necessidade de classificação dos arcos, imposta pelo algoritmo de Kruskal. Este é um algoritmo extremamente rápido e capaz de ser executado em paralelo. Os passos que compõem este algoritmo são: 1) Para cada vértice escolher o seu arco com peso mínimo. Pode-se dar o caso de, ao executarmos este passo, ficarmos com dois grafos "nao conected". Seguidamente consideramos cada par de vértices (ou conjunto de vértices no caso de estarem ligados vários vértices, como um vértice só e 2) executar de novo o passo 1. Este algoritmo também pode ser recursivo. O algoritmo acaba quando só temos 1 vértice. 11

12 II. APRESENTAÇÃO DOS RESULTADOS 1.1. Exercício 1: No exercício 1, foram implementados os programas para executarem os algoritmos de árvore mínima[1]. Estes algoritmos são os de Dijkstra e Ford-Moore-Bellman, os quais são apresentados no apêndice, no final deste relatório. O objetivo é encontrar o menor caminho de um ponto a outro em um grafo conexo, de acordo com o que é realizado pelo algoritmo. Para tal implementação foram utilizados dois grafos. O Grafo 1, possui 20 nós e 25 arcos e o Grafo 2 possui 20 nós e 48 arcos. Em seguida são apresentados os arquivos de dados de entrada para os grafos, conto três vetores: noorigem, nodestino e Custos, os quais são apresentados abaixo: NoOrigem Grafo (20 Nós e 25 arcos) noorigem=[ ] NoDestino nodestino=[ ] Custos Custos=[ ] NoOrigem Grafo 2 (20 nós e 48 arcos) noorigem=[ ] NoDestino nodestino=[ ] Custos 12

13 Custos=[ ] Assim, com os dados de entrada inseridos nos programas para o exercício 1, foram obtidos os resultados apresentados nas tabelas, para os algoritmo Dijkstra e Ford-Moore-Bellman DIJKSTRA E FORD MOORE BELLMAN: Arquivo de entrada: Grafo1_Dados (25 arcos) Tabela 1: Resultados das implementações com o algoritmo de Dijkstra Djkstra Tabela 2: Resultados das implementações com o algoritmo de Ford-Moore-Bellman Ford-Moore-Bellman Nó Origem de Rotulação Valor do Caminho Tempo de execução: 170 ms Nó Valor do Caminho Tempo de execução: 170 ms Número de iterações: 16 Número de iterações: 2 13

14 Arquivo de entrada: Grafo2_Dados (48 arcos) Tabela 3: Resultados das implementações com o algoritmo de Dijkstra Dijkstra Tabela 4: Resultados das implementações com o algoritmo de Ford-Moore-Bellman Ford-Moore-Bellman Nó Origem de Rotulação Valor do Caminho Tempo de execução: 40 ms Nó Valor do Caminho Tempo de execução: Número de iterações: 20 Número de iterações: 2 40 ms 14

15 1.2. Exercício 2: No exercício 2, o objetivo foi implementar os programas para executarem os algoritmos de caminho mínimo[2]. Estes algoritmos são os de Prim, Prim-Colorido, Kruskal e Boruϋka, os quais são apresentados no apêndice, no final deste relatório. Os resultados foram obtidos implementando os mesmos arquivos de entrada, como apresentado na seção 1.1, ou seja, foi utilizado o mesmo arquivo de dados do Exercício acima. Os resultados estão apresentados nas tabelas 5 e 6. Arquivo de entrada: Grafo1_Dados (25 arcos) Tabela 5: Resultados apresentados para o Grafo 1 Prim Prim-Colorido Kruskal Boruvka Nó Origem Nó Destino Nó Origem Nó Destino Nó Origem Nó Destino Nó Origem Nó Destino Tempo de execução: ms 270 ms 110 ms 170 ms Número de iterações:

16 Arquivo de entrada: Grafo2_Dados (48 arcos) Tabela 6: Resultados apresentados para o Grafo 2 Prim Prim-Colorido Kruskal Boruvka Tempo de execução: Nó Origem Nó Destino Nó Origem Nó Destino Nó Origem Nó Destino Nó Origem Nó Destino ms 220 ms 80 ms 20 ms Número de iterações:

17 1.3. Exercício 3: O exercício 3, proposto segue o seguinte enunciado: Uma empresa que produz fogões instalou duas fábricas - uma em São Paulo e outra em Campinas - dois depósitos - um em Bauru e outro em Ribeirão-Preto. A Fábrica de São Paulo produz 1500 unidades por mês e a Fábrica de Campinas produz 1000 unidades por mês. Toda produção é enviada aos depósitos, para depois ser distribuída para Franca, Araçatuba e Ourinhos, com demandas de 950, 1000 e 1220, respectivamente. Transferência entre os depósitos é limitada em 50 unidades por mês, sem custo. Os custos de transporte estão apresentados na tabela 1 conforme é apresentado na tabela 7, relacionada abaixo: Tabela 7: Custos de transportes entre os depósitos e fábricas. De/Para Bauru Ribeirão-Preto Franca Araçatuba Ourinhos São Paulo Campinas Bauru Ribeirão-Preto O problema apresentado acima segue a seguinte forma matricial: min fo = c ' x sa. Ax = b x = { xi} xi 0 i Desta forma, a formulação do problema apresentado foi realizada conforme é apresentado abaixo: Os dados de entrada no método simplex utilizado para resolução do problema, são apresentados abaixo: A=[ ] b=[ ] c=[ ] 17

18 Para resolução deste exercício foram utilizados dois métodos. Primeiro utilizou-se o algoritmo baseado no método simplex. Os resultados obtidos com o algoritmo para resolução do método estão apresentados na tabela 8, relacionada abaixo: Tabela 8: Resultados do método simplex RESULTADOS DO MÉTODO SIMPLEX X= [ ] Função Objetivo: A resolução do exercício 3, baseada em fluxo em redes é apresentado em anexo, no final deste relatório. III. COMENTÁRIOS: EXERCÍCIO 1: Os programas implementados neste exercício, mostram a extrema semelhança entre os algoritmos de Dijkstra e Ford-Moore-Bellman, tanto no tempo de execução, como nos resultados apresentados nas tabelas citadas acima. No número de iterações, contatou-se que o algoritmo de Ford_Moore-Bellman apresentou melhores resultados que o de Dijkstra, tanto para ambos arquivos de entrada com Grafos de 25 e 48 arcos.. EXERCÍCIO 2: Os programas implementados neste exercício, apresentaram que os algoritmos Prim e Boruvska possuem melhores resultados, quanto ao tempo de execução e número de iterações. Para redes maiores (20 nós e 48 arcos), o tempo de simulação do algoritmo Prim Colorido apresentou resultados bem superiores que os demais. EXERCÍCIO 3: No Exercício 3, o valor da função-objetivo é igual a Importante destacar que, se, a título de simulação retirarem-se os fluxos entre os armazéns, o valor da função-objetivo não muda, uma vez que o custo de transporte entre 3 e 4 é nulo. IV. CONCLUSÃO: Podemos dizer que os algoritmos implementados, apresentaram resultados satisfatórios comparados com a teoria apresentada. A implementação dos mesmos se deu de forma bastante simples apresentando as principais características entre algoritmos de caminho mínimo e de geração de árvore mínima. Os vários problemas apresentados no dia-dia, como fluxo em redes, encaminhamento de chamadas/serviços, tráfego telefônico, problemas de comunicação e conexões entre outros, foram um estimulo a mais para estudos mais avançados no intuito de resolução desses algoritmos. V. REFERÊNCIAS BIBLIOGRÁFICAS: [1] Goldbarg M. C., Luna H. P. L., Otimização Combinatória e Programação Linear, Ed. Campus, [2] Bazaraa, Jarvis, Sherali Linear Programming and Network flows, J. Willey and sons,

19 VI. APÊNDICE 1 - FLUXOGRAMAS: Fluxograma de Dijkstra Fluxograma de Ford-Moore-Bellman INICIO INICIO Definir matriz com as distancias que ligam os nós da rede. Definir matriz com as distancias que ligam os nós da rede. INICIALIZAR AS VARIAVELS d, d(ni) 0, A (N) F φ, Rot 0, t = 1 INICIALIZAR AS VARIAVELS L (i,k) D ( Ni. i) L (i,k) < Ant ( i ) T < N Ant ( i ) 0 R xi, tal que dni,i Min dni,i F F r A A \ r V A Γ + ( r) Para todo i V P Min d(ni, i), d(ni, r) + d(r, i) Se P < d(ni, i) d(ni, i) P Rot r L (j,k-1) L(j,k) L (j,k+1) Min L(j,k), L (i,k) + D(i,j) I Ni ; j = 1,2,3,...N K k + 1 FIM FIM Fluxograma de Prim Fluxograma de Prim Colorido INICIO INICIO Definir matriz com as distancias que ligam os nós da rede. Definir matriz com as distancias que ligam os nós da rede. INICIALIZAR AS VARIAVELS S 0 I é o vértice inicia escolhida T i V N \ i INICIALIZAR AS VARIAVELS N vértice inicial escolhido T N i 0 Colorir de x as arestas que contem vértice origem Ni Para T N 19 Procurar a aresta menor (j,k) A tal que Para I < N-1

20 Fluxograma de Kruskal Fluxograma de Boruvska INICIO INICIO Definir matriz D com as distancias que ligam os nós da rede. Definir matriz com as distancias que ligam os nós da rede. Ordenar as arestas no vector H Definir a floresta inicial Tj, j = 1,2,3,...N com N subarvores INICIALIZAR AS VARIAVELS T hi INICIALIZAR AS VARIAVELS F φ T < N L (j,k-1) L(j,k) Tomar a próxima aresta na orem H (hi+1) se T T hi+1é um grafo cíclico (arvore) então T T hi Para cada Tj ; Determinar a menor aresta (xa, ya ) Onde xa Ti e Ya Ti (suponha ya Tj ) FIM F F (xa, ya) Aglutinar as duas sub arvores Ti e Tj FIM 20

21 VII. APÊNDICE 2- CÓDIGO FONTE DOS PROGRAMAS 1.1) DJKSTRA % % DJKSTRA % % Inicio function Djkstra; clear all; clc; % Carregando o arquivo de dados load('grafo1_dados'); % Inicializando de valores tic; % Marcando o tempo NumArcos = length(noorigem); vtc = union(noorigem(:),nodestino(:)); n = length(vtc); S = zeros(n); V = zeros(n,1); V(1) = 1; A = ones(n,1); F = zeros(n,1); rot = A; % Montago a matriz de custos for k = 1:NumArcos, S(nodestino(k),noorigem(k)) = 1; S(noorigem(k),nodestino(k)) = 1; custos(noorigem(k),nodestino(k)) = Custos(k); custos(nodestino(k),noorigem(k)) = Custos(k); ; % Fazo dl = inf, e dl(1) = 0 d1(1) = 0; 21

22 for i = 2:n, d1(i) = inf; ; p = find(noorigem == 1); d1(nodestino(p)) = Custos(p); % Calculando r - no que vai ser fechado contador = 0; for t = 1:n g = inf; for k = 1:n if((a(k) == 1)&(g > d1(k))) g = d1(k); r = k; F(r) = 1; A(r) = 0; for k = 1:n if((s(r,k) == 1)&(A(k) == 1)) V(k) = 1; for i = 1:n if(v(i) == 1) if(d1(i) > (d1(r) + custos(r,i))) p = d1(r) + custos(r,i); else p = d1(i); if(p < d1(i)) d1(i) = p; rot(i) = r; for i = 1:n V(i) = 0; contador = contador + 1; tempo = toc; % Travando Cronometro % Exibindo os resultados 22

23 fprintf('\n') fprintf('\n '); fprintf('\n Algoritmo - DJKSTRA '); fprintf('\n '); fprintf('\n No Origem da Rotulacao Valor do Caminho'); fprintf('\n '); for i = 1:n fprintf('\n %d %d %d ',i,rot(i),d1(i)); fprintf('\n'); fprintf('\n '); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000); fprintf('\n '); fprintf('\n Numero de iteracoes = %d',contador); fprintf('\n '); fprintf('\n'); 1.2) FORD-MOORE-BELLMAN % % FORD-MOORE-BELLMAN % % Inicio function FordMooreBellman; clear all; clc; % Carregando o arquivo de dados load('grafo1_dados'); % Inicializando de valores tic; % Comecando a marcar o tempo NumArcos = length(noorigem); vtc = union(noorigem(:),nodestino(:)); n = length(vtc); A = zeros(n); S = zeros(n); custo = inf*ones(n); % Montando a matriz de custos for j = 1:NumArcos S(noorigem(j),nodestino(j)) = 1; custo(noorigem(j),nodestino(j)) = Custos(j); k = 1; j = 1; 23

24 lj(1) = 0; for i = 2:n lj(i) = custo(1,i); Ls(1) = custo(1,j); for i = 1:n for j = 1:n if (S(i,j) == 1) ANT(i,j) = i; contador = 0; fim = 0; k = 1; while((fim == 0)&(k <= n)) fim = 1; for j = 2:n menor = lj(j); for i = 1:n if((s(i,j) == 1)&(menor > (lj(i) + custo(i,j)))&(i ~= j)) menor = lj(i) + custo(i,j); if(menor < lj(j)) fim = 0; lj(j) = menor; k = k + 1; contador = contador + 1; tempo = toc; %Travando Cronometro % Exibindo os resultados fprintf('\n') fprintf('\n '); fprintf('\n Algoritmo - Ford-Moore-Bellman '); fprintf('\n '); fprintf('\n No Valor do Caminho '); fprintf('\n '); for i=1:n fprintf('\n %d %d ',i,lj(i)); fprintf('\n'); fprintf('\n '); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000); 24

25 fprintf('\n fprintf('\n fprintf('\n fprintf('\n'); '); Numero de iteracoes = %d',contador); '); 1.3) PRIM % % PRIM % % Inicio function prim; clear all; clc; % Carregando o arquivo de dados load('grafo1_dados'); % Inicializando de valores NumArcos = length(noorigem); vtc = union(noorigem(:),nodestino(:)); n = length(vtc); caminho = zeros(1,n); custo = inf * ones(n); S = zeros(n); % Escolho o no inicial: fprintf('\n'); fprintf('\n Com qual no deseja comecar?'); fprintf('\n'); Ni = input('--->'); tic; % Marcando o tempo T = []; T(1) = Ni; % No inicial da arvore minima V = (1:n); V = V(V ~= Ni); S = []; % Montando a matriz de custos for j = 1:NumArcos custo(noorigem(j),nodestino(j)) = Custos(j); custo(nodestino(j),noorigem(j)) = Custos(j); contador = 0; while length(t) < n % Encontrando a menor aresta 25

26 aresta = inf; for k =1 : length(t) for i = 1: length(v) i1 = T(k); i2 = V(i); atual = custo(i1,i2); if (atual < aresta) aresta = atual; novo = V(i); entra = T(k); T = [T novo]; V = V(V ~= novo); S = [S entra novo]; contador = contador + 1; tempo = toc; % Travando o cronometro % Exibindo os resultados fprintf('\n') fprintf('\n '); fprintf('\n Algoritmo - PRIM '); fprintf('\n '); j = 2; for i = 1:2:length(S) fprintf('\n %d - %d ',S(i),S(j)); j = j + 2; fprintf('\n'); fprintf('\n '); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000); fprintf('\n '); fprintf('\n Numero de iteracoes = %d',contador); fprintf('\n '); fprintf('\n'); 1.4) PRIM-COLORIDO % % PRIM-COLORIDO % % Inicio function PrimColorido; clear all; clc; 26

27 % Carregando o arquivo de dados load('grafo1_dados'); % Inicializando de valores tic; % Marcando o tempo NumArcos = length(noorigem); % Setando as cores verde = 0; azul = 1; vermelho = 2; corarc = Inf*ones(NumArcos,1); Vert = union(noorigem(:),nodestino(:)); Nver = size(vert,1); V = Vert; dist = Inf*ones(Nver,NumArcos); for i = 1:length(noorigem) if noorigem(i) == nodestino(i) Custos(i) = inf; % Montando a matriz custos for i = 1:NumArcos dist(noorigem(i),i) = Custos(i); dist(nodestino(i),i) = Custos(i); i = 0; T = 1; [xxx, ind] = min(dist(t,:)); corarc(ind) = verde; contador = 0; while (i < (Nver-1)) sel = find(corarc == verde); [xxx, ind] = min(custos(sel)); corarc(sel(ind)) = azul; T = union(t,noorigem(sel(ind))); T = union(t,nodestino(sel(ind))); sel = find(corarc == verde); corarc(sel) = Inf; for j = 1:length(T) k = T(j); for l = 1:NumArcos if ((dist(k,l) ~= Inf)&(corArc(l) ~= azul)&(corarc(l) ~= vermelho)) if (k == noorigem(l)) no2 = nodestino(l); else no2 = noorigem(l); 27

28 exis = 0; arc2 = 0; for m = 1:NumArcos if ((dist(no2,m) ~= Inf)&(corArc(m) ~= azul)&(corarc(m) ~= vermelho) & (m ~= l)) if (corarc(m) == verde), exis = 1; arc2 = m; if (exis == 0) corarc(l) = verde; else if Custos(l) < Custos(arc2) corarc(arc2) = vermelho; corarc(l) = verde; else corarc(l) = vermelho; corarc(arc2) = verde; i = i + 1; contador = contador + 1; tempo = toc; % Travando o Cronometro % Exibindo os resultados fprintf('\n') fprintf('\n '); fprintf('\n Algoritmo - PRIM-COLORIDO '); fprintf('\n '); for i = 1:NumArcos if corarc(i) == 1 fprintf('\n %d - %d %d ',noorigem(i),nodestino(i),custos(i)); fprintf('\n'); fprintf('\n '); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000); fprintf('\n '); fprintf('\n Numero de iteracoes = %d',contador); fprintf('\n '); fprintf('\n'); 28

29 1.5) KRUSKAL % % KRUSKAL % % Inicio function Kruskal; clear all; clc; % Carregando o arquivo de dados load('grafo1_dados'); % Inicializando os valores vtc = union(noorigem(:),nodestino(:)); n = length(vtc); NumArcos = length(noorigem); caminho = zeros(1,n); NoInic = 1; tic; % Comecando a marcar o tempo custo = inf * ones(n); % Montago a matriz de custos for j = 1:NumArcos, custo(noorigem(j),nodestino(j)) = Custos(j); custo(nodestino(j),noorigem(j)) = Custos(j); ; MS = triu(custo,1); [C1 C2] = find(ms ~= 0 & MS ~= Inf); H = [C1 C2]; for i = 1: length(h) Dist(i) = custo(h(i, 1), H(i, 2)); for i = 1 : length(dist)-1, for j = i + 1:length(Dist), if Dist(i) > Dist(j) aux = Dist(i); Dist(i) = Dist(j); Dist(j) = aux; aux = H(i,1); H(i,1) = H(j,1); H(j,1) = aux; aux = H(i,2); H(i,2) = H(j,2); H(j,2) = aux; T = [H(1,1) H(1,2)]; No = T; NT(1) = 2; 29

30 H( 1, : ) = []; Dist( 1 ) = []; contador = 0; while length(t) < 2*(NumArcos - 1) if isempty(h) == 1 break; [L1 C1] = find(no == H(1,1)); [L2 C2] = find(no == H(1,2)); % Funcao que verifica se existe ciclagem [No, NT, T] = Ver_Ciclagem(L1, L2, No, H, NT, T); H(1, :) = []; Dist( 1 ) = []; contador = contador + 1; tempo = toc; % Travando o cronometro % Exibindo os resultados fprintf('\n') fprintf('\n '); fprintf('\n Algoritmo - KRUSKAL '); fprintf('\n '); j = 2; for i = 1:2:length(T) fprintf('\n %d - %d ',T(i),T(j)); j = j + 2; fprintf('\n'); fprintf('\n '); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000); fprintf('\n '); fprintf('\n Numero de iteracoes = %d',contador); fprintf('\n '); fprintf('\n'); 1.6) BORUVKA % % BORUVKA % % Inicio function Boruvka; clear all; 30

31 clc; % Carregando o arquivo de dados load('grafo1_dados'); tic; %Comecando a marcar o tempo NumArcos = length(noorigem); vtc = union(noorigem(:),nodestino(:)); n = length(vtc); caminho = zeros(1,n); % Inicializando o vetor de custos custo = inf*ones(n); for j = 1:NumArcos custo(noorigem(j),nodestino(j)) = Custos(j); custo(nodestino(j),noorigem(j)) = Custos(j); ; for i = 1 : n T(i,1) = i; NT(i) = 1; contador = 0; F = []; while length(f) < 2*(n-1) V = []; net = size(t,1); for i = 1 : net min = inf; for k = 1 : NT(i), for j = 1 : net if i ~= j for m = 1 : NT(j), if custo(t(i,k),t(j,m)) < min min = custo(t(i,k),t(j,m)); no = T(i,k); nd = T(j,m); V = [V no nd]; for i = 1 : 2 : length(v), [Lin1 Col1] = find(t == V(i)); [Lin2 Col2] = find(t == V(i+1)); if Lin1 ~= Lin2 for j = 1 : NT(Lin2), NT(Lin1) = NT(Lin1) + 1; 31

32 T( Lin1, NT(Lin1) ) = T( Lin2, j); T( Lin2, : ) = []; NT( Lin2 ) = []; F = [F V(i) V(i+1)]; contador = contador + 1; tempo = toc; % Travando o cronometro % Exibindo os resultados fprintf('\n') fprintf('\n '); fprintf('\n Algoritmo - BORUVKA '); fprintf('\n '); j = 2; for i = 1:2:length(F) fprintf('\n %d - %d ',F(i),F(j)); j = j + 2; fprintf('\n'); fprintf('\n '); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000); fprintf('\n '); fprintf('\n Numero de iteracoes = %d',contador); fprintf('\n '); fprintf('\n'); 32

33 VIII. APÊNDICE 3 EXERCÍCIO 3: FLUXO EM REDES O problema apresentado no trabalho pode ser representado pela figura abaixo: São Paulo b 1 = Franca [7] [8] b 5 = [7] [8] [0, 50, 0] Bauru b 3 =0 3 Araçatuba [5] [7] 6 b 6 =-100 [0, 50, 0] 4 Ribeirão Preto b 4 =0 [6] Ourinhos [9] 7 b 7 =-1220 [4] [7] 2 b 2 =1000 Campinas Existe um desbalanceamento igual a 670 entre a oferta (São Paulo, nó 1; e Campinas, nó 2) e a demanda (Franca, nó 5; Araçatuba, nó 6; e Ourinhos, nó 7). Assim, foi necessária a introdução de um novo nó (balanceamento de carga, nó 8) ao grafo do problema. 33

34 São Paulo b 1 = [7] Franca [8] b 5 = [7] [8] [0, 50, 0] Bauru b 3 =0 3 Araçatuba [5] [7] 6 b 6 =-1000 [0, 50, 0] Ourinhos [6] [9] 7 b 7 = Ribeirão Preto b 4 =0 8 =670 b 3 Nó de Balanceamento [4] [7] 2 b 2 =1000 Campinas Para que o processo iterativo seja iniciado, a introdução de um novo nó (nó artificial, nó 9) foi necessária. A conexão do nó artificial aos demais nós do grafo, de maneira adequada, fornece uma solução inicial básica factível. Desta forma, considerando-se que os custos dos arcos artificiais sejam do tipo M-grande e que o nó 9 seja o nó raiz (w 9 =0), tem-se: As iterações seguintes têm como primeiro objetivo a eliminação de todos os arcos artificiais introduzidos no grafo original do sistema. Por fim, deve-se concluir o processo de otimização do problema de transporte. 34

35 Custos relativos: 35 c ˆ13 = 7 c ˆ = 8 14 cˆ = 7 cˆ = 8 45 c ˆ34 = 0 cˆ = 5 36 cˆ = 7 46 c ˆ43 = 0 cˆ = 6 37 cˆ = 9 47 c ˆ24 = 7 c ˆ = cˆ = cˆ = 86 cˆ = 87 Entra arco (8,5) sai arco (8,9) Custos relativos: 35 cˆ = c ˆ13 = 7 c ˆ = 8 14 cˆ = 7 cˆ = 8 45 c ˆ34 = 0 cˆ = 5 36 c ˆ = 0 43 cˆ = 6

36 Entra arco (3,6) sai arco (3,9) Custos relativos: cˆ = c ˆ14 = 8 c ˆ = 2 35 cˆ = 8 cˆ = cˆ = 7 46 cˆ = 5 43 c ˆ37 = 1 cˆ = 9 47 c ˆ24 = 7 cˆ = c ˆ = 0 86 c ˆ = 0 87

37 Entra arco (4,3) sai arco (4,9) Custos relativos: cˆ = cˆ = c ˆ35 = 2 c ˆ = 3 45 c ˆ = 0 34 c ˆ = 2 46 c ˆ = 1 37 c ˆ = 4 47 cˆ = 12 cˆ = 9 23 c ˆ86 = 0 c ˆ = 0 87 Entra arco (2,3) sai arco (9,6) 37

38 Custos relativos: 35 cˆ = cˆ = c ˆ24 = 3 cˆ = c ˆ13 = 3 c ˆ = 4 14 cˆ = 11 cˆ = c ˆ34 = 0 c ˆ = 2 46 c ˆ87 = 0 Entra arco (3,7) sai arco (2,9) 38

39 Custos relativos: cˆ = cˆ = cˆ 35 = 1 ĉ45 = 2 ĉ = 0 34 ĉ = 2 46 ĉ = 3 47 ĉ = 3 24 c ˆ = 1 86 ĉ = 0 87 Entra arco (1,3) sai arco (9,7) 39

40 Custos relativos: c ˆ14 = 1 cˆ = 14 cˆ = cˆ = cˆ = c ˆ34 = 0 c ˆ = 2 46 c ˆ = 3 47 c ˆ = 3 24 Entra arco (3,5) sai arco (9,5) 40

41 Término da Fase I Fase II : Custos relativos: c ˆ14 = 1 c ˆ = 1 45 c ˆ = 0 34 c ˆ = 2 46 c ˆ = 3 47 c ˆ = 3 24 c ˆ = 2 86 c ˆ =

42 Solução ótima Esta última iteração representa a solução ótima para o problema, pois os custos relativos reduzidos, relacionados a todos os arcos são não positivos. Portanto, a partir do grafo ótimo, foram obtidos os seguintes resultados: * x = [ x ] ' 13 x23 x35 x36 x37 x43 x85 [ ] ' x * =