“teoria dos grafos e fluxos em redes” - dt - home...

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________

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


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, podendo 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 sendo 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


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.

1.2.1. Operações elementares

São elas:

• 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


• inversão ou troca do sentido dos arcos.

1.2.2. 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


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.

1.3.1 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) = 4.

1.3.2 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. 1.3.3 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

1.3.4 Cadeia É um conjunto qualquer de linhas de um grafo. Ex.: Para o exemplo anterior, são cadeias

DAB, CB. 1.3.5 Ciclo É uma cadeia fechada, onde a extremidade inicial e final coincidem.

__________________________________________________________________________________________________________ 5


Ex.: Os ciclos ABCDA e CBADC foram retirados do grafo

1.3.6 Caminho É um conjunto qualquer de arcos de um grafo.

Ex.: Para o grafo são caminhos DA e BCDA.

1.3.7 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 = 4

1.4. Que tipos de grafos existem?

1.4.1. 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.:

1.4.2. Subgrafo:

Se o grafo G2 é um subgrafo de G1, então G2 possui um número de vértices inferior aos de G1, embora mantendo o número de curvas entre os vértices existentes. Ex.:

__________________________________________________________________________________________________________ 6


1.4.3. 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.:

1.4.4. Grafo valorado

É o grafo que possui valores nos vértices e nas curvas. Ex.:

1.4.5. Multigrafo

É o grafo que possui ao menos um par de vértices ligados por duas ou mais curvas. Ex.:

1.4.6. Grafo denso

É o grafo que possui alta cardinalidade de vértice ou curva.

1.4.7. Grafo pouco povoado É o grafo que possui baixa cardinalidade de vértice ou curva.

1.4.8. Grafo conexo É aquele onde qualquer par de vértice for conexo.

__________________________________________________________________________________________________________ 7


Ex.:

Contra-exemplo:

1.4.9 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.:

1.4.10 Grafo planar

É aquele que permite a representação no plano sem que as linhas se cruzem. Ex.:

1.4.11 Grafo de Kuratowski É um tipo de grafo aceito como não-planar. Exs.:

1.4.12 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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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 sendo processada entre os módulos.

1.5. 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. 1.5.1. 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


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. 1.5.2. 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 descrevendo 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. 1.5.3. 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:

i[i,j] =

2. Algoritmos 2.1. Dijkstra:

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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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.

2.2. 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.

2.3. 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).

2.4. 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 sendo mais sondados. Segue o fluxograma deste algoritmo.

2.5. 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.

2.6. 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


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, contendo três vetores: noorigem, nodestino e Custos, os quais são apresentados abaixo:

Grafo (20 Nós e 25 arcos) NoOrigem

noorigem=[ 1 1 2 2 2 3 3 4 5 5 6 6 7 7 8 9 10 11 11 12 12 13 13 14 15 ]

NoDestino

nodestino=[ 2 5 3 4 9 4 5 7 6 12 7 8 10 14 9 11 11 13 15 13 15 14 16 15 16 ]

Custos

Custos=[ 75 120 75 120 300 75 120 150 60 300 75 60 150 300 60 60 105 75 120 60 120 120 75 60 120 ]

Grafo 2 (20 nós e 48 arcos) NoOrigem

noorigem=[ 1 2 1 1 2 3 4 2 3 3 3 4 4 4 5 6 7 8 6 6 7 7 7 8 8 8 9 9 10 11 12 10 10 11 11 12 12 13 13 14 15 15 16 16 17 18 18 19 ]

NoDestino

nodestino=[ 2 3 4 5 3 4 5 6 6 7 8 7 8 9 9 7 8 9 10 11 10 11 12 11 12 13 12 13 11 12 13 14 15 15 16 15 16 13 17 18 18 19 18 19 19 19 20 20 ]

Custos

__________________________________________________________________________________________________________ 12


Custos=[ 1 4 2 6 2 8 9 3 10 7 4 9 6 8 1 8 9 10 12 7 5 6 8 3 5 1 2 6 8 10 14 10 9 5 8 9 5 1 12 8 8 7 5 4 2 8 10 8 ]

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.

1.1.1. DIJKSTRA E FORD – MOORE – BELLMAN:

Arquivo de entrada: Grafo1_Dados (25 arcos)

_______

Tabela 1: Resultados das implementações com o algoritmo de Dijkstra

Djkstra

Nó Origem de Rotulação

Valor do Caminho

1 1 0

2 1 75

3 2 150

4 2 195

5 1 120

6 5 180

7 6 255

8 6 240

9 8 300

10 7 405

11 9 360

12 5 420

13 11 435

14 15 540

15 11 480

16 13 510

Tempo de execução: 170 ms

Número de iterações: 16

__________________________________________________

Tabela 2: Resultados das implementações com o algoritmo de Ford-Moore-Bellman

Ford-Moore-Bellman

Nó Valor do Caminho

1 0

2 75

3 150

4 195

5 120

6 180

7 255

8 240

9 300

10 405

11 360

12 420

13 435

14 555

15 480

16 510


Número de iterações: 2

_________________________________________________ 13


Arquivo de entrada: Grafo2_Dados (48 arcos) Tabela 3: Resultados das implementações com o algoritmo de Dijkstra

Tabela 4: Resultados das implementações com o algoritmo de Ford-Moore-Bellman

Ford-Moore-Bellman

Nó Valor do Caminho

1 0

2 1

3 3

4 2

5 6

6 4

7 10

8 7

9 7

10 15

11 10

12 9

13 8

14 25

15 15

16 14

17 20

18 19

19 18

20 26


Dijkstra

Nó Origem de Rotulação

Valor do Caminho

1 1 0

2 1 1

3 2 3

4 1 2

5 1 6

6 2 4

7 3 10

8 3 7

9 5 7

10 7 15

11 8 10

12 9 9

13 8 8

14 10 25

15 11 15

16 12 14

17 13 20

18 16 19

19 16 18

20 19 26


Número de iterações: 20 Número de iterações: 2

__________________________________________________________________________________________________________ 14

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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

1 2 1 2 5 6 1 2

2 3 1 5 6 8 3 2

3 4 2 3 8 9 4 3

1 5 3 4 9 11 5 6

5 6 5 6 12 13 7 6

6 8 6 7 14 15 8 6

8 9 6 8 3 4 9 8

9 11 8 9 1 2 10 11

6 7 9 11 11 13 11 9

11 13 10 11 6 7 12 13

13 12 11 13 2 3 14 15

13 16 11 15 13 16 16 13

11 10 12 13 10 11 3 5

11 15 13 16 1 5 11 13

15 14 14 15 13 14 14 13

Tempo de execução: 20 ms 270 ms 110 ms 170 ms

Número de iterações: 15 15 24 2

__________________________________________________________________________________________________________ 15


Arquivo de entrada: Grafo2_Dados (48 arcos) Tabela 6: Resultados apresentados para o Grafo 2

Prim

Prim-Colorido

Kruskal

Boruvka

Nó Origem Nó Destino Nó Origem Nó Destino Nó Origem Nó Destino Nó Origem Nó Destino

1 2 1 2 1 2 1 2

1 4 1 4 5 9 3 2

2 3 2 3 8 13 4 1

2 6 2 6 2 3 5 9

3 8 3 8 9 12 6 2

8 13 5 9 1 4 7 10

8 11 7 10 17 19 8 13

8 12 7 11 8 11 11 8

12 9 8 11 2 6 12 9

9 5 8 12 16 19 14 18

11 15 8 13 3 8 15 11

12 16 9 12 11 15 16 19

16 19 11 15 12 16 17 19

19 17 12 16 16 18 18 16

16 18 14 18 7 10 20 19

11 7 16 18 8 12 3 8

7 10 16 19 7 11 7 11

19 20 17 19 14 18 12 8

18 14 19 20 19 20 16 12

Tempo de execução: 20 ms 220 ms 80 ms 20 ms

Número de iterações: 19 19 45 2

__________________________________________________________________________________________________________ 16


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 7 8 - - - Campinas 4 7 - - -

Bauru - - 7 5 6 Ribeirão-Preto - - 8 7 9

O problema apresentado acima segue a seguinte forma matricial:

'

. { } | 0 i i

min fo c xAx b

s ax x x 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=[ 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0

0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0

0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0

0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0

-1 0 -1 0 1 1 1 0 0 0 1 -1 1 0 0 0

0 -1 0 -1 0 0 0 1 1 1 -1 1 0 1 0 0

0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0

0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 ]

b=[ 1500 1000 950 1000 1220 0 0 50 50 ]

c=[ -7 -8 -4 -7 -7 -5 -6 -8 8 -7 -9 0 0 0 0 0 ]

__________________________________________________________________________________________________________ 17

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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= [1500 0 1000 0 950 1000 1220 0 0 0 0 0 550 0 50 50]

Função Objetivo: 33470 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 33470. 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, 2000.

[2] Bazaraa, Jarvis, Sherali – Linear Programming and Network flows, J. Willey and sons, 1990.

__________________________________________________________________________________________________________ 18


VI. APÊNDICE 1 - FLUXOGRAMAS:

_______

INICIO INICIO

Fluxograma de Dijkstra

__________________________________________________________________

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

T < N

R ← xi, tal que dNi,i ← Min ⎨ dNi,i ⎬ F ← F ∪ ⎨r⎬ A ← A \ ⎨r⎬ V ← A ∩ Γ+( r)

FIM

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

INICIO



S ← 0 I é o vértice inicia escolhida

T ← i V ← N \ ⎨ i ⎬

Para | T | ≠ N

Procurar a aresta menor (j,k) ∈ A tal que j ∈ T, k ∈ V



L (i,k) ← D ( Ni. i)

L (j,k-1) ≠ L(j,k)

FIM

L (j,k+1) ← Min ⎨ L(j,k), L (i,k) + D(i,j) ⎬ I ≠ Ni ; j = 1,2,3,...N K ← k + 1

L (i,k) < ∝

Ant ( i ) ← 0

Ant ( i ) ←

INICIO

Fluxograma de Ford-Moore-Bellman

Fluxograma de Prim

__

Fluxograma de Prim Colorido

19 _______________________________



N ← vértice inicial escolhido T ← N i ← 0

Para I < N-1

S l i l id d “ ”

Colorir de “x” as arestas que contem vértice origem Ni


Fluxograma de Kruskal Fluxograma de Boruvska

INICIO

Definir matriz D com as distancias que ligam os nós da rede.


T ← hi

| T | < N

FIM

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

Ordenar as arestas no vector H

INICIO



F ← φ

L (j,k-1) ≠ L(j,k)

FIM

Para cada Tj ; Determinar a menor aresta (xa, ya ) Onde xa ∈ Ti e Ya ∉ Ti (suponha ya ∈ Tj )

Definir a floresta inicial Tj, j = 1,2,3,...N com N sub-

arvores

F ← F ∪ (xa, ya) Aglutinar as duas sub arvores Ti e Tj

__________________________________________________________________________________________________________ 20


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; % Montagendo 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); end; % Fazendo dl = inf, e dl(1) = 0 d1(1) = 0;

__________________________________________________________________________________________________________ 21

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ for i = 2:n, d1(i) = inf; end; 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; end end F(r) = 1; A(r) = 0; for k = 1:n if((S(r,k) == 1)&(A(k) == 1)) V(k) = 1; end end 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); end if(p < d1(i)) d1(i) = p; rot(i) = r; end end end for i = 1:n V(i) = 0; end contador = contador + 1; end tempo = toc; % Travando Cronometro % Exibindo os resultados

__________________________________________________________________________________________________________ 22

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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)); end 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); end k = 1; j = 1;

__________________________________________________________________________________________________________ 23

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ lj(1) = 0; for i = 2:n lj(i) = custo(1,i); end Ls(1) = custo(1,j); for i = 1:n for j = 1:n if (S(i,j) == 1) ANT(i,j) = i; end end end 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); end end if(menor < lj(j)) fim = 0; lj(j) = menor; end end k = k + 1; contador = contador + 1; end 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)); end fprintf('\n'); fprintf('\n __________________________________'); fprintf('\n Tempo gasto(ms) = %.4f',tempo * 1000);

__________________________________________________________________________________________________________ 24

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ fprintf('\n __________________________________'); fprintf('\n Numero de iteracoes = %d',contador); fprintf('\n __________________________________'); fprintf('\n'); 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); % Escolhendo 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); end contador = 0; while length(T) < n % Encontrando a menor aresta

__________________________________________________________________________________________________________ 25

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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); end end end T = [T novo]; V = V(V ~= novo); S = [S entra novo]; contador = contador + 1; end 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; end 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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ % 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; end end % Montando a matriz custos for i = 1:NumArcos dist(noorigem(i),i) = Custos(i); dist(nodestino(i),i) = Custos(i); end 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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ end 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; end end end 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; end end end end end i = i + 1; contador = contador + 1; end 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)); end end 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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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); % Montagendo a matriz de custos for j = 1:NumArcos, custo(noorigem(j),nodestino(j)) = Custos(j); custo(nodestino(j),noorigem(j)) = Custos(j); end; 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)); end 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; end end end T = [H(1,1) H(1,2)]; No = T; NT(1) = 2;

__________________________________________________________________________________________________________ 29

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ H( 1 , : ) = []; Dist( 1 ) = []; contador = 0; while length(T) < 2*(NumArcos - 1) if isempty(H) == 1 break; end [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; end 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; end 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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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); end; for i = 1 : n T(i,1) = i; NT(i) = 1; end 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); end end end end end V = [V no nd]; end 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

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ T( Lin1, NT(Lin1) ) = T( Lin2, j); end T( Lin2 , : ) = []; NT( Lin2 ) = []; F = [F V(i) V(i+1)]; end end contador = contador + 1; end 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; end 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


VIII. APÊNDICE 3

EXERCÍCIO 3: FLUXO EM REDES

O problema apresentado no trabalho pode ser representado pela figura abaixo:

1

5

6

7

2

43

São Paulo

Campinas

Ribeirão Preto Bauru

Franca

Araçatuba

Ourinhos

b3=0

b2=1000

b5=-950

b6=-100

b7=-1220

b4=0

b1=1500

[7] [8]

[4] [7]

[7] [8][0, 50, 0]

[0, 50, 0]

[6] [9]

[5] [7]

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


1

5

6

7

2

43

São Paulo

Campinas

Ribeirão PretoBauru

Franca

Araçatuba

Ourinhos

b 3 =0

b2=1000

b5=-950

b6=-1000

b7=-1220

b4=0

b1=1500

[7] [8]

[4] [7]

[7] [8][0, 50, 0]

[0, 50, 0]

[6] [9]

[5] [7]

Nó de Balanceamento

8

=670 b3

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 (w9=0), tem-se:

1

5

6

7

8

2

3 4 9

950

1500

0

670

01000

1000

1220

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


Custos relativos:

___ ________________________________________ 35

⇒ Entra arco (8,5)

13ˆ 7c =

14ˆ 8c =

35ˆ 7 2c M= −

45ˆ 8 2c M= −

34ˆ 0c =

36ˆ 5 2c M= −

46ˆ 7 2c M= −

43ˆ 0c =

37ˆ 6 2c M= −

47ˆ 9 2c M= −

24ˆ 7c =

23ˆ 4c =

85ˆ 2c M= −

86ˆ 2c M= −

87ˆ 2c M= −

⇐ sai arco (8,9)

Custos relativos:

_________________________________________________4c

3cˆ

3c

4c

3c

______________6 7 2M= −

43ˆ 0c =

7 6 2M= −

9 2M

13ˆ 7c =

14ˆ 8c =

5 7 2M= −

5 8 2M= −

34ˆ 0c =

6 5 2M= −


⇒ Entra arco (3,6) ⇐ sai arco (3,9)

Custos relativos:

________________________________________ 36

_______________________________________________
___________________ 23ˆ 9 2c M= −
86ˆ 0c =

ˆ 0c =

13ˆ 12 2c M= −

14ˆ 8c =

35ˆ 2c =

45ˆ 8 2c M= −

34ˆ 5 2c M= − +

46ˆ 7 2c M= −

43ˆ 5 2c M= −

37ˆ 1c =

47ˆ 9 2c M= −

24ˆ 7c =

87



Custos relativos:

⇒⇐

________________________________________________

13ˆ 12 2c M= −

14ˆ 13 2c M= −

35ˆ 2c =

45ˆ 3c =

34ˆ 0c =

46ˆ 2c =

37ˆ 1c =

47ˆ 4c =

24ˆ 12 2c M= −

23ˆ 9 2c M= −

86ˆ 0c =

ˆ 0c =
87
Entra arco (2,3) sai arco (9,6)

__________________________________________________________ 37


Custos relativos:

86c

37c

47c

35c

45c

⇒ E⇐ s

___________________________________________________

9 2M= − +

ˆ 0c =

10 2M= −13 2M= −

24ˆ 3c

=

46ˆ 2c =

13ˆ 3c =

14ˆ 4c =

11 2M= −12 2M= −

34ˆ 0c

=

87

ntra arco (3,7) ai arco (2,9)

_______________________________________________________ 38


Custos relativos:

13ˆ 13 2c M= −

14ˆ 14 2c M= −ˆ 1c

35 =

45c 2=

34c 0=

46c 2=

47c 3=

24c 3=

86ˆ 1c =

87c 0=


__________________________________________________________________________________________________________ 39


Custos relativos:

14ˆ 1c =

86ˆ 12 2c M= − +

87ˆ 12 2c M = − +

47ˆ 3c =

24ˆ 3c =

46ˆ 2c =

35ˆ 14 2c M= −

45ˆ 15 2c M= −

34ˆ 0c =


__________________________________________________________________________________________________________ 40


Término da Fase I

Fase II :

Custos relativos:

14ˆ 1c =

45ˆ 1c =

34ˆ 0c =

46ˆ 2c =

47ˆ 3c =

24ˆ 3c =

86ˆ 2c =

87ˆ 1c =

__________________________________________________________________________________________________________ 41

Otimização Linear Teoria dos Grafos & Fluxos em Redes _______________________________________________________________________________________________________________ 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:

[ ]'85433736352313

* xxxxxxxx =

[ ]'* 67001220100028010001500=x

__________________________________________________________________________________________________________ 42

“teoria dos grafos e fluxos em redes” - dt - home...

Documents