added 2015/day09

Author: anight

2015/day09/answers.txt

@@ -0,0 +1,2 @@
+117
+909

2015/day09/input.txt

@@ -0,0 +1,28 @@
+Faerun to Tristram = 65
+Faerun to Tambi = 129
+Faerun to Norrath = 144
+Faerun to Snowdin = 71
+Faerun to Straylight = 137
+Faerun to AlphaCentauri = 3
+Faerun to Arbre = 149
+Tristram to Tambi = 63
+Tristram to Norrath = 4
+Tristram to Snowdin = 105
+Tristram to Straylight = 125
+Tristram to AlphaCentauri = 55
+Tristram to Arbre = 14
+Tambi to Norrath = 68
+Tambi to Snowdin = 52
+Tambi to Straylight = 65
+Tambi to AlphaCentauri = 22
+Tambi to Arbre = 143
+Norrath to Snowdin = 8
+Norrath to Straylight = 23
+Norrath to AlphaCentauri = 136
+Norrath to Arbre = 115
+Snowdin to Straylight = 101
+Snowdin to AlphaCentauri = 84
+Snowdin to Arbre = 96
+Straylight to AlphaCentauri = 107
+Straylight to Arbre = 14
+AlphaCentauri to Arbre = 46

2015/day09/run.py

@@ -0,0 +1,70 @@
+#! /usr/bin/env python3
+
+def load_data(filename):
+	with open(filename, 'r') as f:
+		for line in f:
+			line = line.rstrip('\n')
+			t1 = line.split(' = ')
+			t2 = t1[0].split(' to ')
+			yield int(t1[1]), t2[0], t2[1]
+
+# Part One
+
+import itertools
+import networkx as nx
+
+G = nx.Graph()
+
+for distance, f, t in load_data('input.txt'):
+	G.add_edge(f, t, weight=distance)
+
+def solve_shortest_hamiltonian_path(G):
+	nodes = list(G.nodes)
+	num_nodes = len(nodes)
+
+	# Brute-force search over all permutations of nodes
+	best_path = None
+	min_cost = float("inf")
+
+	for perm in itertools.permutations(nodes):  # Try all orderings
+		try:
+			cost = sum(G[perm[i]][perm[i+1]]['weight'] for i in range(num_nodes - 1))
+			if cost < min_cost:
+				min_cost = cost
+				best_path = perm  # This is the optimal open path
+		except KeyError:
+			# This catches cases where a path doesn't exist in non-complete graphs
+			continue
+
+	return best_path, min_cost
+
+path, cost = solve_shortest_hamiltonian_path(G)
+
+print(cost)
+
+# Part Two
+
+def solve_longest_hamiltonian_path(G):
+	nodes = list(G.nodes)
+	num_nodes = len(nodes)
+
+	# Brute-force search over all permutations of nodes
+	best_path = None
+	max_cost = float("-inf")  # Start with negative infinity
+
+	for perm in itertools.permutations(nodes):  # Try all orderings
+		try:
+			cost = sum(G[perm[i]][perm[i+1]]['weight'] for i in range(num_nodes - 1))
+			if cost > max_cost:  # Maximization instead of minimization
+				max_cost = cost
+				best_path = perm  # Store the best (longest) path
+		except KeyError:
+			# This catches cases where a path doesn't exist in non-complete graphs
+			continue
+
+	return best_path, max_cost
+
+path, cost = solve_longest_hamiltonian_path(G)
+
+print(cost)
+

README.md

@@ -1,6 +1,6 @@
 ```
       1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
-2015 ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +
+2015 ++ ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +
 2016 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
 2017 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -
 2018 ++ ++ ++ ++ ++ ++ ++ ++ -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +