Projeto de Programação PD-I

Apresentação em tema: "Projeto de Programação PD-I"— Transcrição da apresentação:

1 Projeto de Programação PD-I
Caxeiro Viajante Felipe Costa Corona Lucas Catabriga Rocha

2 Problema: Dado um número de cidades e o custo para ir de uma cidade qualquer para outra cidade qualquer, qual a rota com menor custo que visita todas as cidades exatamente uma vez e retorna ao ponto de partida?

3 O problema do caxeiro viajante é um problema NP-completo
O problema do caxeiro viajante é um problema NP-completo. Neste tipo de problema é fácil verificar uma solução para o problema, mas demorado para achar a solução do problema. Não existe na atualidade um algoritmo capaz de resolver este tipo de problema de forma eficiente. A maioria dos pesquisadores acreditam que uma solução eficiente não exista e que a única maneira de resolver o problema com certeza seja simplesmente testar todas as possibilidades.

4 O programa deve ser capaz de resolver o problema usando força bruta, que é testar todas as possibilidades. Como este método é apenas funcional para um número pequeno de cidades, deve também resolver o problema usando heurística, isto é, um algoritmo que da uma resposta rapidamente, porém sem garantias de que será a melhor resposta ou até mesmo uma boa resposta.

5 Para testar o programa será usada uma lista de cidades com tamanho arbitrário, para se testar até que número de cidades uma solução é eficiente, e algumas listas de cidades em que se conhece a melhor solução de vários tamanhos diferentes. Os resultados e custo computacional de cada algoritmo será comparado com os outros algoritmos para avaliar sua eficiência.

6 Força Bruta Neste método serão testados todos os caminhos possíveis, e se escolherá o melhor. Deve-se gerar todas as permutações possíveis, calcular a distância de cada um desses caminhos e escolher o menor. Uma função gera todas as permutações, quando as permutações são terminadas, calcula a distância de todos os caminhos e ordena a lista de caminhos baseado na distancia. Pega o caminho com a menor distância.

7 permut10 ls cs n listaP = if (length (fst (cs!!0)) < n) then permut10 ls [ (fst x ++ [y], delete y (snd x)) | x<-cs, y<-(snd x) ] n listaP else [ (distCaminho10 ls (caminho x) listaP, caminho x) | x<-cs, (fst x)!!1 last (fst x) ] where caminho x = fst x ++ ([head (fst x)]) distCaminho10 ls cs listaP = sum [((listaP)!!((cs!!(x))))!!((cs!!(x+1)))|x<-[0..((length cs)-2)]] caminhosPossiveis10 ls = sort (permut10 ls [([0],[1..((length ls)-1)])] (length ls) listaP10) listaP10 = [[distC (ls!!x) (ls!!y)|y<[0..((length ls)-1)]]|x<-[0..((length ls)-1)]] menorCaminho10 ls = head (caminhosPossiveis10 ls)

8 Algoritmo do vizinho mais próximo
Neste algoritmo, o caxeiro visita sempre a cidade mais próxima que ainda não visitou. Retorna um resultado muito mais rápido que o algoritmo de força bruta e na maioria das vezes tem um resultado razoável. Apesar disso, existem casos em que este algoritmo retorna o pior resultado possível ou simplesmente retorna respostas ruins.

9 cidadeProxima11 c ls fs listaP = snd (head (sort [(((listaP. c)
cidadeProxima11 c ls fs listaP = snd (head (sort [(((listaP!!c)!!x),x)|x<-fs])) listaCaminho11 ls cs fs n listaP = if(length cs == 0) then listaCaminho11 ls [n] (delete (n) fs) n listaP else if(length fs >0) then listaCaminho11 ls (cs ++ [cidadeProxima]) (delete (cidadeProxima) fs) n listaP else cs where cidadeProxima = cidadeProxima11 (last cs) ls fs listaP distCaminho11 ls cs listaP = sum [((listaP)!!((cs!!(x))))!!((cs!!(x+1)))|x<-[0..((length cs)-2)]] caminho11 ls n = (distCaminho11 ls (menorCaminho) listaP11, menorCaminho) listaP11 = [[distC (ls!!x) (ls!!y)|y<-[0..((length ls)-1)]]|x<-[0..((length ls)-1)]] listaCaminho = listaCaminho11 ls [] [0..((length ls)-1)] n listaP11 menorCaminho = (listaCaminho) ++ [head (listaCaminho)] menorCaminho11 ls = caminho11 ls 0

10 Algorimo de caminho sem cruzamentos
Se acontecerem cruzamentos em um caminho, sempre que estes cruzamentos forem retirados, o caminho resultante será mais curto. Este algoritmo gera um caminho quase sempre sem cruzamentos acrescentando as cidades sempre na posição do caminho em que o custo será menor. O algoritmo pode ser melhorado, com um custo relativamente alto, para checar se no caminho final algumas cidades podem mudar de posição dentro da lista melhorando a eficiência ou até mesmo checar isto depois que cada cidade é acrescentada.

11 acrescimoDist7 ls c cs = [ ((newDist x) - (oldDist x), x)| x<-[0
acrescimoDist7 ls c cs = [ ((newDist x) - (oldDist x), x)| x<-[0..((length cs)-2)] ] where newDist x = (distC (ls!!(cs!!x)) (ls!!c)) + (distC (ls!!(cs!!(x+1))) (ls!!c)) oldDist x = (distC (ls!!(cs!!x)) (ls!!(cs!!(x+1)))) menorAcrescimo7 ls c cs = head (sort (acrescimoDist7 ls c cs)) adicionarCidade7 ls c cs = (take (x+1) cs) ++ [c] ++ (drop (x+1) cs) x = snd (menorAcrescimo7 ls c cs) criarCaminho7 ls es cs = if((length es)==1) then adicionarCidade7 ls (head es) cs else criarCaminho7 ls (tail es) (adicionarCidade7 ls (head es) cs) distCaminho7 ls cs = sum [distC (ls!!(cs!!(x))) (ls!!(cs!!(x+1)))|x<-[0..((length cs)-2)]] menorCaminho7 ls = ( distCaminho7 ls caminho,caminho) caminho = criarCaminho7 ls [2..((length ls)-1)] [0,1,0]

12 Testes 5 7 9 10 Número Cidades Força Bruta 521.5018 525.9532 553.8046
Vizinho Cruzamento Cruzamento melhorado

13 Vizinho Melhor Cruzamento

14 1177.989 - (5798874 reductions, 7541514 cells, 1 garbage collection)
50 cidades ( reductions, cells, 1 garbage collection) ( reductions, cells, 6 garbage collections) ( reductions, cells, 41 garbage collections) ( reductions, cells)

15 250 cidades ( reductions, cells, 1007 garbage collections) ( reductions, cells, 61 garbage collections) ( reductions, cells, 120 garbage collections) ( secs, bytes)

16 1500 cidades ( secs, bytes) ( secs, bytes) ( secs, bytes)

17 Trajetos que se conhece o melhor caminho
Cidades na África, 29 cidades, melhor caminho 27603: Vizinho: ( reductions, cells) Cruzamento: ( reductions, cells) Cruzamento +: ( reductions, cells, 1 garbage collection) Cruzamento ++: ( reductions, cells, 5 garbage collections)

18 Cidades Djibouti, 89 cidades, melhor caminho 6656:
Vizinho: ( reductions, cells, 2 garbage collections) Cruzamento: ( reductions, cells, 5 garbage collections) Cruzamento +: ( reductions, cells, 19 garbage collections) Cruzamento ++: ( reductions, cells, 593 garbage collections)

19 Cidades Luxemburgo, 980 cidades, melhor caminho 11340:
Cidades Qatar, 194 cidades, melhor caminho 9352: Vizinho: Cruzamento: Cruzamento +: Cruzamento ++: Cidades Luxemburgo, 980 cidades, melhor caminho 11340: Vizinho: Cruzamento: Cruzamento +: