def search(points, neighborhoods, maxNoImprove, maxNoImproveLocalSearch):
t_end = time.time() + 60
# First construct the initial solution. We use a random permutation as the initial solution
best = {}
best["permutation"] = constructInitialSolution(points)
best["cost"] = tourCost(best["permutation"])
noImproveCount = 0
while noImproveCount <= maxNoImprove and time.time() < t_end:
candidate = {}
candidate["permutation"] = best["permutation"]
# for each neighborhood in neighborhoods
for neighborhood in neighborhoods:
#Calculate Neighborhood : Involves running stochastic two opt for neighbor times
for index in range(0, neighborhood):
# Get candidate solution from neighborhood
candidate["permutation"] = stochasticTwoOpt(
candidate["permutation"])
# Calculate the cost of the final neighborhood
candidate["cost"] = tourCost(candidate["permutation"])
# Refine candidate solution using local search and neighborhood
candidate = localSearch(candidate, maxNoImproveLocalSearch,
neighborhood)
#if the cost of the candidate is lesser than cost of current best then replace
#best with current candidate
if candidate["cost"] < best["cost"]:
best, noImproveCount = candidate, 0 # We also restart the search when we find the local optima
# break: this breaks out of the neighborhoods iteration
break
else: # increment the count as we did not find a local optima
noImproveCount += 1
return best
def searchIteration(points,neighborhoods, maxNoImprove, maxNoImproveLocalSearch, timeLimit):
t_end = time.time() + timeLimit
best_list = []
# Permutação aleatória é usada para a construção da solução inicial.
best ={}
best["permutation"] = constructInitialSolution(points)
best["cost"] = tourCost(best["permutation"])
noImproveCount =0
while noImproveCount<=maxNoImprove and time.time() < t_end:
candidate ={}
candidate["permutation"] = best["permutation"]
# Para cada vizinhança em vizinhanças.
for neighborhood in neighborhoods:
# Calcular vizinhança: Envolve executar duas opções estocásticas por quantidade de vizinhanças.
for index in range(0,neighborhood):
# Obter solução canditada de vizinhança.
candidate["permutation"] = stochasticTwoOpt(candidate["permutation"])
# Calcular o custo da vizinhança final.
candidate["cost"] = tourCost(candidate["permutation"])
# Refinar a solução candidata final usando a busca local e a vizinhança.
candidate = localSearch(candidate,maxNoImproveLocalSearch, neighborhood, t_end)
# Se o custo da candidata é menor que o custo da melhor solução atual, então substitua a melhor pela candidata.
if candidate["cost"] < best["cost"]:
best, noImproveCount = candidate, 0 # Quando um ótimo local é encontrado a busca é reiniciada.
best_list.append(best["cost"])
# Interrupção da iteração das vizinhanças.
break
else: # Incremento do contador para informar que um ótimo local não foi encontrado.
best_list.append(best["cost"])
noImproveCount +=1
return best_list
def search(points, maxIterations, maxTabu, maxCandidates):
t_end = time.time() + 60
# construct a random tour
best = {}
best["permutation"] = constructInitialSolution(points)
best["cost"] = tourCost(best["permutation"])
tabuList = []
while maxIterations > 0 and time.time() < t_end:
# Generate candidates using stocahstic 2-opt near current best candidate
# Use Tabu list to not revisit previous rewired edges
candidates = []
for index in range(0, maxCandidates):
candidates.append(generateCandidates(best, tabuList, points))
# Locate the best candidate
# sort the list of candidates by cost
# since it is an involved sort, we write a function for getting the least cost candidate
bestCandidate, bestCandidateEdges = locateBestCandidate(candidates)
# compare with current best and update if necessary
if bestCandidate["cost"] < best["cost"]:
# set current to the best, so thatwe can continue iteration
best = bestCandidate
# update tabu list
for edge in bestCandidateEdges:
if len(tabuList) < maxTabu:
tabuList.append(edge)
maxIterations -= 1
return best
def searchIteration(points, maxIterations, maxTabu, maxCandidates, timeLimit):
t_end = time.time() + timeLimit
best_list = []
# constrói a solução inical
best = {}
best["permutation"] = constructInitialSolution(points)
best["cost"] = tourCost(best["permutation"])
tabuList = []
while maxIterations > 0 and time.time() < t_end:
# Gera candicdatos usando o algoritmo 2-opt de busca local
# estocásticamente, perto do melhor candidato dessa iteração.
# Usa a lista tabu para não visitar vértices mais de uma vez
candidates = []
for index in range(0, maxCandidates):
candidates.append(generateCandidates(best, tabuList, points,
t_end))
# Procura o melhor candidasto
# ordena a lista de cnadicados pelo custo
bestCandidate, bestCandidateEdges = locateBestCandidate(candidates)
# compara com o melhor candidato e o atualiza se necessário
if bestCandidate["cost"] < best["cost"]:
# define o candidato atual como melhor
best = bestCandidate
# atuliza a lista tabu
for edge in bestCandidateEdges:
if len(tabuList) < maxTabu:
tabuList.append(edge)
maxIterations -= 1
best_list.append(best["cost"])
return best_list
def generateCandidates(best, tabuList, points):
permutation, edges, result = None, None, {}
while permutation == None or isTabu(best["permutation"], tabuList):
permutation, edges = stochasticTwoOptWithEdges(best["permutation"])
candidate = {}
candidate["permutation"] = permutation
candidate["cost"] = tourCost(candidate["permutation"])
result["candidate"] = candidate
result["edges"] = edges
return result
def localSearch(best, maxIter, timeLimit):
count = 0
while count < maxIter and time.time() < timeLimit:
candidate = {}
candidate["permutation"] = stochasticTwoOpt(best["permutation"])
candidate["cost"] = tourCost(candidate["permutation"])
if candidate["cost"] < best["cost"]:
best, count = candidate, 0
else:
count += 1
return best
def localSearch(best, maxIter, neighborhood, timeLimit):
count =0
while count < maxIter and time.time() < timeLimit:
candidate ={}
candidate["permutation"]=best["permutation"]
for index in range(0,neighborhood):# Envolve executar duas opções estocásticas por quantidade de vizinhos.
# Obter a solução candidata de vizinhança.
candidate["permutation"] = stochasticTwoOpt(candidate["permutation"])
candidate["cost"] = tourCost(candidate["permutation"])
if candidate["cost"] < best["cost"]:# A busca é reiniciada quando um ótimo local é encontrado.
best,count = candidate, 0
else:
count +=1
return best
def localSearch(best, maxIter, neighborhood):
count = 0
while count < maxIter:
candidate = {}
candidate["permutation"] = best["permutation"]
for index in range(
0, neighborhood
): #Involves running stochastic two opt for neighbor times
# Get candidate solution from neighborhood
candidate["permutation"] = stochasticTwoOpt(
candidate["permutation"])
candidate["cost"] = tourCost(candidate["permutation"])
if candidate["cost"] < best[
"cost"]: # We also restart the search when we find the local optima
best, count = candidate, 0
else:
count += 1
return best
def constructGreedySolution(perm, alpha):
candidate = {}
# Seleciona um ponto da lista aleatoriamente
problemSize = len(perm)
candidate["permutation"] = [perm[random.randrange(0, problemSize)]]
# Enquanto o tamanho do candidato não for igual ao tamanho da permutação
while len(candidate["permutation"]) < problemSize:
# Pega todos os pontos, exceto os já presentes na solução candidata
candidates = [
item for item in perm if item not in candidate["permutation"]
]
# Calcula o custo de adicionar uma característica à solução
# A 'feature' ou característica é definida por quão longe os outros pontos estão do último elemento da lista de candidatos
costs = []
candidateSize = len(candidate["permutation"])
for item in candidates:
costs.append(
euclideanDistance(candidate["permutation"][candidateSize - 1],
item))
# Determina o menor e o maior custo do determinado set
rcl, maxCost, minCost = [], max(costs), min(costs)
# Construimos o RCL da seguinte maneira:
# Adicionamos o que for menor ou igual ao mínimo + o custo da característica pela fórmula da RCL
# Quanto menor a distância aqui, menor o custo final do algoritmo
# Custo de cada Feature:
for index, cost in enumerate(
costs): # Para conseguir o index e o item enquanto faz o loop
# IF Fcurrent <= Fmin + alpha * (Fmax-Fmin) THEN
if (cost <= minCost + alpha * (maxCost - minCost)):
# Adiciona ao RCL
rcl.append(candidates[index])
# Seleciona feature aleatório do RCL e adiciona à solução
candidate["permutation"].append(rcl[random.randrange(0, len(rcl))])
# Calcula o custo final antes de retornar a solução candidata
candidate["cost"] = tourCost(candidate["permutation"])
return candidate
