Merge branch 'a2' of tarfeef101/cs486 into master

a2/README.md

@@ -0,0 +1,8 @@
+# CS 486 A2 README
+
+ ## Files
+ 
+
+ - tsp_local.py: this file contains all code used. the main function has lines in it to generate graphs for each of the hill climbing methods. simply comment out the one you want to run, comment out the rest (unless you want those to be generated as well), then run this file with "python3 tsp_local.py". Just ensure you have python3 version 3.5 or later, and all dependencies from the imports.
+ - CS_486_A2.pdf: this file is the main assignment document. pretty simple
+ - hill_climbing_*.pdf: These are the diagrams inserted into the PDF. The "*" refers to the algorithm used to generate the graph (basic, tabu, etc.)

a2/tsp_local.py

@@ -0,0 +1,602 @@
+import sys
+import copy
+import math
+import time
+from heapq import heappush, heappop
+from random import shuffle, sample, randint, SystemRandom
+import matplotlib.pyplot as plt
+from matplotlib.backends.backend_pdf import PdfPages
+
+# globals to contain reference solutions
+neos14 = [318, 324, 336, 319, 351, 311, 272, 361, 274, 322]
+neos15 = [313, 318, 281, 324, 378, 291, 348, 342, 353, 325]
+neos16 = [404, 353, 361, 349, 358, 344, 373, 355, 243, 330]
+neos36 = 464
+neos = {14: neos14, 15: neos15, 16: neos16, 36: neos36}
+
+# returns a shuffled version of the cities list while maintaining the first & last elements
+def rand_order(cities):
+    # shitty variable name
+    suburbs = cities[1:-1]
+    shuffle(suburbs)
+    suburbs.insert(0, cities[0])
+    suburbs.append(cities[-1])
+    return suburbs
+
+
+# returns distance between 2 vertices
+def dist(city1, city2):
+    return math.sqrt(int((city1[2]) - int(city2[2])) ** 2 + (int(city1[3]) - int(city2[3])) ** 2)
+
+
+# returns total cost/distance of a tour (list of cities)
+def length(cities):
+    sum = 0
+    for i in range(len(cities) - 1):
+        sum += dist(cities[i], cities[i+1])
+
+    return sum
+
+
+# returns the best ordered child state of a state (hill climbing, basic) & its cost
+def best_child(cities, cost):
+    bestorder = cities
+    bestcost = cost
+    
+    for i in range(1, len(cities) - 2):
+        for j in range(i, len(cities) - 1):
+            temporder = copy.deepcopy(cities)
+            tempcity = temporder[i]
+            temporder[i] = temporder[j]
+            temporder[j] = tempcity
+            templen = length(temporder)
+            if (templen < cost):
+                bestorder = temporder
+                bestcost = templen
+    
+    return (bestorder, bestcost)
+
+
+# returns the best child using tabu
+# returns the best ordered child state of a state (hill climbing, basic) & its cost
+def bester_child(cities, cost, tabu):
+    bestorder = cities
+    bestcost = cost
+    
+    for i in range(1, len(cities) - 2):
+        for j in range(i, len(cities) - 1):
+            temporder = copy.deepcopy(cities)
+            tempcity = temporder[i]
+            temporder[i] = temporder[j]
+            temporder[j] = tempcity
+            
+            if (get_hashable(temporder) in tabu):
+                continue
+            
+            templen = length(temporder)
+            if (templen < cost):
+                bestorder = temporder
+                bestcost = templen
+    
+    return (bestorder, bestcost)
+
+
+# returns a random child for simulated annealing search
+# returns the ordering and the cost of it
+def random_child(cities):
+    #i = randbelow(len(cities) - 3) + 1
+    i = int(randint(1, len(cities) - 2))
+    j = i
+    
+    while (j == i):
+        #j = randbelow(len(cities) - 3) + 1
+        j = int(randint(1, len(cities) - 2))
+        
+    temporder = copy.deepcopy(cities)
+    tempcity = temporder[i]
+    temporder[i] = temporder[j]
+    temporder[j] = tempcity
+    
+    return(temporder, length(temporder))
+
+
+# returns the basic hill climbing solution for a given input
+def sir_edmund_hillary(cities):
+    curcost = length(cities)
+    curpath = copy.deepcopy(cities)
+    steps = 0
+    
+    # keep trying things til we can no longer try things
+    while(1):
+        steps += 1
+        child = best_child(curpath, curcost)
+        if (child[1] < curcost):
+            curcost = child[1]
+            curpath = child[0]
+            continue
+        break
+        
+    return(curpath, curcost, steps)
+
+
+# retuns a tuple of the indices (ordered) in a list of cities
+def get_hashable(cities):
+    newlist = []
+    for i in range(1, len(cities) - 1):
+        newlist.append(cities[i][1])
+        
+    return tuple(newlist)
+
+
+# returns the hill climbing solution w/tabu & sideways moves for a given input
+def tenzing_norgay(cities):
+    curcost = length(cities)
+    curpath = copy.deepcopy(cities)
+    tabu = {get_hashable(cities)}
+    laterals = 0
+    steps = 0
+    
+    # keep trying things til we can no longer try things
+    while(1):
+        steps += 1
+        child = bester_child(curpath, curcost, tabu)
+        if (child[1] < curcost):
+            curcost = child[1]
+            curpath = child[0]
+            tabu.add(get_hashable(curpath))
+            continue
+        if (child[1] == curcost and laterals < len(cities)):
+            laterals += 1
+            curcost = child[1]
+            curpath = child[0]
+            tabu.add(get_hashable(curpath))
+            continue
+        break
+        
+    return(curpath, curcost, steps)
+
+
+# returns the hill climbing solution w/ x random restarts for a given input
+# if you want x restarts, call with x + 1
+def reinhold_messner(cities, x):
+    start = time.process_time()
+    curcost = length(cities)
+    curpath = copy.deepcopy(cities)
+    bestcost = length(cities)
+    bestpath = copy.deepcopy(cities)
+    
+    # keep trying things til we can no longer try things
+    while(x):
+        child = best_child(curpath, curcost)
+        if (child[1] < curcost):
+            curcost = child[1]
+            curpath = child[0]
+            continue
+        else:
+            if (curcost < bestcost):
+                bestcost = curcost
+                bestpath = copy.deepcopy(curpath)
+            curpath = rand_order(cities)
+            curcost = length(curpath)
+            x -= 1
+        
+    end = time.process_time()
+    return(bestpath, bestcost, end - start)
+
+
+# returns true or false randomly, based on the distribution e^(delta / temp)
+def bad_weather(delta, temp):
+    return SystemRandom().random() < math.exp(delta / temp)
+
+
+# decrements temp by the option specified by opt: 1 is linear, 2 is logarithmic, 3 is exponential
+def colder(temp, opt, count):
+    if (opt == 1):
+        return temp - 15
+    if (opt == 2):
+        return temp - (math.log(temp) + 2)
+    else:
+        return 500000 * math.exp(-0.0005 * count) - 1
+
+
+# returns the hill climbing solution using simulated annealing w/ schedule opt
+def beck_weathers(cities, opt):
+    start = time.process_time()
+    temp = 500000
+    count = 1
+    curcost = length(cities)
+    curpath = copy.deepcopy(cities)
+    
+    # keep trying things til we can no longer try things
+    while(temp > 0):
+        child = random_child(curpath)
+        delta = curcost - child[1]
+        if (delta > 0 or bad_weather(delta, temp)):
+            curcost = child[1]
+            curpath = child[0]
+        temp = colder(temp, opt, count)
+        count += 1
+    
+    end = time.process_time()
+    return(curpath, curcost, end - start)
+
+
+# solves the inputted TSP problem (filepath), using algorithm algo
+# 1 = hill climbing, 2 = tabu/sideways allowed, 3 = random restarts, 4 = annealing
+# x represents the optional parameters for 3 and 4
+# specifically, the # of restarts and the annealing schedule, respectively
+def solver(problem, algo, x=None):
+    # import map
+    prob = problem
+    with open(prob) as file:
+        prob = file.read().splitlines()
+
+    global n
+    cities = prob[1:]
+    counter = 0
+    # convert to list of list of ints
+    # original format is: letter, coord, coord
+    # output format is: iD#, letter, coord, coord
+    for l in cities:
+        temp = l.split()
+        temp[1] = int(temp[1])
+        temp[2] = int(temp[2])
+        temp.insert(0, counter)
+        counter += 1
+        cities[cities.index(l)] = temp
+    
+    # add in goal state
+    cities.append(cities[0])
+    input = rand_order(cities)
+    
+    if (algo == 1):
+        result = sir_edmund_hillary(cities)
+    elif (algo == 2):
+        result = tenzing_norgay(cities)
+    elif (algo == 3):
+        result = reinhold_messner(cities, x)
+    else:
+        result = beck_weathers(cities, x)
+    
+    return result
+
+
+# function to generate PDF results for basic hill climbing
+def sir_edmund_hillary_graph():
+    plt.ioff()
+    plt.switch_backend('agg')
+    solution_steps = []
+    solution_scores = []
+    good_sol_counts = []
+    
+    for i in range(14, 17):
+        steps = []
+        solution_steps.append(steps)
+        scores = []
+        solution_scores.append(scores)
+        good_sols = []
+        good_sol_counts.append(good_sols)
+        
+        for j in range(1, 11):
+            filepath = "tsp_problems/" + str(i) + "/instance_" + str(j) + ".txt"
+            prob_steps = 0
+            prob_scores = 0
+            good_solutions = 0
+            # run problem 100 times
+            for k in range(0, 100):
+                # path, cost, steps returned
+                result = solver(filepath, 1)
+                prob_steps += result[2]
+                prob_scores += (result[1] / neos[i][j - 1])
+                if (result[1] <= neos[i][j- 1]):
+                    good_solutions += 1
+            
+            steps.append(prob_steps / 100.0)
+            scores.append(prob_scores / 100.0)
+            good_sols.append(good_solutions)
+            
+    with PdfPages("hill_climbing.pdf") as pdf:
+        figure, axes = plt.subplots(3, 1, True)
+        figure.suptitle("Hill Climbing")
+        
+        for i in range(0, 3):
+            axes[i].plot(range(1, 11), solution_steps[i], label = "Steps to Solution", color = 'b')
+            axes[i].set_xlabel("Problem Instance w/ " + str(i + 14) + " cities")
+            axes[i].set_ylabel("Steps Taken", color = 'b')
+            axis_twin = axes[i].twinx()
+            axis_twin.plot(range(1, 11), solution_scores[i], label = "Solution Quality", color = 'r')
+            axis_twin.set_ylabel("Solution Quality", color = 'r')
+            #axes[i].legend()
+            #axis_twin.legend()
+
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+        
+        figure, axes = plt.subplots(3, 1, True)
+        figure.suptitle("Hill Climbing Cont.")
+        
+        for i in range(0, 3):
+            axes[i].plot(range(1, 11), good_sol_counts[i], color = 'b')
+            axes[i].set_xlabel("Problem Instance w/ " + str(i + 14) + " cities")
+            axes[i].set_ylabel("% of runs <= NEOS", color = 'b')
+            
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+        
+        # now we can aggregate and replace the old values
+        for i in range(0, 3):
+            tempsteps = 0
+            tempqual = 0
+            tempgood = 0
+            for j in range(0, 10):
+               tempsteps += solution_steps[i][j]
+               tempqual += solution_scores[i][j]
+               tempgood += good_sol_counts[i][j]
+            solution_steps[i] = tempsteps / 10.0
+            solution_scores[i] = tempqual / 10.0
+            good_sol_counts[i] = tempgood / 10.0
+        
+        figure, axes = plt.subplots(3, 1, True)
+        figure.suptitle("Hill Climbing Aggegated (Averages)")
+        
+        axes[0].plot(range(14, 17), solution_steps, color = 'b')
+        axes[0].set_xlabel("Problem Instances w/ x cities")
+        axes[0].set_ylabel("Steps Used", color = 'b')
+        axes[0].set_xticks([14, 15, 16])
+        
+        axes[1].plot(range(14, 17), solution_scores, color = 'b')
+        axes[1].set_xlabel("Problem Instances w/ x cities")
+        axes[1].set_ylabel("Solution Quality", color = 'b')
+        axes[1].set_xticks([14, 15, 16])
+        
+        axes[2].plot(range(14, 17), good_sol_counts, color = 'b')
+        axes[2].set_xlabel("Problem Instances w/ x cities")
+        axes[2].set_ylabel("% of runs <= NEOS", color = 'b')
+        axes[2].set_xticks([14, 15, 16])
+            
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+
+
+# function to generate PDF results for basic hill climbing w/ tabu and sideways moves
+def tenzing_norgay_graph():
+    plt.ioff()
+    plt.switch_backend('agg')
+    solution_steps = []
+    solution_scores = []
+    good_sol_counts = []
+    
+    for i in range(14, 17):
+        steps = []
+        solution_steps.append(steps)
+        scores = []
+        solution_scores.append(scores)
+        good_sols = []
+        good_sol_counts.append(good_sols)
+        
+        for j in range(1, 11):
+            filepath = "tsp_problems/" + str(i) + "/instance_" + str(j) + ".txt"
+            prob_steps = 0
+            prob_scores = 0
+            good_solutions = 0
+            # run problem 100 times
+            for k in range(0, 100):
+                # path, cost, steps returned
+                result = solver(filepath, 2)
+                prob_steps += result[2]
+                prob_scores += (result[1] / neos[i][j - 1])
+                if (result[1] <= neos[i][j- 1]):
+                    good_solutions += 1
+            
+            steps.append(prob_steps / 100.0)
+            scores.append(prob_scores / 100.0)
+            good_sols.append(good_solutions)
+            
+    with PdfPages("hill_climbing_tabu.pdf") as pdf:
+        figure, axes = plt.subplots(3, 1, True)
+        figure.suptitle("Hill Climbing - Tabu")
+        
+        for i in range(0, 3):
+            axes[i].plot(range(1, 11), solution_steps[i], label = "Steps to Solution", color = 'b')
+            axes[i].set_xlabel("Problem Instance w/ " + str(i + 14) + " cities")
+            axes[i].set_ylabel("Steps Taken", color = 'b')
+            axis_twin = axes[i].twinx()
+            axis_twin.plot(range(1, 11), solution_scores[i], label = "Solution Quality", color = 'r')
+            axis_twin.set_ylabel("Solution Quality", color = 'r')
+            #axes[i].legend()
+            #axis_twin.legend()
+
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+        
+        figure, axes = plt.subplots(3, 1, True)
+        figure.suptitle("Hill Climbing - Tabu Cont.")
+        
+        for i in range(0, 3):
+            axes[i].plot(range(1, 11), good_sol_counts[i], color = 'b')
+            axes[i].set_xlabel("Problem Instance w/ " + str(i + 14) + " cities")
+            axes[i].set_ylabel("% of runs <= NEOS", color = 'b')
+            
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+        
+        # now we can aggregate and replace the old values
+        for i in range(0, 3):
+            tempsteps = 0
+            tempqual = 0
+            tempgood = 0
+            for j in range(0, 10):
+               tempsteps += solution_steps[i][j]
+               tempqual += solution_scores[i][j]
+               tempgood += good_sol_counts[i][j]
+            solution_steps[i] = tempsteps / 10.0
+            solution_scores[i] = tempqual / 10.0
+            good_sol_counts[i] = tempgood / 10.0
+        
+        figure, axes = plt.subplots(3, 1, True)
+        figure.suptitle("Hill Climbing - Tabu Aggegated (Averages)")
+        
+        axes[0].plot(range(14, 17), solution_steps, color = 'b')
+        axes[0].set_xlabel("Problem Instances w/ x cities")
+        axes[0].set_ylabel("Steps Used", color = 'b')
+        axes[0].set_xticks([14, 15, 16])
+        
+        axes[1].plot(range(14, 17), solution_scores, color = 'b')
+        axes[1].set_xlabel("Problem Instances w/ x cities")
+        axes[1].set_ylabel("Solution Quality", color = 'b')
+        axes[1].set_xticks([14, 15, 16])
+        
+        axes[2].plot(range(14, 17), good_sol_counts, color = 'b')
+        axes[2].set_xlabel("Problem Instances w/ x cities")
+        axes[2].set_ylabel("% of runs <= NEOS", color = 'b')
+        axes[2].set_xticks([14, 15, 16])
+            
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+        
+        
+# function to generate PDF results for basic hill climbing w/ random restarts
+def reinhold_messner_graph():
+    plt.ioff()
+    plt.switch_backend('agg')
+    solution_times = []
+    solution_scores = []
+    
+    # num of cities
+    for i in range(14, 17):
+        times = []
+        solution_times.append(times)
+        scores = []
+        solution_scores.append(scores)
+        
+        # num of instances
+        for j in range(1, 3):
+            filepath = "tsp_problems/" + str(i) + "/instance_" + str(j) + ".txt"
+            prob_times = []
+            times.append(prob_times)
+            prob_scores = []
+            scores.append(prob_scores)
+            
+            # num of repeats
+            for k in range(1, 16):
+                ktimes = []
+                prob_times.append(ktimes)
+                kscores = []
+                prob_scores.append(kscores)
+            
+                runtime = 0
+                qual = 0
+                # run problem 100 times
+                for num in range(0, 100):
+                    # path, cost, runtime returned
+                    result = solver(filepath, 3, k)
+                    runtime += result[2]
+                    qual += (result[1] / neos[i][j - 1])
+            
+                ktimes.append(runtime / 100.0)
+                kscores.append(qual / 100.0)
+            
+    with PdfPages("hill_climbing_restarts.pdf") as pdf:
+        figure, axes = plt.subplots(3, 2, True)
+        figure.suptitle("Hill Climbing - Restarts")
+        
+        for i in range(0, 3):
+            for j in range(0, 2):
+                axes[i][j].plot(range(1, 16), solution_times[i][j], color = 'b')
+                axes[i][j].set_xlabel("Problem Instance " + str(j + 1) +  " w/ " + str(i + 14) + " cities")
+                axes[i][j].set_ylabel("Time Taken (s)", color = 'b')
+                axis_twin = axes[i][j].twinx()
+                axis_twin.plot(range(1, 16), solution_scores[i][j], color = 'r')
+                axis_twin.set_ylabel("Solution Quality", color = 'r')
+                #axes[i].legend()
+                #axis_twin.legend()
+
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.92)
+        pdf.savefig()
+        plt.close()
+        
+        
+# function to generate PDF results for basic hill climbing w/ annealing
+def beck_weathers_graph():
+    plt.ioff()
+    plt.switch_backend('agg')
+    solution_times = []
+    solution_scores = []
+    
+    # num of cities
+    for i in range(14, 17):
+        times = []
+        solution_times.append(times)
+        scores = []
+        solution_scores.append(scores)
+        
+        # num of instances
+        for j in range(1, 3):
+            filepath = "tsp_problems/" + str(i) + "/instance_" + str(j) + ".txt"
+            prob_times = []
+            times.append(prob_times)
+            prob_scores = []
+            scores.append(prob_scores)
+            
+            # diff schedules
+            for k in range(1, 4):
+                ktimes = []
+                prob_times.append(ktimes)
+                kscores = []
+                prob_scores.append(kscores)
+            
+                runtime = 0
+                qual = 0
+                # run problem 100 times
+                for num in range(0, 100):
+                    # path, cost, runtime returned
+                    result = solver(filepath, 4, k)
+                    runtime += result[2]
+                    qual += (result[1] / neos[i][j - 1])
+            
+                ktimes.append(runtime / 100.0)
+                kscores.append(qual / 100.0)
+            
+    with PdfPages("hill_climbing_annealing.pdf") as pdf:
+        figure, axes = plt.subplots(3, 2, True)
+        figure.suptitle("Hill Climbing - Annealing")
+        
+        for i in range(0, 3):
+            for j in range(0, 2):
+                axes[i][j].plot(range(1, 4), solution_times[i][j], color = 'b')
+                axes[i][j].set_title("Problem Instance " + str(j + 1) +  " w/ " + str(i + 14) + " cities")
+                axes[i][j].set_xlabel("Annealing Schedule")
+                axes[i][j].set_ylabel("Time Taken (s)", color = 'b')
+                axis_twin = axes[i][j].twinx()
+                axis_twin.plot(range(1, 4), solution_scores[i][j], color = 'r')
+                axis_twin.set_ylabel("Solution Quality", color = 'r')
+                #axes[i].legend()
+                #axis_twin.legend()
+
+        plt.tight_layout()
+        plt.subplots_adjust(top=0.85)
+        pdf.savefig()
+        plt.close()
+
+
+# main function that will call needed graphing function(s)
+def main():
+    #sir_edmund_hillary_graph()
+    #tenzing_norgay_graph()
+    #reinhold_messner_graph()
+    beck_weathers_graph()
+
+main()

a2/tsp_problems/14/instance_1.txt

@@ -0,0 +1,15 @@
+14
+A 33 26
+B 33 16
+C 65 7
+D 75 30
+E 91 88
+F 37 13
+G 64 89
+H 7 79
+I 1 89
+J 11 70
+K 62 74
+L 65 74
+M 15 31
+N 24 91

a2/tsp_problems/14/instance_10.txt

@@ -0,0 +1,15 @@
+14
+A 37 36
+B 67 6
+C 90 71
+D 40 71
+E 49 53
+F 90 38
+G 3 34
+H 27 15
+I 20 8
+J 81 40
+K 85 3
+L 59 63
+M 74 44
+N 99 37

a2/tsp_problems/14/instance_2.txt

@@ -0,0 +1,15 @@
+14
+A 92 92
+B 1 65
+C 27 67
+D 53 84
+E 92 19
+F 95 35
+G 57 5
+H 77 89
+I 4 13
+J 90 34
+K 31 63
+L 7 16
+M 64 9
+N 94 72

a2/tsp_problems/14/instance_3.txt

@@ -0,0 +1,15 @@
+14
+A 53 79
+B 5 63
+C 51 78
+D 12 86
+E 77 41
+F 22 1
+G 83 52
+H 89 8
+I 93 66
+J 60 3
+K 30 94
+L 4 34
+M 4 88
+N 18 66

a2/tsp_problems/14/instance_4.txt

@@ -0,0 +1,15 @@
+14
+A 30 50
+B 10 55
+C 64 68
+D 25 46
+E 28 8
+F 23 58
+G 55 37
+H 80 7
+I 12 3
+J 53 63
+K 82 43
+L 10 70
+M 91 52
+N 82 48

a2/tsp_problems/14/instance_5.txt

@@ -0,0 +1,15 @@
+14
+A 25 44
+B 25 6
+C 43 86
+D 2 30
+E 8 18
+F 62 40
+G 76 94
+H 54 94
+I 69 26
+J 55 49
+K 60 18
+L 71 5
+M 13 81
+N 93 26

a2/tsp_problems/14/instance_6.txt

@@ -0,0 +1,15 @@
+14
+A 87 93
+B 54 69
+C 37 29
+D 8 74
+E 22 46
+F 28 72
+G 31 21
+H 89 74
+I 16 50
+J 3 4
+K 22 41
+L 86 45
+M 15 31
+N 70 32

a2/tsp_problems/14/instance_7.txt

@@ -0,0 +1,15 @@
+14
+A 25 83
+B 84 62
+C 37 74
+D 17 48
+E 41 39
+F 35 18
+G 54 96
+H 12 24
+I 41 29
+J 71 49
+K 17 88
+L 70 82
+M 16 40
+N 91 54

a2/tsp_problems/14/instance_8.txt

@@ -0,0 +1,15 @@
+14
+A 12 13
+B 73 34
+C 57 68
+D 67 70
+E 61 51
+F 46 58
+G 69 89
+H 16 81
+I 92 47
+J 5 17
+K 26 63
+L 64 83
+M 93 30
+N 91 4

a2/tsp_problems/14/instance_9.txt

@@ -0,0 +1,15 @@
+14
+A 47 37
+B 74 52
+C 61 94
+D 39 54
+E 11 45
+F 65 86
+G 77 18
+H 19 74
+I 62 80
+J 44 50
+K 45 55
+L 49 90
+M 53 54
+N 84 69

a2/tsp_problems/15/instance_1.txt

@@ -0,0 +1,16 @@
+15
+A 62 27
+B 75 34
+C 14 20
+D 54 65
+E 99 90
+F 96 40
+G 69 9
+H 98 51
+I 74 18
+J 17 4
+K 52 42
+L 83 25
+M 61 19
+N 34 9
+O 22 33

a2/tsp_problems/15/instance_10.txt

@@ -0,0 +1,16 @@
+15
+A 38 23
+B 6 87
+C 86 72
+D 88 52
+E 56 95
+F 21 28
+G 46 4
+H 15 60
+I 61 32
+J 68 96
+K 72 9
+L 48 87
+M 58 91
+N 5 23
+O 82 80

a2/tsp_problems/15/instance_2.txt

@@ -0,0 +1,16 @@
+15
+A 98 24
+B 18 72
+C 79 84
+D 54 64
+E 29 61
+F 2 88
+G 24 91
+H 92 54
+I 71 54
+J 66 59
+K 61 78
+L 83 7
+M 45 96
+N 93 84
+O 92 78

a2/tsp_problems/15/instance_3.txt

@@ -0,0 +1,16 @@
+15
+A 61 32
+B 51 45
+C 92 49
+D 54 31
+E 63 81
+F 83 73
+G 19 36
+H 65 18
+I 20 66
+J 83 63
+K 73 75
+L 2 48
+M 7 43
+N 36 45
+O 16 19

a2/tsp_problems/15/instance_4.txt

@@ -0,0 +1,16 @@
+15
+A 76 76
+B 10 23
+C 74 74
+D 27 98
+E 10 49
+F 4 71
+G 46 12
+H 23 59
+I 20 35
+J 18 31
+K 96 39
+L 84 32
+M 71 18
+N 75 11
+O 38 70

a2/tsp_problems/15/instance_5.txt

@@ -0,0 +1,16 @@
+15
+A 56 8
+B 11 86
+C 35 80
+D 2 40
+E 59 6
+F 76 6
+G 92 4
+H 50 20
+I 29 72
+J 39 15
+K 53 53
+L 93 27
+M 42 48
+N 45 78
+O 99 86

a2/tsp_problems/15/instance_6.txt

@@ -0,0 +1,16 @@
+15
+A 60 6
+B 21 15
+C 94 42
+D 72 24
+E 40 35
+F 17 65
+G 51 86
+H 75 18
+I 22 20
+J 24 61
+K 76 8
+L 90 61
+M 73 63
+N 93 43
+O 65 93

a2/tsp_problems/15/instance_7.txt

@@ -0,0 +1,16 @@
+15
+A 22 33
+B 12 79
+C 31 9
+D 95 64
+E 5 61
+F 96 49
+G 30 92
+H 20 70
+I 81 44
+J 73 20
+K 75 79
+L 72 66
+M 24 93
+N 98 2
+O 3 50

a2/tsp_problems/15/instance_8.txt

@@ -0,0 +1,16 @@
+15
+A 6 58
+B 48 53
+C 67 30
+D 31 26
+E 55 99
+F 82 64
+G 59 37
+H 71 83
+I 95 96
+J 89 11
+K 85 22
+L 83 77
+M 24 82
+N 94 34
+O 62 38

a2/tsp_problems/15/instance_9.txt

@@ -0,0 +1,16 @@
+15
+A 46 96
+B 94 78
+C 9 12
+D 98 93
+E 2 81
+F 49 92
+G 57 98
+H 58 76
+I 90 91
+J 40 65
+K 82 58
+L 73 38
+M 90 49
+N 23 85
+O 45 70

a2/tsp_problems/16/instance_1.txt

@@ -0,0 +1,17 @@
+16
+A 14 82
+B 90 67
+C 21 69
+D 42 29
+E 69 28
+F 62 19
+G 56 1
+H 19 13
+I 53 9
+J 82 11
+K 29 44
+L 42 77
+M 6 44
+N 54 60
+O 46 40
+P 87 99

a2/tsp_problems/16/instance_10.txt

@@ -0,0 +1,17 @@
+16
+A 93 48
+B 67 72
+C 66 44
+D 99 65
+E 18 90
+F 47 17
+G 84 8
+H 16 67
+I 9 57
+J 76 28
+K 72 69
+L 53 65
+M 91 26
+N 61 49
+O 26 56
+P 15 73

a2/tsp_problems/16/instance_2.txt

@@ -0,0 +1,17 @@
+16
+A 37 3
+B 6 80
+C 48 60
+D 67 94
+E 24 4
+F 59 72
+G 11 72
+H 76 22
+I 12 10
+J 56 51
+K 92 70
+L 16 5
+M 19 60
+N 82 98
+O 3 59
+P 96 38

a2/tsp_problems/16/instance_3.txt

@@ -0,0 +1,17 @@
+16
+A 97 96
+B 18 93
+C 38 59
+D 71 86
+E 13 19
+F 88 98
+G 98 88
+H 45 78
+I 79 30
+J 58 59
+K 60 28
+L 12 88
+M 12 61
+N 43 44
+O 66 87
+P 36 41

a2/tsp_problems/16/instance_4.txt

@@ -0,0 +1,17 @@
+16
+A 87 61
+B 40 4
+C 29 39
+D 89 99
+E 72 10
+F 67 28
+G 83 12
+H 64 75
+I 74 11
+J 29 78
+K 32 46
+L 35 88
+M 17 38
+N 64 74
+O 8 26
+P 13 51

a2/tsp_problems/16/instance_5.txt

@@ -0,0 +1,17 @@
+16
+A 42 68
+B 57 56
+C 11 66
+D 69 43
+E 87 1
+F 73 96
+G 4 19
+H 11 41
+I 36 19
+J 65 21
+K 85 11
+L 31 85
+M 85 88
+N 59 48
+O 80 99
+P 72 66

a2/tsp_problems/16/instance_6.txt

@@ -0,0 +1,17 @@
+16
+A 65 56
+B 57 17
+C 38 22
+D 35 95
+E 19 36
+F 65 21
+G 88 14
+H 59 55
+I 80 91
+J 60 52
+K 26 64
+L 56 29
+M 52 50
+N 3 32
+O 1 69
+P 53 23

a2/tsp_problems/16/instance_7.txt

@@ -0,0 +1,17 @@
+16
+A 37 18
+B 8 68
+C 77 92
+D 56 5
+E 1 87
+F 56 60
+G 13 46
+H 43 27
+I 13 12
+J 40 27
+K 12 95
+L 53 24
+M 95 60
+N 62 71
+O 38 53
+P 82 96

a2/tsp_problems/16/instance_8.txt

@@ -0,0 +1,17 @@
+16
+A 17 16
+B 67 99
+C 10 87
+D 62 81
+E 28 93
+F 47 14
+G 86 44
+H 29 61
+I 59 6
+J 34 67
+K 58 18
+L 60 52
+M 60 64
+N 45 61
+O 1 17
+P 51 9

a2/tsp_problems/16/instance_9.txt

@@ -0,0 +1,17 @@
+16
+A 68 79
+B 55 35
+C 46 78
+D 65 73
+E 28 78
+F 48 25
+G 45 80
+H 9 32
+I 66 38
+J 60 92
+K 43 38
+L 84 52
+M 23 44
+N 5 35
+O 80 55
+P 80 52

a2/tsp_problems/36/instance_1.txt

@@ -0,0 +1,37 @@
+36
+A 13 2
+B 64 49
+C 92 15
+D 33 42
+E 92 14
+F 89 53
+G 61 57
+H 79 60
+I 27 76
+J 41 10
+K 33 2
+L 26 67
+M 80 91
+N 28 27
+O 86 15
+P 81 15
+Q 40 14
+R 92 88
+S 99 45
+T 38 67
+U 91 39
+V 49 35
+W 33 5
+X 46 35
+Y 29 70
+Z 51 18
+AA 50 71
+AB 23 25
+AC 96 16
+AD 92 7
+AE 99 81
+AF 41 70
+AG 82 73
+AH 18 84
+AI 13 98
+AJ 72 54