for i in range(N):
for j in range(N):
dist[i][j] = dist[j][i] = distance(cities[i], cities[j])
path = [i for i in range(N)]
while True:
count = 0
for i in range(N - 2):
i1 = i + 1
for j in range(i + 2, N):
if j == N - 1:
j1 = 0
else:
j1 = j + 1
if i != 0 or j1 != 0:
l1 = dist[path[i]][path[i1]]
l2 = dist[path[j]][path[j1]]
l3 = dist[path[i]][path[j]]
l4 = dist[path[i1]][path[j1]]
if l1 + l2 > l3 + l4:
# つなぎかえる
new_path = path[i1:j+1]
path[i1:j+1] = new_path[::-1]
count += 1
if count == 0: break
return path
if __name__ == '__main__':
assert len(sys.argv) > 1
solution = opt_2(read_input(sys.argv[1]))
print_solution(solution)
}
solutionCity = []
solution = []
for city in cities:
tan = gTan(G, city)
dist = distance(G, city)
area[getArea(G, city, tan, dist)].append(city)
for x in goOut:
areaGreedy[x].extend(goGreedy(area[x]))
for x in goIn:
areaGreedy[x].extend(goGreedy(area[x]))
for i in order:
solutionCity = mergeArea(solutionCity, areaGreedy[i])
for city in solutionCity:
solution.append(cities.index(city))
# for n in order :
# for j in areaGreedy[n] :
# solution.append(cities.index(j))
return solution
if __name__ == '__main__':
assert len(sys.argv) > 1
solution = solve(read_input(sys.argv[1]))
print_solution(solution)
while True:
if t <= Tend:
break
#set the initial temp
for rt2 in range(int(len(cities) * 3)):
newroute = getnewroute(route, rt2, n_len)
new_total_dis = cacl_best(newroute, n_len, distence)
delt = new_total_dis - total_dis
if delt <= 0:
route = newroute
total_dis = new_total_dis
if best_total_dis > new_total_dis:
best = newroute
best_total_dis = new_total_dis
elif delt > 0:
p = math.exp(-delt / t)
ranp = random.uniform(0, 1)
if ranp < p:
route = newroute
total_dis = new_total_dis
t = t * a
return best
if __name__ == "__main__":
assert len(sys.argv) > 1
cities = read_input(sys.argv[1])
result = solve(cities)
print_solution(result)
table[(1 << size1) - 1] = [(distance_table[i][0], 0) for i in xrange(1, size)]
for v in xrange((1 << size1) - 2, 0, -1):
tmp = [1e300] * size1
for i in xrange(size1):
if (1 << i) & v:
tmp[i] = min0([(distance_table[i+1][j+1] + table[v | (1 << j)][j][0], j) \
for j in xrange(size1) if not (1 << j) & v])
table[v] = tmp
s = min0([(distance_table[i+1][0] + table[1 << i][i][0], i) for i in xrange(size1)])
return s[0], get_min_path(table, size, s[1])
def get_min_path(table, size, p):
path = [0, p + 1]
v = 1 << p
while len(path) < size:
_, q = table[v][p]
path.append(q + 1)
v |= (1 << q)
p = q
return path
point_table = read_input(sys.argv[1])
point_size = len(point_table)
distance_table = distance(point_table)
min_len, min_path = tsp_dp1(point_size)
#min_len = tsp_dp(point_size)
#min_path = []
print min_len
print_solution(min_path)
path_length = 0
for i in range(0, N):
path_length += distance(cities[order_list[i]],
cities[order_list[i + 1]])
path_length += distance(cities[order_list[N]], cities[0])
return path_length
def list_all_orders_without_zero(N): #start:0, goal:0
all_cities = range(1, N)
all_orders_without_zero = list(itertools.permutations(all_cities))
return all_orders_without_zero
if __name__ == '__main__':
assert len(sys.argv) > 1
all_orders_without_zero = list_all_orders_without_zero(N)
for order in all_orders_without_zero:
with_zero = [0] + list(order) + [0]
path_length = calculate_path_length(with_zero)
if (min > path_length):
min = path_length
best_solution = with_zero
best_solution.pop() #最後の0を削除
print("best solution is = {}, min path length = {}".format(
best_solution, min))
print_solution(best_solution)
def main():
solution = solve(read_input(sys.argv[1]))
print_solution(solution)
total = 0
while True:
count = 0
for i in range(datalen - 2):
i1 = i + 1
for j in range(i + 2, datalen):
if j == datalen - 1:
j1 = 0
else:
j1 = j + 1
if i != 0 or j1 != 0:
l1 = np.linalg.norm([data[root[i]] - data[root[i1]]])
l2 = np.linalg.norm([data[root[j]] - data[root[j1]]])
l3 = np.linalg.norm([data[root[i]] - data[root[j]]])
l4 = np.linalg.norm([data[root[i1]] - data[root[j1]]])
if l1 + l2 > l3 + l4:
new_root = root[i1:j+1]
root[i1:j+1] = new_root[::-1]
count += 1
total += count
if count == 0:
break
return root
if __name__ == '__main__':
assert len(sys.argv) > 1
data, datalen, root, ex_root = init_data(read_input(sys.argv[1]))
root = nearest_n(data, datalen, root, ex_root)
root = opt_2(data, datalen, root)
print_solution(root)
pass
else:
if key[0] not in idx_list:
idx_list += key
else:
if key[0] not in idx_list:
idx_list += key
for i in range(len(idx_list)):
for j in range(len(idx_list)):
if i==j:
pass
else:
N = len(idx_list)
try:
A, B, C, D = idx_list[i], idx_list[i+1], idx_list[j], idx_list[(j+1) % N]
if distance(all_store[A],all_store[B]) + distance(all_store[C],all_store[D])> distance(all_store[A],all_store[C]) + distance(all_store[B],all_store[D]):
idx_list[i+1:j+1] = reversed(idx_list[i+1:j+1])
except IndexError:
pass
#print(idx_list)
#print(len(idx_list))
#print([x for x in set(idx_list) if idx_list.count(x) > 1])
#print(sorted(idx_list))
#
print_solution(idx_list)
from vortex import vortex
from kruskal import kruskal_greedy
from my_random import random_solve
from combine import optimize2, read_path
if __name__ == '__main__':
assert len(sys.argv) > 1
optimize = optimize(read_input(sys.argv[1]))
optimize2 = optimize2(read_input(sys.argv[1]), read_path(sys.argv[2]))
greedy = greedy(read_input(sys.argv[1]))
opt_2 = opt_2(read_input(sys.argv[1]))
or_opt = or_opt(read_input(sys.argv[1]))
vortex = vortex(read_input(sys.argv[1]))
kruskal = kruskal_greedy(read_input(sys.argv[1]))
print_solution(or_opt)
print_solution(or_opt)
print_solution(vortex)
print_solution(kruskal)
print_solution(greedy)
print_solution(greedy)
print_solution(optimize)
print_solution(optimize)
print_solution(optimize)
print_solution(optimize)
print_solution(optimize2)
print_solution(optimize2)
print_solution(optimize2)
print_solution(optimize2)
print_solution(optimize2)
print_solution(optimize2)
