帮我看一下我的代码对吗
def swap(permutation, i, j):
"""
Return a new permutation where the elements at indices i and j are swapped.
Parameters:
permutation (list or np.ndarray): Current assignment.
i, j (int): Indices to swap.
Returns:
(list or np.ndarray): New permutation with i and j exchanged.
"""
# create a copy or modify in place to swap positions i and j
new_permutation=permutation
new_permutation[i]=permutation[j]
new_permutation[j]=permutation[i]
return new_permutation
def delta_i_j(permutation, i, j, weights, distance):
"""
Compute the change in objective value if we swap facilities i and j.
Parameters:
permutation (list or np.ndarray): Current assignment.
i, j (int): Indices of facilities to swap.
weights (np.ndarray): Flow matrix.
distance (np.ndarray): Distance matrix.
Returns:
float: Change in cost after swapping i and j.
"""
# compute the fitness difference directly or with the O(n) delta formula
old_cost=fitness(permutation,weights,distance)
new_permutation=swap(permutation,i,j)
new_cost=fitness(new_permutation,weights,distance)
return new_cost-old_cost
def best_swap(weights, distance, permutation, current_fitness, best_fitness, tabu_matrix, itr):
"""
Identify the best neighbor of the current solution
while respecting Tabu Search rules.
Parameters:
weights (np.ndarray) : Flow matrix of the QAP.
distance (np.ndarray) : Distance matrix of the QAP.
permutation (list or np.ndarray) : Current assignment of facilities to locations.
current_fitness (float) : Cost of the current solution.
best_fitness (float) : Best cost found so far (global best).
tabu_matrix (np.ndarray) : Matrix that stores, for each possible swap, the iteration number until which it is tabu.
itr (int) : Current iteration index.
Returns:
i, j (int): Indices of the selected swap.
delta (float): Change in cost for the swap.
is_best (bool): True if this move improves the global best solution.
"""
# iterate over all pairs (i, j)
# compute delta for each swap
# skip tabu moves unless aspiration criterion is met
# keep track of the best candidate
n=len(permutation)
best_delta=float('inf')
best_i, best_j = 0, 0
is_best=False
for i in range(n):
for j in range(i+1,n):
if tabu_matrix[i][j]<itr:
if current_fitness+delta_i_j(permutation,i,j,weights,distance)<best_fitness:
new_permutation=swap(permutation,i,j)
delta=delta_i_j(permutation,i,j,weights,distance)
return i,j,delta,True
else:
delta=delta_i_j(permutation,i,j,weights,distance)
if delta<best_delta:
best_delta=delta
best_i, best_j=i,j
return best_i,best_j,best_delta,is_best
def tabu_search(weights, distance, tabu_tenure, tmax, diversification, u):
"""
Main Tabu Search routine.
Parameters:
weights (np.ndarray): Flow between locations.
distance (np.ndarray): Distance between locations.
tabu_tenure (int): Number of iterations a move remains tabu.
tmax (int): Total number of iterations.
diversification (bool): Enable diversification strategy.
u (int): Number of iterations after which diversification triggers.
Returns:
best_fitness (float): Best objective value found.
best_permutation (list or np.ndarray): Best assignment found.
fitness_history (list): Cost of each visited solution.
best_history (list): Best cost at each iteration.
"""
# initialize permutation and tabu matrix
# initialize diversification structures if enabled
# repeat for tmax iterations:
# choose move (best swap or diversification)
# apply move and update current fitness
# update best solution if improved
# update tabu matrix
# update diversification bookkeeping if enabled
# initialize permutation and tabu matrix
n = len(weights)
permutation = np.random.permutation(n)
# 计算当前适应度
current_fitness = fitness(permutation,weights,distance)
# 初始化最佳适应度
best_fitness = current_fitness
# 初始化最佳排列
best_permutation = permutation.copy()
# 初始化禁忌矩阵
tabu_matrix = np.zeros((n, n), dtype=int)
for itr in range(tmax):
# 找到最佳交换
i, j, delta, is_best = best_swap(weights, distance, permutation, current_fitness, best_fitness, tabu_matrix, itr)
# 更新排列
permutation = swap(permutation, i, j)
# 更新当前适应度
current_fitness += delta
# 更新禁忌矩阵
tabu_matrix[i][j] = itr + tabu_tenure
tabu_matrix[j][i] = itr + tabu_tenure
# 更新最佳适应度和最佳排列
if is_best:
best_fitness = current_fitness
best_permutation = permutation.copy()
# 多样化策略
if diversification and itr % u == 0:
np.random.shuffle(permutation)
current_fitness = fitness(permutation,weights, distance )
return best_permutation, best_fitness,
# return final best solution and histories
# ------------------------------------------------
# Diversification:
# implement a mechanism that forces rarely-used
# swaps to be tried after u iterations
# ------------------------------------------------
最新发布
本文介绍了一个通过编程解决特定数学问题的方法：利用1到9这9个数字组成三个比例为1:2:3的三位数，并确保每个数字仅被使用一次。通过遍历可能的组合并检查它们是否满足条件来找出所有可能的解决方案。
扫一扫
156
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
