otimização linear - DComp

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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
•
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')
Ex.:
G"(V", A") = G(V, A), V = V'
G1
G2:
G1
V" e A = A'
A".
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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.:
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
embora
mantendo
o
número
de
curvas
entre
os
vértices
existentes.
__________________________________________________________________________________________________________
6
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
12
1
12
2
13
2
13
2
14
3
15 ]
3
4
5
5
6
6
7
7
4
16
9
15
4
16 ]
5
7
6
12
7
8
10
14
8
9
10 11
11
9 11
11 13
15
NoDestino
nodestino=[
2
13
5
15
3
14
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Custos=[
1
7
12
4
5
8
2
6
8
6
8
7
2
3
5
8
5
4
9
1
2
3 10
2 6
8 10
7 4 9 6
8 10 14 10
8]
8
9
1
5
8
8
9 10 12
9 5 1
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
Ford-Moore-Bellman
Djkstra
Nó
Tabela 2: Resultados das implementações com o
algoritmo de Ford-Moore-Bellman
Nó
Valor do
Caminho
0
1
0
Origem de Valor do
Rotulação Caminho
1
1
2
1
75
2
75
3
2
150
3
150
4
2
195
4
195
5
1
120
5
120
6
5
180
6
180
7
6
255
7
255
8
6
240
8
240
9
8
300
9
300
10
7
405
10
405
11
9
360
11
360
12
5
420
12
420
13
11
435
13
435
14
15
540
14
555
15
11
480
15
480
16
13
510
16
510
Tempo de
execução:
170 ms
Tempo de
execução:
170 ms
Número de iterações: 16
Número de iterações: 2
__________________________________________________________________________________________________________
13
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Arquivo de entrada: Grafo2_Dados (48 arcos)
Tabela 3: Resultados das implementações com o
algoritmo de Dijkstra
Ford-Moore-Bellman
Dijkstra
Nó
Tabela 4: Resultados das implementações com o
algoritmo de Ford-Moore-Bellman
Origem de Valor do
Rotulação Caminho
Nó
Valor do
Caminho
1
1
0
1
0
2
1
1
2
1
3
2
3
3
3
4
1
2
4
2
5
1
6
5
6
6
2
4
6
4
7
3
10
7
10
8
3
7
8
7
9
5
7
9
7
10
7
15
10
15
11
8
10
11
10
12
9
9
12
9
13
8
8
13
8
14
10
25
14
25
15
11
15
15
15
16
12
14
16
14
17
13
20
17
20
18
16
19
18
19
19
16
18
19
18
20
19
26
20
26
Tempo de
execução:
40 ms
Tempo de
execução:
40 ms
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
Tempo de
execução:
Número de
iterações:
Prim-Colorido
Kruskal
Boruvka
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
20 ms
15
270 ms
15
110 ms
24
Nó Origem Nó Destino
170 ms
2
__________________________________________________________________________________________________________
15
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Arquivo de entrada: Grafo2_Dados (48 arcos)
Tabela 6: Resultados apresentados para o Grafo 2
Prim
Tempo de
execução:
Número de
iterações:
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
20 ms
19
220 ms
19
80 ms
45
20 ms
2
__________________________________________________________________________________________________________
16
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
São Paulo
7
8
Campinas
4
7
Bauru
7
Ribeirão-Preto
8
Araçatuba
5
7
Ourinhos
6
9
O problema apresentado acima segue a seguinte forma matricial:
min fo = c ' x
⎧ Ax = b
s.a
⎨
⎩ 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=[
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=[
-5
-6
-8
8
-7
-9
0
0
0
0
0
]
-7
-8
-4
-7
-7
__________________________________________________________________________________________________________
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
VI. APÊNDICE 1 - FLUXOGRAMAS:
Fluxograma de Dijkstra
INICIO
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
Fluxograma de Ford-Moore-Bellman
INICIO
Definir matriz com as
distancias que ligam os
nós da rede.
INICIALIZAR AS
VARIAVELS
L (i,k) ← D ( Ni. i)
L (i,k) < ∝
Ant ( i ) ←
T< N
R ← xi, tal que dNi,i ← Min ⎨ dNi,i ⎬
F ← F ∪ ⎨r⎬
A ← A \ ⎨r⎬
V ← A ∩ Γ+( r)
Ant ( i ) ← 0
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
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
FIM
FIM
Fluxograma de Prim
Fluxograma de Prim Colorido
INICIO
INICIO
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⎬
Definir matriz com as
distancias que ligam os
nós da rede.
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
_________________________________________________________________________
_________________________________
Para I < N-1
Procurar a aresta menor (j,k) ∈ A tal que
19
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Fluxograma de Kruskal
INICIO
Definir matriz D com as
distancias que ligam os
nós da rede.
Ordenar as arestas
no vector H
INICIALIZAR AS
VARIAVELS
T ← hi
Fluxograma de Boruvska
INICIO
Definir matriz com as
distancias que ligam os
nós da rede.
Definir a floresta inicial Tj,
j = 1,2,3,...N com N subarvores
INICIALIZAR AS
VARIAVELS
F←φ
L (j,k-1) ≠ L(j,k)
|T|<N
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
FIM
Para cada Tj ;
Determinar a menor aresta (xa, ya )
Onde xa ∈ Ti
e
Ya ∉ Ti (suponha ya ∈ Tj )
F ← F ∪ (xa, ya)
Aglutinar as duas sub arvores
Ti e Tj
FIM
__________________________________________________________________________________________________________
20
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
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
fprintf('\n
fprintf('\n
fprintf('\n
for i = 1:n
fprintf('\n
end
fprintf('\n');
fprintf('\n
fprintf('\n
fprintf('\n
fprintf('\n
fprintf('\n
fprintf('\n');
_________________________________________________');
|
Algoritmo - DJKSTRA
|');
_________________________________________________');
No Origem da Rotulacao
Valor do Caminho');
____ _____________________ _________________');
%d
%d
%d
',i,rot(i),d1(i));
_________________________________________________');
Tempo gasto(ms) = %.4f',tempo * 1000);
_________________________________________________');
Numero de iteracoes = %d',contador);
_________________________________________________');
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
VIII. APÊNDICE 3
EXERCÍCIO 3: FLUXO EM REDES
O problema apresentado no trabalho pode ser representado pela figura abaixo:
São Paulo
b1=1500
1
[7]
[7]
Franca
b5=-950
5
[8]
[0, 50, 0]
[8]
Araçatuba
Bauru 3
b3=0
[5]
[7]
6
4
b6=-100
[0, 50, 0]
[6]
Ourinhos
7
Ribeirão Preto
b4=0
[9]
b7=-1220
[4]
[7]
2
b2=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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
São Paulo
b1=1500
1
[7]
[7]
Franca
b5=-950
5
[8]
[0, 50, 0]
[8]
Araçatuba
[5]
Bauru 3
b3=0
[7]
6
4
b6=-1000
[0, 50, 0]
[6]
Ourinhos
7
Ribeirão Preto
b4=0
8
b =670
3
[9]
Nó de Balanceamento
b7=-1220
[7]
[4]
2
b2=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 (w9=0), tem-se:
1
0
1500
5
950
9
0
1000
3
6
4
1220
7
1000
670
2
8
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
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Custos relativos:
cˆ13 = 7
cˆ14 = 8
cˆ35 = 7 − 2 M
cˆ45 = 8 − 2 M
cˆ34 = 0
cˆ36 = 5 − 2 M
cˆ46 = 7 − 2 M
cˆ43 = 0
cˆ37 = 6 − 2 M
cˆ47 = 9 − 2 M
cˆ24 = 7
cˆ23 = 4
cˆ85 = −2 M
cˆ86 = −2 M
cˆ87 = −2 M
⇒ Entra arco (8,5)
⇐ sai arco (8,9)
Custos relativos:
cˆ13 = 7
cˆ14 = 8
cˆ35 = 7 − 2 M
cˆ45 = 8 − 2 M
cˆ34 = 0
cˆ36 = 5 − 2 M
cˆ46 = 7 − 2 M
__________________________________________________________________________________________________________
cˆ43 = 0
cˆ37 = 6 − 2 M
35
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
⇒ Entra arco (3,6)
⇐ sai arco (3,9)
Custos relativos:
cˆ13 = 12 − 2 M
cˆ14 = 8
cˆ35 = 2
cˆ45 = 8 − 2 M
cˆ34 = −5 + 2 M
cˆ46 = 7 − 2 M
cˆ43 = 5 − 2 M
cˆ37 = 1
cˆ47 = 9 − 2 M
cˆ24 = 7
cˆ23 = 9 − 2 M
__________________________________________________________________________________________________________
cˆ86 = 0
cˆ87 = 0
36
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
⇒ Entra arco (4,3)
⇐ sai arco (4,9)
Custos relativos:
cˆ13 = 12 − 2 M
cˆ14 = 13 − 2 M
cˆ35 = 2
cˆ45 = 3
cˆ34 = 0
cˆ46 = 2
cˆ37 = 1
cˆ47 = 4
cˆ24 = 12 − 2 M
cˆ23 = 9 − 2 M
cˆ86 = 0
cˆ87 = 0
⇒ Entra arco (2,3)
⇐ sai arco (9,6)
__________________________________________________________________________________________________________
37
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Custos relativos:
cˆ13 = 3
cˆ14 = 4
cˆ35 = 11 − 2 M
cˆ45 = 12 − 2 M
cˆ34 = 0
cˆ46 = 2
cˆ37 = 10 − 2 M
cˆ47 = 13 − 2 M
cˆ24 = 3
cˆ86 = −9 + 2 M
cˆ87 = 0
⇒ Entra arco (3,7)
⇐ sai arco (2,9)
__________________________________________________________________________________________________________
38
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Custos relativos:
cˆ13 = 13 − 2 M
cˆ14 = 14 − 2 M
cˆ35 = 1
ĉ45 = 2
ĉ34 = 0
ĉ46 = 2
ĉ47 = 3
ĉ24 = 3
cˆ86 = 1
ĉ87 = 0
⇒ Entra arco (1,3)
⇐ sai arco (9,7)
__________________________________________________________________________________________________________
39
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Custos relativos:
cˆ14 = 1
cˆ35 = 14 − 2 M
cˆ45 = 15 − 2 M
cˆ34 = 0
cˆ46 = 2
cˆ47 = 3
cˆ24 = 3
cˆ86 = −12 + 2 M
cˆ87 = −12 + 2 M
⇒ Entra arco (3,5)
⇐ sai arco (9,5)
__________________________________________________________________________________________________________
40
Otimização Linear
Teoria dos Grafos & Fluxos em Redes
_______________________________________________________________________________________________________________
Término da Fase I
Fase II :
Custos relativos:
cˆ14 = 1
cˆ45 = 1
cˆ34 = 0
cˆ46 = 2
cˆ47 = 3
cˆ24 = 3
cˆ86 = 2
cˆ87 = 1
__________________________________________________________________________________________________________
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:
x * = [x13
x 23
x35
x36
x37
x 43
x85
x* = [1500 1000 280 1000 1220 0 670
]'
]'
__________________________________________________________________________________________________________
42