def main():
#initialize random inputs:
generate_test_set(n1, 1000)
# this will plot route_length vs. N &
# timing vs. N for each algorithm listed
# (using the default range+seed declared up in the global variable)
#batch_compare_algos(algo_combo1,algo_combo2)
# this will plot the resultant route from each algorithm for
# a given city set size (using the default seed)
#compare_algos(15,[algo_combo1,algo_combo1])
#cities1 = return_set(5)
cities1 = parse_input("in/example-input-1.txt")
route = algo_greedy(cities1)
print is_valid(cities1, route)
route = [0, 0, 1, 2, 3]
print is_valid(cities1, route)
#format_output(cities1, route, "out.txt")
#run_verifier("in/example-input-1.txt","out.txt")
#print route_length(cities1, route)
#tsp_grapher.plot_route(cities1,route)
'''
def main():
#initialize random inputs:
generate_test_set(n1,1000)
# this will plot route_length vs. N &
# timing vs. N for each algorithm listed
# (using the default range+seed declared up in the global variable)
#batch_compare_algos(algo_combo1,algo_combo2)
# this will plot the resultant route from each algorithm for
# a given city set size (using the default seed)
#compare_algos(15,[algo_combo1,algo_combo1])
#cities1 = return_set(5)
cities1 = parse_input("in/example-input-1.txt")
route = algo_greedy(cities1)
print is_valid(cities1,route)
route = [0,0,1,2,3]
print is_valid(cities1,route)
#format_output(cities1, route, "out.txt")
#run_verifier("in/example-input-1.txt","out.txt")
#print route_length(cities1, route)
#tsp_grapher.plot_route(cities1,route)
'''
def algo_combo1(cities): route = algo_greedy(cities) for i in xrange(2,len(cities)): route = algo_improve_rev(cities,route,i) for i in xrange(len(cities),2,-1): route = algo_improve_rev(cities,route,i) for i in xrange(2,len(cities)): route = algo_improve_rev(cities,route,i) return route
def algo_combo1(cities):
route = algo_greedy(cities)
for i in xrange(2, len(cities)):
route = algo_improve_rev(cities, route, i)
for i in xrange(len(cities), 2, -1):
route = algo_improve_rev(cities, route, i)
for i in xrange(2, len(cities)):
route = algo_improve_rev(cities, route, i)
return route
def algo_greedy_segmented(cities):
#how many divisions should we use??
#the success of this algorithm is largely dependent on these values,
#but i have no clue how to pick the proper
#number of divions for an input
grid_div_x = 30
grid_div_y = 30
villages = [[[] for i in xrange(grid_div_y)] for i in xrange(grid_div_x)]
village_routes = []
village_centers = []
x_min = min(cities, key=itemgetter(0))[0]
y_min = min(cities, key=itemgetter(1))[1]
x_max = max(cities, key=itemgetter(0))[0]
y_max = max(cities, key=itemgetter(1))[1]
for x in xrange(0, len(cities)):
for i in xrange(grid_div_x):
for j in xrange(grid_div_y):
if cities[x][0] >= (float(i) /
grid_div_x) * x_max and cities[x][0] <= (
(float(i) + 1) / grid_div_x) * x_max:
if cities[x][1] >= (float(
j) / grid_div_y) * y_max and cities[x][1] <= (
(float(j) + 1) / grid_div_y) * y_max:
villages[i][j].append(cities[x])
#unwrap nested array
villages = list(itertools.chain(*villages))
for v in villages:
#get approximate center of village
if (len(v) > 0):
x_center = 0.0
y_center = 0.0
for i in v:
x_center += i[0]
y_center += i[1]
x_center = x_center / len(v)
y_center = y_center / len(v)
village_centers.append((x_center, y_center))
# run greedy on village
temp = algo_greedy(v)
# convert village index back to city index
village_route = []
for idx in xrange(len(temp)):
village_route.append(cities.index(v[temp[idx]]))
village_routes.append(village_route)
'''
# this is waaaay too slow
# recombine subroutes into every possible complete route
all_permutations = list(itertools.permutations(village_routes))
all_p = []
for p in all_permutations:
all_p.append( list(itertools.chain.from_iterable(p)) )
# compare all these possible complete routes
shortest_route_dist = sys.maxint
best_route = []
for p in all_p:
test_length = route_length(cities,p)
if (test_length < shortest_route_dist):
shortest_route_dist = test_length
best_route = p
return best_route
'''
shortest_route_dist = sys.maxint
ret = []
#print village_routes
# we need to recombine these sub routes in a smarter way(by avg location perhaps?)
#ret = list(itertools.chain(*village_routes))
# run greedy on village centers
temp = algo_greedy(village_centers)
for i in temp:
tmp = village_routes[i]
ret.append(tmp)
ret2 = list(itertools.chain(*ret))
default_distance = route_length(cities, ret2)
for idx1 in xrange(len(temp)):
for i in range(0, len(ret[idx1])):
for j in range(2):
revert = ret[idx1]
ret[idx1] = ret[idx1][i:] + ret[idx1][:i]
if (j == 1): ret[idx1].reverse()
ret3 = list(itertools.chain(*ret))
new_distance = route_length(cities, ret3)
if new_distance > default_distance:
ret[idx1] = revert
ret4 = list(itertools.chain(*ret))
return ret4
def algo_combo2(cities): route = algo_greedy(cities) for i in xrange(2,4): route = algo_improve_rev(cities,route,i) route = algo_improve_swap(cities,route) return route
def algo_combo2(cities):
route = algo_greedy(cities)
for i in xrange(2, 4):
route = algo_improve_rev(cities, route, i)
route = algo_improve_swap(cities, route)
return route
def algo_greedy_segmented(cities):
#how many divisions should we use??
#the success of this algorithm is largely dependent on these values,
#but i have no clue how to pick the proper
#number of divions for an input
grid_div_x = 30
grid_div_y = 30
villages = [[[] for i in xrange(grid_div_y)] for i in xrange(grid_div_x)]
village_routes = []
village_centers = []
x_min = min(cities,key=itemgetter(0))[0]
y_min = min(cities,key=itemgetter(1))[1]
x_max = max(cities,key=itemgetter(0))[0]
y_max = max(cities,key=itemgetter(1))[1]
for x in xrange(0, len(cities)):
for i in xrange(grid_div_x):
for j in xrange(grid_div_y):
if cities[x][0] >= (float(i)/grid_div_x)*x_max and cities[x][0] <= ((float(i)+1)/grid_div_x)*x_max:
if cities[x][1] >= (float(j)/grid_div_y)*y_max and cities[x][1] <= ((float(j)+1)/grid_div_y)*y_max:
villages[i][j].append(cities[x])
#unwrap nested array
villages = list(itertools.chain(*villages))
for v in villages:
#get approximate center of village
if (len(v) > 0):
x_center = 0.0
y_center = 0.0
for i in v:
x_center += i[0]
y_center += i[1]
x_center = x_center/len(v)
y_center = y_center/len(v)
village_centers.append( (x_center,y_center) )
# run greedy on village
temp = algo_greedy(v)
# convert village index back to city index
village_route = []
for idx in xrange(len(temp)):
village_route.append( cities.index( v[temp[idx]] ))
village_routes.append(village_route)
'''
# this is waaaay too slow
# recombine subroutes into every possible complete route
all_permutations = list(itertools.permutations(village_routes))
all_p = []
for p in all_permutations:
all_p.append( list(itertools.chain.from_iterable(p)) )
# compare all these possible complete routes
shortest_route_dist = sys.maxint
best_route = []
for p in all_p:
test_length = route_length(cities,p)
if (test_length < shortest_route_dist):
shortest_route_dist = test_length
best_route = p
return best_route
'''
shortest_route_dist = sys.maxint
ret = []
#print village_routes
# we need to recombine these sub routes in a smarter way(by avg location perhaps?)
#ret = list(itertools.chain(*village_routes))
# run greedy on village centers
temp = algo_greedy(village_centers)
for i in temp:
tmp = village_routes[i]
ret.append(tmp)
ret2 = list(itertools.chain(*ret))
default_distance = route_length(cities,ret2)
for idx1 in xrange(len(temp)):
for i in range(0,len(ret[idx1])):
for j in range(2):
revert = ret[idx1]
ret[idx1] = ret[idx1][i:] + ret[idx1][:i]
if (j == 1): ret[idx1].reverse()
ret3 = list(itertools.chain(*ret))
new_distance = route_length(cities,ret3)
if new_distance > default_distance:
ret[idx1] = revert
ret4 = list(itertools.chain(*ret))
return ret4
