Aula 24 – Aproximação TSP e Problema da Mochila

25089/1001525 – Projeto e Análise de Algoritmos

2019/2 - Turma A
Prof. Dr. Murilo Naldi

naldi@dc.ufscar.br
Agradecimentos

●
Aos professores Mário Felice e Diego Furtado por ceder
parte do material utilizado.
●
Material inspirado nas aulas do prof. Tim Roughgarden
Traveling Salesman Problem, TSP
●
Ou problema do caixeiro viajante
– Entrada: um grafo completo não-orientado G = (V,
E) com custos c(e) não negativos nas arestas
– Solução: um circuito de custo mínimo que visita
cada vértice exatamente uma vez
●
Veremos um algoritmo aproximado que, dado os
requisitos acima, os pesos das arestas devem
respeitar a desigualdade triangular.
Algoritmo de Adição do Mais Próximo

AdMaisPróximo(G=(V, E), c) {
encontre os dois vértices mais próximos
construa um ciclo C entre esses dois vértices
enquanto V(C) != V
seja i є V(C) e j є V \ V(C) o par que minimiza c(i, j)
seja k o vértice que segue i no ciclo C
adicionamos j em C entre i e k
devolva C
}
Eficiência

●
Observe que o algoritmo escolhe, em cada iteração,
o vértice fora de C que é alcançado por uma aresta
de custo mínimo que tem uma ponta num vértice de
C.
– tivemos que fazer algo muito parecido no
algoritmo de Prim e resolvemos isso usando um
heap de mínimo.
Eficiência

●
A eficiência obtida com isso é Θ(m log n), pois
– embora a iteração principal do algoritmo só ocorra
Θ(n) vezes
– e remover do heap o vértice que minimiza o valor da
aresta tenha custo Θ(log n)
– em cada iteração pode ser necessário atualizar no
heap o valor da aresta de menor custo para todos os
vértices alcançados pelo vértice removido do heap
●
cada uma dessas atualizações custa Θ(log n)
●
e podem ocorrer Θ(m) dessas ao longo da
execução de todo o algoritmo
 Garantia de qualidade

●
Vamos explorar a semelhança do comportamento
desse algoritmo com o algoritmo de Prim, que obtém
uma árvore geradora mínima
– primeiro, observe que o custo de uma árvore
geradora mínima <= custo ótimo do TSP
– para entender porque isso ocorre, seja
●
OPT o custo de um circuito que é solução ótima
do TSP
●
Path o custo de um caminho obtido removendo
uma aresta do circuito ótimo do TSP
●
MST uma árvore geradora mínima
Garantia de qualidade

●
Note que
– MST <= Path , pois MST é a árvore de custo
mínimo e Path é o custo de um caminho, que é
uma árvore em particular
– Path <= OPT , pois OPT é o custo de Path mais o
custo da aresta que foi removida
– MST <= Path <= OPT
 Garantia de qualidade
●
Agora vamos mostrar que o custo do circuito obtido pelo
algoritmo é <= 2 MST
– Primeiro, observe que o algoritmo se comporta
exatamente como o algoritmo de Prim (que tivesse
começado em um dos vértices extremos da aresta de
menor custo)
●
Ou seja, a sequência com que o algoritmo adiciona
vértices a C é a mesma que o algoritmo de Prim
adiciona vértices à árvore
– Vamos focar numa iteração qualquer do algoritmo
●
E mostrar que o custo que o circuito aumenta nesta
iteração é no máximo 2 * o custo que a árvore
geradora mínima aumentaria
Aumento do custo

●
Observe que o algoritmo escolhe o vértice mais
próximo j (que está próximo de i e será adicionado
entre i e k)
– Assim, o custo do circuito vai aumentar de
●
c(i, j) + c(j, k) - c(i, k)
– No entanto, pela desigualdade triangular
●
c(j, k) <= c(i, j) + c(i, k) →
●
c(j, k) - c(i, k) <= c(i, j)
Aumento do custo
●
Portanto, o aumento no custo do circuito (lado
esquerdo da seguinte inequação)
– c(i, j) + c(j, k) - c(i, k) <= 2 * c(i, k)
●
Como o lado direito da seguinte inequação é duas
vezes o aumento no custo da árvore geradora mínima
●
Somando ao longo de todas as iterações do algoritmo
(e observando que ele começa com um circuito que
custa duas vezes as arestas de menor custo do grafo)
– temos que o custo do circuto <= 2 * MST <= 2 *
OPT
●
Ou seja, o algoritmo é 2-aproximado
Problema da mochila
●
Entrada:
– n itens, sendo que cada item i (1<=i<=n) tem
● valor vi > 0
● peso wi > 0 e inteiro
– capacidade W > 0 e inteiro
●
Solução:
– subconjunto S de itens que
– maximiza
∑ v i (tem lucro máximo)
i∈S
–
∑ w i≤W (e não viola a capacidade)
i∈S
Problema da mochila

●
Aparece com muita frequência como subproblema
de outros problemas de interesse, sempre que
temos um recurso que queremos usar da melhor
forma possível.
Ideia para uma heurística gulosa

●
Itens com maior valor tem prioridade
●
Itens com menor peso tem prioridade
●
Para relacionar essas duas grandezas:
– Itens com maior densidade de valor tem
prioridade
Heurística

●
1) ordenamos os itens em ordem decrescente de
razão vi/wi, para i = 1, ..., n
– para facilitar, renomeamos os itens de 1 a n
seguindo essa ordem
– v1/w1 >= v2/w2 >= v3/w3 >= ... >= vn/wn
●
2) colocamos os itens na mochila nesta ordem até
não caber mais
Heurística

●
Como podemos verificar nos exemplos, existem
casos em que a solução desta heurística não
fornece qualquer garantia de qualidade em relação à
solução ótima
– no entanto, uma pequena variação da mesma se
sai muito melhor
Heurística melhorada

●
1) ordenamos os itens em ordem decrescente de
razão vi/wi, para i = 1, ..., n
– para facilitar, renomeamos os itens de 1 a n
seguindo essa ordem
● v1/w1 >= v2/w2 >= v3/w3 >= ... >= vn/wn
●
2) colocamos os itens na mochila nesta ordem até
não caber mais
●
3) escolhemos o melhor entre o empacotamento
que obtivemos no item 2 e o item de maior valor
disponível fora do empacotamento
Demonstração

●
Considere uma solução fracionária gulosa Sf
construída seguindo a ordem do algoritmo guloso
mas que
– ao encontrar o primeiro item (k+1) que não cabe
na mochila, pega a maior fração dele que
couber
Demonstração

●
Para verificar isso, considere uma solução qualquer S
diferente de Sf
– suponha que S tem l unidades que não estão presentes
em Sf
– como Sf preenche totalmente a mochila, ela tem pelo
menos l unidades que não estão presentes em S
– mas, pelo critério guloso, sabemos que a densidade de
valor dos itens escolhidos para Sf é a maior possível
– portanto, as l unidades de Sf tem valor >= que as l
unidades de S
●
o que mostra que Sf tem valor >= que S
– como S é uma solução qualquer, Sf tem valor >= que a
solução ótima, inclusive
Demonstração

●
Agora, note que o valor do algoritmo é o melhor
(maior) entre
– o valor dos primeiros k itens que couberam na
mochila
– o valor do item k+1 que não coube na mochila
●
já que ele é um dos itens que o algoritmo
considera ao escolher o de maior valor
Demonstração

●
Portanto k
valor algoritmo >=
–
∑ vi
i=1
– valor algoritmo >= vk+1
●
Somando k +1
– 2 valor algoritmo >= ∑ vi
i=1 >= valor Sf
>= OPT
●
Finalmente
– valor algoritmo >= OPT / 2
Exemplo Justo

●
v1 = 502 w1 = 501
●
v2 = 500 w2 = 500
●
v3 = 500 w3 = 500
●
valor da solução da heurística gulosa = 502
●
valor da solução ótima = 1000