Reduzindo o tempo de

algoritmos heurísticos
para o TSP Simétrico
Guilherme Polo

Disponível em http://goo.gl/rjSw
 Reduzindo o tempo de
algoritmos heurísticos
para o TSP Simétrico
Guilherme Polo

Disponível em http://goo.gl/rjSw
 Sumário
Problema Bibliografia

Estratégia Extras

Greedy

2-Opt

GRASP

Resultados finais
 Problema

O Problema do Caixeiro Viajante (TSP)

consiste em encontrar um ciclo
hamiltoniano de custo mínimo.

Para N pontos: N ! caminhos possíveis

Possíveis caminhos com custos

distintos no STSP: N !
2N
 Estratégia
Encontrar um caminho inicial válido

Algoritmo construtivo: Greedy NN

Tentar reduzir o custo do caminho

inicial

Busca local: 2-Opt, 2.1/4 -Opt

Tentar fugir de ótimo local por GRASP

Algoritmo construtivo
Greedy NN
5 5

1 1
2 2
3 3

6 6

4 4

1 2 3 4 6 5
Algoritmo Greedy 1 naive-greedy-nn(start, n, C)
seja T [1 . . n] um novo array
visitado = ∅ ; atual = start ; custo = 0
for i = 1 to n − 1
T [i] = atual ; visitado = visitado ∪ {atual }
menor = ∞ ; proximo = nil
for j = 1 to n
if j �∈ visitado and C(atual , j) < menor
menor = C(atual , j)
proximo = j
custo = custo + menor
atual = proximo
T [n] = atual
custo = custo + C(atual , start)
return (T, custo)
 Problemas com o
NAIVE-GREEDY-NN
1.Considera todos os vizinhos

2.Trabalhar com matriz nxn é inviável

~47.68 GB para uma instância com

80.000 pontos (assumindo inteiro de 8 bytes)
80000 Paginação
* 80000 * 8 =excessiva.
51200000000 Bytes
51200000000 / 1024 / 1024 / 1024 ≈ 47.6837158 GB
 Problemas com o
NAIVE-GREEDY-NN
2.Trabalhar com matriz nxn é inviável

No pseudo-código, C é uma função

capaz de calcular o custo entre
dois pontos

Cálculos repetidos. Ainda assim,

menos custoso que matriz nxn
 Problemas com o
NAIVE-GREEDY-NN
Testando empiricamente com algumas
instâncias da TSPLIB. (gcc -O2, Mac OS X)

1.Considera todos os vizinhos

d2103 vm1084
~0.08
~0.02
s s d18512 ~ 2.94 s

d15112d2103
~5.20 s s
~0.04 pla33810 ~ 8.58 s

d18512d15112
~9.10 s s
~2.15 pla85900 ~56.04 s

Média de 5 execuções, user time + system time

Melhorando o tempo
do algoritmo Greedy
Uma estrutura de dados mais adequada*
resolve o problema

vm1084 ~0.01 s d18512 ~0.04 s

d2103 ~0.01 s pla33810 ~0.07 s

d15112 ~0.04 s pla85900 ~0.17 s

* Juntamente com operações que fazem bom uso da estrutura

 Melhorando o tempo
do algoritmo Greedy
Tempo de execução (segundos) Melhoria (vezes)
380
0,02 329,64
vm1084 0,01

0,04 254
d2103 0,01

2,15 122,57
d15112 127
0,04 73,50
53,75
2,94 2,00 4,00
d18512 0,04 1
vm1084 pla85900
8,58
pla33810 0,07

56,04 Naïve
pla85900 0,17 Melhorado

0,01 0,1 1 10 100

Melhorando o tempo
do algoritmo Greedy
Atividade/Tempo no Greedy melhorado
100% 9% Saída
11% 11% 12%
15% Entrada
18% 20% 22%
75% Outros
Inicialização
37% 25% 20% 15% Greedy tour
50%
16% 17%
16%
14%
25%
30% 32% 34%
25%
0%
d15112 d18512 pla33810 pla85900
 Tempo para obter caminho inicial
10,0

7,5
y = 0,0966x - 0,1196
R² = 0,9988

5,0

2,5

0
pla85900 rl2-1116700 rl2-2147500 rl2-3178300 rl2-4209100

Tempo (s) Tendência 1

 Tempo para inicializar estrutura
10,0

7,5
y = 0,0408x1,4135
R² = 0,9941

5,0

2,5

0
pla85900 rl2-1116700 rl2-2147500 rl2-3178300 rl2-4209100

Tempo (s) Tendência 1

 Inicialização e Greedy tour
10,0

7,5

5,0

2,5

0
pla85900 rl2-1116700 rl2-2147500 rl2-3178300 rl2-4209100

Tempo (s) Init Tempo (s) Greedy

Melhorando o tempo
do algoritmo Greedy
Estrutura de dados:

k-d tree (2-d), Bentley 1975

Otimizada para busca eficiente:

Friedman, Bentley, Finkel 1977

Operações adequadas:

Bentley 1990 (Pontos não se alteram)

k-d trees ..
k-d tree
ou kd-tree;
ou kdtree;
ou árvore binária de busca multidimensional

Permite efetuar operações de proximidade de

forma eficiente

Vizinho mais próximo

Vizinhos mais próximos em um raio

Exemplos de aplicações: ray-tracing,

simulação n-body, 2-opt, banco de dados
Exemplo de algoritmo
para construção
build(P, l, u, d)
node = kdnode-new()
Quantidade máxima de pontos
if u − l = = 0 em um bucket; 1 aqui
node. val = P [l]
else
m = (l + u)/2
if (d mod 2) = = 0
sort(P, l, u, X)
node. cut = P [m]. x
else Cuidado com o custo

sort(P, l, u, Y)
node. cut = P [m]. y
node. left = build(P, l, m, d + 1)
node. right = build(P, m + 1, u, d + 1)
return node
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
30
30,25
25
10,20
20
20,15
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y
X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 NIL
30
30,25
25
10,20
20
20,15
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (25;10),
<(5;5), (10;20), (20,
(10;30),
15), (20;15),
(10;20), (25;10),
(30;25), (30;25)>
(10;30)>
X Ordenado
Ordenar por
porx x
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25
25
10,20
20
20,15
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X Ordenado por x
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25
10,20
20
20,15
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X Ordenado por y
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20
20,15
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X Ordenado por x
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10 4 6 1 5 15 NIL
5,5
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (25;10), (20;15), (30;25)>

X Ordenado por y
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10 4 6 1 5 15 NIL
5,5
4 5 2 4 20 NIL
5

0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X Ordenado por x
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10 4 6 1 5 15 NIL
5,5
4 5 2 4 20 NIL
5
4 4 3 NIL NIL (20;15)
0
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10 4 6 1 5 15 NIL
5,5
4 5 2 4 20 NIL
5
4 4 3 NIL NIL (20;15)
0 5 5 3 NIL NIL (25;10)
0 5 10 15 20 25 30 35

Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>

X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10 4 6 1 5 15 NIL
5,5
4 5 2 4 20 NIL
5
4 4 3 NIL NIL (20;15)
0 5 5 3 NIL NIL (25;10)
0 5 10 15 20 25 30 35
6 6 2 NIL NIL (30;25)
Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>
X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35 l u d m cut val
10,30
1 6 0 3 10 NIL
30
30,25 1 3 1 2 20 NIL
25 1 2 2 1 5 NIL
10,20
20 1 1 3 NIL NIL (5;5)
20,15 2 2 3 NIL NIL (10;20)
15
3 3 2 NIL NIL (10;30)
25,10
10 4 6 1 5 15 NIL
5,5
4 5 2 4 20 NIL
5
4 4 3 NIL NIL (20;15)
0 5 5 3 NIL NIL (25;10)
0 5 10 15 20 25 30 35
6 6 2 NIL NIL (30;25)
Y <(5;5), (10;20), (10;30), (20;15), (25;10), (30;25)>
X
 Exemplo de construção
arvore = BUILD(<(5;5), (25;10), (20;15), (10;20), (30;25), (10;30)>, 1, 6, 0)

35
10,30 X 10
30

Dimensão de corte
30,25
25
10,20 Y 20 15
20
20,15
15
25,10 10; 30;
X 5 20
10 30 25
5,5
5
5; 10; 20; 25;
0 5 20 15 10
0 5 10 15 20 25 30 35

Y Outra representação
X
 rnn(root, d)
if root. val �= NIL
Exemplo de if root. val = = target
algoritmo para return
thisdist = euc-2d(root. val , target)
busca NN if thisdist < dist
dist = thisdist
Top-Down nn = root. val
else
cutval = root. cut
if (d mod 2) = = 0
kdtree-nn(root, nntarget)
thisval = target. x
target = nntarget else thisval = target. y
dist = ∞ if thisval ≤ cutval
nn = NIL rnn(root. left, d + 1)
rnn(root, 0) if (thisval + dist) > cutval
return nn rnn(root. right, d + 1)
else
rnn(root. right, d + 1)
if (thisval − dist) < cutval
rnn(root. left, d + 1)
Exemplo de busca NN

X 10

Y 20 15

10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

Exemplo de busca NN
10 <= 10

X 10

Y 20 15

10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

Exemplo de busca NN
10 <= 10
30 > 20
X 10

Y 20 15

10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

Exemplo de busca NN
10 <= 10
30 > 20
X 10
retorna
30 - ∞ < 20

Y 20 15

10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

Exemplo de busca NN
10 <= 10
30 > 20
X 10
retorna
30 - ∞ < 20
10 > 5
Y 20 15

10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

 10;20 15,81 Exemplo de busca NN
10;30 25,50 10
10 <= 10
20;15 18,03 11,18 18,03
30 > 20
25;10 20,62 18,03 25 7,07
X 10
retorna
30 - ∞ < 20
30;25 32,02 20,62 20,62 14,14 15,81
10 > 5
5;5 10;20 10;30 20;15Y 25;10 20 15 dist = 10
nn = 10;20
Distância Euclidiana 10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

 10;20 15,81 Exemplo de busca NN
10;30 25,50 10
10 <= 10
20;15 18,03 11,18 18,03
30 > 20
25;10 20,62 18,03 25 7,07
X 10
retorna
30 - ∞ < 20
30;25 32,02 20,62 20,62 14,14 15,81
10 > 5
5;5 10;20 10;30 20;15Y 25;10 20 15 dist = 10
nn = 10;20
Distância Euclidiana 10; 30;
10 - 10 < 5
X 5
30
20
25 não altera dist

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

Exemplo de busca NN
10 <= 10
30 > 20
X 10
retorna
30 - ∞ < 20
10 > 5
Y 20 15 dist = 10
nn = 10;20
10 - 10 < 5
10; 30;
X 5
30
20
25 não altera dist
10 + 10 > 10
5; 10; 20; 25;
5 20 15 10

Encontrar o ponto mais próximo de 10;30

 10;20 15,81 Exemplo de busca NN
10;30 25,50 10
10 <= 10
20;15 18,03 11,18 18,03
30 > 20
25;10 20,62 18,03 25 7,07
X 10
retorna
30 - ∞ < 20
30;25 32,02 20,62 20,62 14,14 15,81
10 > 5
5;5 10;20 10;30 20;15Y 25;10 20 15 dist = 10
nn = 10;20
Distância Euclidiana 10; 30;
10 - 10 < 5
X 5
30
20
25 não altera dist
10 + 10 > 10
5; 10; 20; 25; 30 > 15
5 20 15 10 não altera dist
30 - 10 ≮ 15

Encontrar o ponto mais próximo de 10;30

Exemplo de busca NN

X 10

Y 20 15

10; 30;
X 5 20
30 25

5; 10; 20; 25;

5 20 15 10

Encontrar o ponto mais próximo de 10;30

. continuando
 Escolhas para a
k-d tree

Tamanho máximo de um bucket: 5 kdnodes

Escolha de hiperplano de corte:

select-rs* + insertion sort

para |sub-array| ≤ 16

BNDS_LEVEL: 3 XXX não uso no greedy

* Implementação encontrada no livro do Robert Sedgewick

Algoritmo Greedy 2 kdtree-greedy-nn(tree, start, n, C)
seja T [1 . . n] um novo array
T [1] = start
atual = start
custo = 0
for i = 2 to n
kdtree-delete(tree, atual )
proximo = kdtree-nearest(tree, atual , C)
T [i] = proximo
custo = custo + C(atual, proximo)
atual = proximo
custo = custo + C(atual , start)
kdtree-undelete-all(tree, n)
return (T, custo)
Resultados com busca
Greedy (Naïve / Melhorado - 1) * 100

Naïve Melhorado* Diff ~

3 304
vm1084 290.806 286.437 1,52%
761 806
d2103 86.504 86.765 -0,29%

0 6523
d15112 1.960.503 1.921.015 2,05%
0 10818
d18512 799.220 779.783 2,49%
11394
0
pla33810 77.332.499 81.131.055 -4,68%
0 38007
pla85900 163.516.994 174.486.522 -6,29%

* Melhor resultado encontrado partindo de todos os pontos

Resultados com busca
Greedy
Obtido Ótimo Prox ~

vm1084 286.437 239.297 19,70%

d2103 86.504 80.450 7,52%

d15112 1.921.015 1.573.084 22,11%

d18512 779.783 645.238 20,85%

pla33810 77.332.499 66.048.945 17,08%

pla85900 163.516.994 142.382.641 14,84%

 Busca local
2-Opt

1
2-exchange 1
9 2 9 2

8 3 8 3

7 4 7 4

6 5 6 5

1 5 4 3 2 6 7 8 9 1 2 3 4 5 6 7 8 9
a b c d a c b d
 naive-2opt(T, n, cost, C)
repeat
ganho = 0
Algoritmo 2-Opt
for i = 1 to n
for j = i + 2 to n
if ((j + 1) mod n) = = i
continue
a = T [i]; b = T [(i + 1) mod n]
c = T [j]; d = T [(j + 1) mod n]
novo-ganho = C(a, c) + C(b, d)−
(C(a, b) + C(c, d))
if novo-ganho < ganho
ganho = novo-ganho
melhor = [b, c]
if ganho < 0
cost = cost + ganho
inverte(T, melhor [1], melhor [2])
until ganho = = 0
 Problema com o
NAIVE-2OPT

Sempre considera todos os pontos

Impraticável aplicar a instâncias

não-pequenas
 Problema com o
NAIVE-2OPT
Tempo (s) Trocas Custo Prox ~

vm1084 3,01 120 257.295 7,52%

d2103 8,30 86 82.125 2,08%

d15112 26700* 2.064 1.659.003 5,46%

Tempo somente para execução do 2-Opt

Pontos de partida: tabela de resultados Greedy

* Apenas uma execução em um outro computador (demais

instâncias demoraram ~50% a mais nesse outro)
Melhorando o tempo
do 2-Opt
Dados os pontos a e b, considerar
apenas aqueles pontos que estejam
mais próximos de a do que a está de b

k-d tree possibilita essa busca

Operação: busca por vizinhos

próximos em um raio fixo
dist(a,b)
Melhorando o tempo
do 2-Opt
Aproximações

Ao descobrir uma troca que reduz o

custo, ela é feita e a busca atual
termina

Se uma troca 2-Opt não reduzir o

custo, tenta-se realizar 2.1/4 -Opt
Melhorando o tempo
do 2-Opt
Outras considerações

A busca por vizinhos num raio só é

realizada se o ponto b não for o
mais próximo de a

Após realizar uma troca, o laço

volta um passo
 2. -Opt 1/
4
1
9 2

8 3

7 4

6 5
1 1
c a c a
9 2 9 2

x
2-Opt

8 3 8 3

7 4 7 4

6 5 6 5
b d b d
 2. -Opt 1/
4

1
c a 1
9 2
9 2

8 3
8 3

7 4
7 4

6 5
6 5
b d

1 2 6 7 8 9 5 4 3

1 2 9 6 7 8 5 4 3
a d
 Melhorando o tempo
do 2-Opt
2-Opt 2.1/4 -Opt Prox.
T (s) Trocas Custo T (s) Trocas Custo ~*
vm1084 0,00 153 260.184 0,00 190 254.355 6,29%
d2103 0,00 147 82.751 0,00 174 82.402 2,42%
d15112 0,07 3.564 1.686.957 0,07 4.228 1.666.102 5,91%
d18512 0,08 4.023 692.396 0,09 4.949 680.798 5,51%
pla33810 0,17 6.002 72.031.744 0,24 7.830 70.744.397 7,11%
pla85900 0,64 16.845 153.558.764 0,70 20.844 150.777.638 5,90%

* Considerando melhor obtido

 Quantidade trocas no 2-Opt aproximado
300000 y = 20546x + 252,05
R² = 0,999
Tempo 2-Opt aproximado 225000

150 150000
y = 1,3369x2 - 7,1294x + 10,326
75000
R² = 0,9936
113 0
pla85900 rl2-515400 rl2-944900

2-Opt trocas Tendência 1

75
Tempo “2-exchange”
5,0E-04 y = 4,722E-6x2 - 1,905E-5x + 7,019E-5
R² = 0,9957
38 3,8E-04

2,5E-04

0 1,3E-04
pla85900 rl2-515400 rl2-944900
0E+00
pla85900 rl2-515400 rl2-944900
2-Opt (s) Tendência 1
Tempo/Troca (s) Tendência 1
 Quantidade trocas no 2.1/4-Opt aproximado
300000
y = 25368x - 2354,1
R² = 0,9976
Tempo 2.1/4-Opt aproximado 225000

150 150000
y = 1,7278x2 - 9,8544x + 14,61
75000
R² = 0,9848
113 0
pla85900 rl2-515400 rl2-944900

2.1/4-Opt trocas Tendência 1

75
Tempo “2.1/4-exchange”
5,0E-04 y = 4,631E-6x2 - 1,768E-5x + 6,255E-5
R² = 0,9852
38 3,8E-04

2,5E-04

0 1,3E-04
pla85900 rl2-515400 rl2-944900
0E+00
pla85900 rl2-515400 rl2-944900
2.1/4-Opt (s) Tendência 1
Tempo/Troca (s) Tendência 1
 Quantidade trocas na busca local
300000

Tempo busca local aproximada 225000

150 150000

75000

113 0
pla85900 rl2-515400 rl2-944900

2-Opt trocas 2.1/4-Opt trocas

75
Tempo/Troca
5,0E-04

38 3,8E-04

2,5E-04

0 1,3E-04
pla85900 rl2-515400 rl2-944900
0E+00
pla85900 rl2-515400 rl2-944900
2-Opt (s) 2.1/4-Opt (s)
2-exchange (s) 2.1/4-exchange (s)
 Avaliação
2-Opt “real” ganhou do aproximado em
2 das 3 instâncias que executou

Mas demora muito mais (> 380.000x)

No 2-Opt aproximado: considerar mais

vizinhos depois de encontrar um que
melhora, não resultou em um caminho
final melhor em grande parte dos
casos
 Avaliação

Representação do tour por array

simples custou ~25% do tempo para
inversões e “slides” no pla85900

Sugestões:

satellite list

two-level tree

movimento 2.1/4
 GRASP
kdtree-grasp(n)
seja M [1 . . n] um novo array
menor -custo = ∞
while condições de parada não satisfeitas
GT = kdtree-semigreedy-tour(random(n))
T, custo = kdtree-2opt(GT )
if custo < menor -custo
menor -custo = custo
M =T
return (M, menor -custo)
 GRASP
Estratégia

Aplicar algoritmos melhorados

discutidos anteriormente

KDTREE-NEAREST é modificada para

coletar vizinhos que encontrar
“KNN”
durante a busca ao mais próximo
 GRASP
Parâmetros
Número máximo de execuções: N2

Interrompe se não diminuir custo

em 5000 iterações

Tamanho máximo RCL: sorteio [1, 3]

Seleção: bias log

 GRASP
RCL
Heap máximo

Fácil de trocar o elemento atual

mais custoso por um novo menos
custoso (apesar de atualmente a RCL ser bem pequena)

Ranking pela função bias é feito

de trás para frente
 GRASP
RCL - Observação
Heap máximo:

Inserir <9 8 3 4 1 7 5 2 11>

11 9 8 5 3 7 4 2 1

Elementos não necessariamente

decrescem à direita (contribui para a
aleatoriedade no GRASP?)
 GRASP
Resultados
KG+2.1/4 GRASP* Prox.
T (s) Custo T (s) Execs. Custo ~
vm1084 0,00 254.355 >> 16.207 249.164 4,12%
d2103 0,00 82.402 >> 7.260 87.860 =
d15112 0,07 1.666.102 >> 6.451 1.668.978 =
d18512 0,09 680.798 >> 10.014 685.330 =
pla33810 0,24 70.744.397 >> 11.903 71.776.398 =
pla85900 0,70 150.777.638 >>> 7.445 152.935.500 =

Pior que Greedy-NN

* Resultado utilizando família de funções rand48; seed fixado em 0

 Avaliação

Conseguiu melhorar apenas a menor

dessas instâncias

Pior que Greedy puro no problema

d2103

Para instâncias um pouco maiores,

GRASP com k-d tree não parece ser uma
boa escolha*

* Considerando todas as escolhas implementadas nessa k-d tree

e nesse GRASP
 Avaliação

Em instâncias menores da TSPLIB (não

exibidas até aqui), GRASP demonstrou bons

resultados:

a280, att48, ch130: < 1% para ótimo

berlin52, dantzig42, eil101,

eil51, fri26, kroA100, kroC100,
rat99, st70: ótimo
 Resultados finais
Instância Custo Distância Instância Custo Distância

a280 2.599 0,77% kroA100 21.282 0,00%

berlin52 7.542 0,00% kroC100 20.749 0,00%

ch130 6.117 0,11% pla33810 70.774.397 7,11%

d15112 1.666.102 5,91% pla85900 150.777.638 5,90%

d18512 680.798 5,51% rat575 7.035 3,86%

d2103 82.402 2,42% rat99 1.211 0,00%

dantzig42 699 0,00% st70 675 0,00%

eil101 629 0,00%

GRASP
eil51 426 0,00%
KG+2.1/4
fri26 937 0,00%
 Bibliografia
K-d tree

Multidimensional binary search

Bentley, J. L. (1975).

trees used for associative searching. Commun.

ACM, 18(9):509–517.

Bentley, J. L. (1990). K-d trees for semidynamic

point sets. In SCG ’90: Proceedings of the sixth annual symposium
on Computational geometry, pages 187–197, New York, NY, USA. ACM.

Fast algorithms for geometric

Bentley, J. J. (1992).

traveling salesman problems. ORSA Journal on Computing,

4(4):387–411.

An
Friedman, J. H., Bentley, J. L., and Finkel, R. A. (1977).

algorithm for finding best matches in

logarithmic expected time. ACM Trans. Math. Softw., 3
(3):209–226.
 Bibliografia

Heuristic-based
Bresina, J. L. (1996).

stochastic sampling. In Proceedings of the

AAAI- 96, pages 271–278.

Mateus, G. R., Resnde, M. G. C., and Silva, R. M. A. (2009).

Grasp: Procedimentos de busca

gulosos, aleatórios, e adaptativos.
Technical report, AT&T Labs Research.

Sedgewick, R. (1990). Algorithms in C. Addison-

Wesley Professional.
Extras