from search_2 import *
+import math
+
+# My implementation of RBFS
+def recursive_best_first_search(problem, h):
+    return RBFS(problem, Node(problem.initial), math.inf, h)[0]
+
+def RBFS(problem, node, f_limit, h):
+    if problem.is_goal(node.state):
+        return node, 0
+    successors = []
+    for child in expand(problem, node):
+        successors.append(child)
+    if not successors:
+        return failure, math.inf
+    for s in successors:
+        s.f = max(g(s) + h(s), g(node) + h(node))
+    while True:
+        successors.sort(key = lambda x: x.f)
+        best = successors[0]
+        if best.f > f_limit:
+            return failure, best.f
+        if len(successors) > 1:
+            alternative = successors[1].f
+        else:
+            alternative = math.inf
+        result, best.f = RBFS(problem, best, min(f_limit, alternative), h)
+        if result is not failure:
+            return result, best.f
+
+def astar_misplaced_tiles(problem): return astar_search(problem, h=problem.h1)
+def recursive_best_first_misplaced_tiles(problem): return recursive_best_first_search(problem, h=problem.h1)
+def astar_manhatten(problem): return astar_search(problem, h=problem.h2)
+def astar_manhatten_with_weight(problem): return astar_search(problem, h=problem.h3)
+def recursive_best_first_manhatten(problem): return recursive_best_first_search(problem, h=problem.h2)
+def recursive_best_first_manhatten_with_weight(problem): return recursive_best_first_search(problem, h=problem.h3)
+
+
+e1 = EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8))
+e2 = EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0))
+e3 = EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6))
+e4 = EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1))
+e5 = EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1))
+
+report([breadth_first_search,
+        uniform_cost_search,
+        recursive_best_first_manhatten,
+        recursive_best_first_manhatten_with_weight,
+        astar_manhatten,
+        astar_manhatten_with_weight], [e1, e2, e3, e4, e5]) 
+

breadth_first_search:
+       81 nodes |       82 goal |    5 cost |      35 actions | EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8),
+  160,948 nodes |  160,949 goal |   22 cost |  59,960 actions | EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
+  218,263 nodes |  218,264 goal |   23 cost |  81,829 actions | EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6),
+  418,771 nodes |  418,772 goal |   26 cost | 156,533 actions | EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1),
+  448,667 nodes |  448,668 goal |   27 cost | 167,799 actions | EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1),
+1,246,730 nodes |1,246,735 goal |  103 cost | 466,156 actions | TOTAL
+
+uniform_cost_search:
+      124 nodes |       46 goal |    5 cost |      50 actions | EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8),
+  214,952 nodes |   79,187 goal |   22 cost |  79,208 actions | EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
+  300,925 nodes |  112,082 goal |   23 cost | 112,104 actions | EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6),
+  457,766 nodes |  171,571 goal |   26 cost | 171,596 actions | EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1),
+  466,441 nodes |  174,474 goal |   27 cost | 174,500 actions | EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1),
+1,440,208 nodes |  537,360 goal |  103 cost | 537,458 actions | TOTAL
+
+recursive_best_first_manhatten:
+       15 nodes |        6 goal |    5 cost |      10 actions | EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8),
+  271,746 nodes |   99,853 goal |   22 cost |  99,874 actions | EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
+2,807,027 nodes |1,042,820 goal |   23 cost |1,042,842 actions | EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6),
+  746,166 nodes |  284,844 goal |   26 cost | 284,869 actions | EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1),
+  326,744 nodes |  126,504 goal |   27 cost | 126,530 actions | EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1),
+4,151,698 nodes |1,554,027 goal |  103 cost |1,554,125 actions | TOTAL
+
+recursive_best_first_manhatten_with_weight:
+       15 nodes |        6 goal |    5 cost |      10 actions | EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8),
+2,409,806 nodes |  901,511 goal |   24 cost | 901,534 actions | EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
+20,658,284 nodes |7,566,616 goal |   25 cost |7,566,640 actions | EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6),
+  588,906 nodes |  211,503 goal |   30 cost | 211,532 actions | EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1),
+  597,734 nodes |  233,773 goal |   33 cost | 233,805 actions | EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1),
+24,254,745 nodes |8,913,409 goal |  117 cost |8,913,521 actions | TOTAL
+
+astar_manhatten:
+       15 nodes |        6 goal |    5 cost |      10 actions | EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8),
+    3,614 nodes |    1,349 goal |   22 cost |   1,370 actions | EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
+    5,373 nodes |    2,010 goal |   23 cost |   2,032 actions | EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6),
+   10,832 nodes |    4,086 goal |   26 cost |   4,111 actions | EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1),
+   11,669 nodes |    4,417 goal |   27 cost |   4,443 actions | EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1),
+   31,503 nodes |   11,868 goal |  103 cost |  11,966 actions | TOTAL
+
+astar_manhatten_with_weight:
+       15 nodes |        6 goal |    5 cost |      10 actions | EightPuzzle((1, 4, 2, 0, 7, 5, 3, 6, 8),
+    1,720 nodes |      633 goal |   24 cost |     656 actions | EightPuzzle((1, 2, 3, 4, 5, 6, 7, 8, 0),
+    1,908 nodes |      709 goal |   25 cost |     733 actions | EightPuzzle((4, 0, 2, 5, 1, 3, 7, 8, 6),
+    1,312 nodes |      489 goal |   30 cost |     518 actions | EightPuzzle((7, 2, 4, 5, 0, 6, 8, 3, 1),
+    2,519 nodes |      935 goal |   29 cost |     963 actions | EightPuzzle((8, 6, 7, 2, 5, 4, 3, 0, 1),
+    7,474 nodes |    2,772 goal |  113 cost |   2,880 actions | TOTAL
+
+

import time
+
+t0 = time.time()
+recursive_best_first_manhatten(e4)
+t1 = time.time()
+print("Time taken to execute RBFS: ", t1 - t0)
+print("Execution time per node: ", (t1 - t0) / 746,166)
+
+t0 = time.time()
+recursive_best_first_manhatten_with_weight(e4)
+t1 = time.time()
+print("Time taken to execute weighted-RBFS: ", t1 - t0)
+print("Execution time per node: ", (t1 - t0) / 588,906)
+
+t0 = time.time()
+astar_manhatten(e4)
+t1 = time.time()
+print("Time taken to execute A*: ", t1 - t0)
+print("Execution time per node: ", (t1 - t0) / 10,832)
+
+t0 = time.time()
+astar_manhatten_with_weight(e4)
+t1 = time.time()
+print("Time taken to execute weighted-A*: ", t1 - t0)
+print("Execution time per node: ", (t1 - t0) / 1,312)
+

Time taken to execute RBFS:  7.069175720214844
+Execution time per node:  0.009476106863558771 166
+Time taken to execute weighted-RBFS:  5.464362859725952
+Execution time per node:  0.009293134115180192 906
+Time taken to execute A*:  0.08570456504821777
+Execution time per node:  0.008570456504821777 832
+Time taken to execute weighted-A*:  0.008708953857421875
+Execution time per node:  0.008708953857421875 312
+

from search_2 import *
+

def add(xs,ys):
+     return tuple(x + y for x, y in zip(xs, ys))
+
+
+class Cannibals(Problem):
+    def __init__(self, initial=(3, 3, 1, 0, 0, 0), goal=(0, 0, 0, 1, 3, 3), obstacles=(), **kwds):
+        Problem.__init__(self, initial=initial, goal=goal, obstacles=set(), **kwds)
+        # The first index is the change in cannibals from
+        # the left hand side. The second index is the 
+        # change in missionaries from the left hand side.
+        self.directions = [(-1, -1, -1, 1, 1, 1),
+                           (1, 1, 1, -1, -1, -1),
+                           (-2, 0, -1, 1, 2, 0),
+                           (2, 0, 1, -1, -2, 0),
+                           (0, -2, -1, 1, 0, 2),
+                           (0, 2, 1, -1, 0, -2),
+                           (-1, 0, -1, 1, 1, 0),
+                           (1, 0, 1, -1, -1, 0),
+                           (0, -1, -1, 1, 0, 1),
+                           (0, 1, 1, -1, 0, -1)]
+        
+    def result(self, state, action):
+        return add(action, state)
+    
+    def actions(self, state):
+        legit_directions = set()
+        for d in self.directions:
+            result = add(d, state)
+            # if more cannibals than missionaries, but if there are no missionaries 
+            # we can have as many cannibals as we like :)
+            if(result[1] > 0):
+                if(result[0] > result[1]):
+                    continue
+            if(result[5] > 0):
+                if(result[4] > result[5]):
+                    continue
+            # if there are negative numbers / more than 3 of each cannibals/missionaries
+            # on the left hand side
+            if(result[0] < 0 or result[1] < 0 or result[0] > 3 or result[1] > 3):
+                continue
+            # if there are negative numbers / more than 3 of each cannibals/missionaries
+            # on the right hand side
+            if(result[4] < 0 or result[5] < 0 or result[4] > 3 or result[5] > 3):
+                continue
+            # now we need to check boat status - bit spagetti :)
+            b1 = result[2]
+            if(b1 < 0 or b1 > 1):
+                continue
+            b2 = result[3]
+            if(b2 < 0 or b2 > 1):
+                continue    
+            if(b1 == 1):
+                if(b2 != 0):
+                    continue
+            if(b2 == 1):
+                if(b1 != 0):
+                    continue
+                # if we reach this point then we have a ligit state
+            legit_directions.add(d)
+        return legit_directions
+

problem = Cannibals()
+states = path_states(breadth_first_search(problem))
+print(states)
+print(len(states))
+

[(3, 3, 1, 0, 0, 0), (1, 3, 0, 1, 2, 0), (2, 3, 1, 0, 1, 0), (0, 3, 0, 1, 3, 0), (1, 3, 1, 0, 2, 0), (1, 1, 0, 1, 2, 2), (2, 2, 1, 0, 1, 1), (2, 0, 0, 1, 1, 3), (3, 0, 1, 0, 0, 3), (1, 0, 0, 1, 2, 3), (2, 0, 1, 0, 1, 3), (0, 0, 0, 1, 3, 3)]
+12
+

import numpy as np
+from agents import *
+
+class VacuumAgent(Agent):
+
+    def __init__(self, program = None):
+        super().__init__(program)
+        self.location = [1,1]
+        self.direction = 'R' # 'R', 'L', 'U', 'D'
+
+def program(percept):
+    if percept == 2:
+        chance = random.randint(1,100)
+        if(chance > 20):
+            return ('Suck','None')
+        else:
+            return ('None','None')
+    else:
+        bump = 'Bump' if agent.bump else 'None'
+        return ('Move', bump)
+
+class Environment:
+    
+    def __init__(self):
+        self.agents = []
+        
+        with open('floorplan.txt') as f:
+            floor_plan = np.array([list(map(int, line.strip())) for line in f])
+        self.floor_plan = floor_plan
+        
+    def percept(self, agent):
+        return self.floor_plan[agent.location[0]][agent.location[1]]
+
+    def execute_action(self, agent, action):
+        if action[0] == 'Suck':
+            self.floor_plan[agent.location[0]][agent.location[1]] = 1
+            agent.performance += 100
+        
+        elif action[0] == 'Move':
+            agent.performance -= 1
+            if action[1] == 'Bump':
+                agent.bump = False
+            else:
+                agent.direction = random.choice(['R', 'L', 'U', 'D'])
+                agent.bump = self.move_agent(agent)
+                
+    def add_dirt(self):
+        x_len = len(self.floor_plan)
+        y_len = len(self.floor_plan[0])
+        for i in range(x_len):
+            for j in range(y_len):
+                if(self.floor_plan[i][j] == 1):
+                    chance = random.randint(1, 100)
+                    if(chance < 5):
+                        self.floor_plan[i][j] = 2
+                    
+    
+    def move_agent(self, agent):
+        if agent.direction == 'R':
+            loc = agent.location
+            if self.floor_plan[loc[0]][loc[1] + 1] == 0:
+                agent.bump = True
+            else:
+                agent.location[1] += 1
+        elif agent.direction == 'L':
+            loc = agent.location
+            if self.floor_plan[loc[0]][loc[1] - 1] == 0:
+                agent.bump = True
+            else:
+                agent.location[1] -= 1
+        elif agent.direction == 'U':
+            loc = agent.location
+            if self.floor_plan[loc[0] - 1][loc[1]] == 0:
+                agent.bump = True
+            else:
+                agent.location[0] -= 1
+        elif agent.direction == 'D':
+            loc = agent.location
+            if self.floor_plan[loc[0] + 1][loc[1]] == 0:
+                agent.bump = True
+            else:
+                agent.location[0] += 1
+        return agent.bump
+
+    def step(self):
+        action = agent.program(self.percept(agent))
+        self.add_dirt()
+        self.execute_action(self.agents[0], action)
+
+    def run(self,steps=100):
+        for step in range(steps):
+            self.step()
+    
+    def display_floor(self):
+        print(self.floor_plan)
+
+    def add_agent(self, agent):
+        self.agents.append(agent)
+
+
+env = Environment()
+agent = VacuumAgent(program)
+env.add_agent(agent)
+print("floor before:")
+env.display_floor()
+env.run()
+
+print("floor after:")
+env.display_floor()
+print("performance score: ",agent.performance)
+

floor before:
+[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+ [0 1 1 2 1 1 1 1 1 1 1 1 1 1 0]
+ [0 0 1 0 1 0 1 0 2 2 2 2 2 2 0]
+ [0 0 1 0 1 1 2 1 1 1 1 0 0 0 0]
+ [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]
+floor after:
+[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
+ [0 2 2 2 2 2 1 1 2 2 2 2 2 2 0]
+ [0 0 2 0 1 0 1 0 2 2 2 2 2 2 0]
+ [0 0 2 0 2 2 1 2 2 2 2 0 0 0 0]
+ [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]]
+performance score:  1519
+

+

from search_2 import *
+import numpy as np
+import matplotlib.pyplot as plt
+
+# this file contains a basic implementation of Kruskal's algorithm for MST
+from Graph import *
+import time
+
+
+romania = {'A': ( 76, 497), 'D': (160, 296),
+           'E': (558, 294), 'G': (368, 257),
+           'N': (407, 561), 'R': (227, 412),
+           'T': ( 83, 414), 'V': (535, 473),
+           'O': (117, 580), 'P': (311, 372),
+           'C': (246, 285)}
+
+distances = {}
+cities = []
+
+# fill out distances
+for city in romania.keys():
+    distances[city] = {}
+    cities.append(city)
+
+for name_1, coordinates_1 in romania.items():
+        for name_2, coordinates_2 in romania.items():
+            distances[name_1][name_2] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+            distances[name_2][name_1] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+
+def cost(route):
+    c = 0
+    for i in range(len(route)-1):
+        c += distances[route[i]][route[i+1]]
+    c += distances[route[0]][route[-1]]
+    return c
+
+class TSP(Problem):
+    
+    def is_goal(self, state):
+        return len(state) == len(romania)
+    
+    def actions(self, state): 
+        """The places neighboring `state`."""
+        visited = list(state)
+        unvisited = [x for x in cities if x not in visited]
+        new_states = set()
+        for i in unvisited:
+            new_state = state
+            new_state = new_state + (i,)
+            new_states.add(new_state)
+        return new_states
+        
+    def result(self, state, action):
+        """Go to the `action` place, if the map says that is possible."""
+        return action
+    
+    def action_cost(self, s, action, s1):
+        """The distance (cost) to go from s to s1."""
+        return cost(action)
+
+    def h(self, n):
+        visited = list(n.state)
+        unvisited = [x for x in cities if x not in visited]
+        #print("unvisited", unvisited)
+        # There are three components to this heurisitc:
+        #    1) smallest distance to the nearest unvisited city from the current city
+        current_city = n.state[-1]
+        if not unvisited:
+            return 0
+        min_city = unvisited[0]
+        min_distance_current = distances[current_city][min_city]
+        for c in unvisited:
+            if distances[current_city][c] < min_distance_current:
+                min_distance_current = distances[current_city][c]
+                min_city = c
+        #    2) nearest distance from an unvisited city to the start city
+        start_city = n.state[0]
+        if not unvisited:
+            return 0
+        min_city = unvisited[0]
+        min_distance_start = distances[start_city][min_city]
+        for c in unvisited:
+            if distances[start_city][c] < min_distance_start:
+                min_distance_start = distances[start_city][c]
+                min_city = c
+        #    3) estimated distance to travel all the unvisited cities 
+        #       (MST heuristic used here)
+        rint = {}
+        keys = unvisited
+        for k in range(len(keys)):
+            rint[keys[k]] = k
+            
+        g = Graph(len(keys))
+        for c1 in keys:
+            for c2 in keys:
+                if c1 == c2:
+                    continue
+                g.add_edge(rint[c1], rint[c2], distances[c1][c2])
+
+        mst = g.kruskal_mst()
+        total_weight = 0
+        for u, v, weight in mst:
+            total_weight = total_weight + weight
+        
+        return min_distance_current + min_distance_start + total_weight
+
+    def h_weighted(self, n):
+        return 2*self.h(n)
+        
+
+initial_route = tuple('A')
+
+print("initial route", initial_route)
+print("initial route length", len(initial_route))
+print("initial route cost", cost(initial_route))
+
+def astar_mst(problem): return astar_search(problem, h=problem.h)
+def astar_mst_weighted(problem): return astar_search(problem, h=problem.h_weighted)
+
+r0 = TSP(initial = initial_route)
+t0 = time.time()
+path = path_states(astar_mst_weighted(r0)) 
+t1 = time.time()
+print(path[-1])
+print("weighted astar")
+print("PATH COST", cost(path[-1]))
+print("EX TIME", t1- t0)
+
+t0 = time.time()
+path = path_states(astar_mst(r0)) 
+t1 = time.time()
+print(path[-1])
+print("astar")
+print("PATH COST", cost(path[-1]))
+print("EX TIME", t1- t0)
+
+t0 = time.time()
+path = path_states(uniform_cost_search(r0)) 
+t1 = time.time()
+print(path[-1])
+print("uniform-cost")
+print("PATH COST", cost(path[-1]))
+print("EX TIME", t1- t0)
+
+data = []
+for p in path[-1]:
+    data.append(romania[p])
+data.append(data[0])
+
+x_val = [x[0] for x in data]
+y_val = [x[1] for x in data]
+
+plt.plot(x_val,y_val)
+plt.plot(x_val,y_val,'or')
+plt.show()
+

initial route ('A',)
+initial route length 1
+initial route cost 0.0
+('A', 'T', 'D', 'C', 'R', 'P', 'G', 'E', 'V', 'N', 'O')
+weighted astar
+PATH COST 1573.266727070963
+EX TIME 46.57731533050537
+('A', 'T', 'D', 'C', 'R', 'P', 'G', 'E', 'V', 'N', 'O')
+astar
+PATH COST 1573.266727070963
+EX TIME 73.26921105384827
+('A', 'T', 'D', 'C', 'R', 'P', 'G', 'E', 'V', 'N', 'O')
+uniform-cost
+PATH COST 1573.266727070963
+EX TIME 78.26286435127258
+

report([uniform_cost_search,
+        astar_mst,
+        astar_mst_weighted], [r0]) 
+

uniform_cost_search:
+2,122,246 nodes |  696,159 goal | 9613 cost | 696,168 actions | TSP(('A',), None)
+2,122,246 nodes |  696,159 goal | 9613 cost | 696,168 actions | TOTAL
+
+astar_mst:
+1,482,426 nodes |  446,164 goal | 9613 cost | 446,173 actions | TSP(('A',), None)
+1,482,426 nodes |  446,164 goal | 9613 cost | 446,173 actions | TOTAL
+
+astar_mst_weighted:
+  943,808 nodes |  259,455 goal | 9613 cost | 259,464 actions | TSP(('A',), None)
+  943,808 nodes |  259,455 goal | 9613 cost | 259,464 actions | TOTAL
+
+

from search_2 import *
+from utils import *
+import numpy as np
+import matplotlib.pyplot as plt
+import random
+import time
+from Graph import *
+
+romania = {'A': ( 76, 497), 'B': (400, 327), 'C': (246, 285), 'D': (160, 296), 'E': (558, 294), 
+           'F': (285, 460), 'N': (407, 561), 'S': (187, 463), 'T': ( 83, 414), 'U': (471, 363), 
+           'V': (535, 473)}
+
+distances = {}
+cities = []
+
+for city in romania.keys():
+    distances[city] = {}
+    cities.append(city)
+
+for name_1, coordinates_1 in romania.items():
+        for name_2, coordinates_2 in romania.items():
+            distances[name_1][name_2] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+            distances[name_2][name_1] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+
+def cost(route):
+    c = 0
+    for i in range(len(route)-1):
+        c += distances[route[i]][route[i+1]]
+    c += distances[route[0]][route[-1]]
+    return c
+

class TSP_hill_climbing(Problem):
+
+    def two_opt(self, state):
+        neighbour_state = state[:]
+        left = random.randint(0, len(neighbour_state) - 1)
+        right = random.randint(0, len(neighbour_state) - 1)
+        if left > right:
+            left, right = right, left
+        neighbour_list = list(neighbour_state)
+        x = neighbour_list[left: right + 1]
+        neighbour_list[left: right + 1] = x[::-1]
+        neighbour_state = tuple(neighbour_list)
+        return neighbour_state
+    
+    def best_of_three_split(self, state):
+        neighbour_state = state[:]
+        left = random.randint(0, len(neighbour_state) - 1)
+        right = random.randint(0, len(neighbour_state) - 1)
+        if left > right:
+            left, right = right, left
+            
+        neighbour_list = list(neighbour_state)        
+        one = neighbour_list[: left]
+        two = neighbour_list[left : right]
+        two = two[::-1]
+        three = neighbour_list[right : ]
+
+        joined_states = []
+        costs = []
+        joined_states.append(one + two + three)
+        costs.append(cost(joined_states[-1]))
+        
+        joined_states.append(one + three + two)
+        costs.append(cost(joined_states[-1]))
+
+        joined_states.append(two + one + three)
+        costs.append(cost(joined_states[-1]))
+        
+        joined_states.append(two + three + one)
+        costs.append(cost(joined_states[-1]))
+
+        joined_states.append(three + one + two)
+        costs.append(cost(joined_states[-1]))
+        
+        joined_states.append(three + two + one)
+        costs.append(cost(joined_states[-1]))
+        
+        min_value = min(costs)
+        min_index = costs.index(min_value)
+        neighbour_list = joined_states[min_index]
+        
+        neighbour_state = tuple(neighbour_list)
+        return neighbour_state
+        
+    def is_goal(self, state):
+        return cost(state) < 1603
+    
+    def actions(self, state): 
+        """The places neighboring `state`."""
+        new_states = set()
+        new_states.add(state)
+        for i in range(10):
+            new_state = self.best_of_three_split(state)
+            #new_state = self.two_opt(state)
+            new_states.add(new_state)
+        return new_states
+    
+    def result(self, state, action):
+        """Go to the `action` place, if the map says that is possible."""
+        return action
+    
+    def action_cost(self, s, action, s1):
+        """The distance (cost) to go from s to s1."""
+        if(type(s1) == tuple):
+            return cost(s1)
+        if(type(s1) == list):
+            return cost(tuple(s1))
+       
+
+    def value(self, state):
+        return -1 * self.action_cost(None, None, state)
+
+def hill_climbing(problem):
+    
+    def find_neighbors(state, number_of_neighbors=500):       
+        neighbors = []
+        
+        for i in range(number_of_neighbors):
+            new_state = problem.best_of_three_split(state)
+            #new_state = problem.two_opt(state)
+
+            neighbors.append(Node(new_state))
+            state = new_state
+
+        return neighbors
+
+    # as this is a stochastic algorithm, we will set a cap on the number of iterations
+    iterations = 100
+
+    current = Node(problem.initial)
+    
+    while iterations:
+        neighbors = find_neighbors(current.state)
+        if not neighbors:
+            break
+        neighbor = argmax_random_tie(neighbors,key=lambda node: problem.value(node.state))
+        if problem.value(neighbor.state) >= problem.value(current.state):
+            current.state = neighbor.state
+        iterations -= 1
+        
+    return current.state
+
+
+tsp = TSP_hill_climbing(cities)
+t0 = time.time()
+path = hill_climbing(tsp)
+t1 = time.time()
+print(cost(path))
+print("EX TIME", t1-t0)
+
+data = []
+for p in path:
+    data.append(romania[p])
+data.append(data[0])
+
+x_val = [x[0] for x in data]
+y_val = [x[1] for x in data]
+
+plt.plot(x_val,y_val)
+plt.plot(x_val,y_val,'or')
+plt.show()
+

1369.4886803733975
+EX TIME 1.652334213256836
+

class TSP_graph_search(Problem):
+    
+    def is_goal(self, state):
+        return len(state) == len(romania)
+        
+    def actions(self, state): 
+        """The places neighboring `state`."""
+        visited = list(state)
+        unvisited = [x for x in cities if x not in visited]
+        new_states = set()
+        for i in unvisited:
+            new_state = state
+            new_state = new_state + (i,)
+            new_states.add(new_state)
+        return new_states
+        
+    def result(self, state, action):
+        """Go to the `action` place, if the map says that is possible."""
+        return action
+    
+    def action_cost(self, s, action, s1):
+        """The distance (cost) to go from s to s1."""
+        return cost(action)
+
+    def h(self, n):
+        visited = list(n.state)
+        unvisited = [x for x in cities if x not in visited]
+        #print("unvisited", unvisited)
+        # There are three components to this heurisitc:
+        #    1) smallest distance to the nearest unvisited city from the current city
+        current_city = n.state[-1]
+        if not unvisited:
+            return 0
+        min_city = unvisited[0]
+        min_distance_current = distances[current_city][min_city]
+        for c in unvisited:
+            if distances[current_city][c] < min_distance_current:
+                min_distance_current = distances[current_city][c]
+                min_city = c
+        #    2) nearest distance from an unvisited city to the start city
+        start_city = n.state[0]
+        if not unvisited:
+            return 0
+        min_city = unvisited[0]
+        min_distance_start = distances[start_city][min_city]
+        for c in unvisited:
+            if distances[start_city][c] < min_distance_start:
+                min_distance_start = distances[start_city][c]
+                min_city = c
+        #    3) estimated distance to travel all the unvisited cities 
+        #       (MST heuristic used here)
+        rint = {}
+        keys = unvisited
+        for k in range(len(keys)):
+            rint[keys[k]] = k
+            
+        g = Graph(len(keys))
+        for c1 in keys:
+            for c2 in keys:
+                if c1 == c2:
+                    continue
+                g.add_edge(rint[c1], rint[c2], distances[c1][c2])
+
+        mst = g.kruskal_mst()
+        total_weight = 0
+        for u, v, weight in mst:
+            total_weight = total_weight + weight
+        
+        return min_distance_current + min_distance_start + total_weight
+
+    def h_weighted(self, n):
+        return 2*self.h(n)
+        
+
+initial_route = tuple('A')
+
+print("initial route", initial_route)
+print("initial route length", len(initial_route))
+print("initial route cost", cost(initial_route))
+
+def astar_mst(problem): return astar_search(problem, h=problem.h)
+def astar_mst_weighted(problem): return astar_search(problem, h=problem.h_weighted)
+
+r0 = TSP_graph_search(initial = initial_route)
+t0 = time.time()
+path = path_states(astar_mst_weighted(r0)) 
+t1 = time.time()
+print(path[-1])
+print("weighted astar")
+print("PATH COST", cost(path[-1]))
+print("EX TIME", t1- t0)
+
+t0 = time.time()
+path = path_states(astar_mst(r0)) 
+t1 = time.time()
+print(path[-1])
+print("astar")
+print("PATH COST", cost(path[-1]))
+print("EX TIME", t1- t0)
+
+data = []
+for p in path[-1]:
+    data.append(romania[p])
+data.append(data[0])
+
+x_val = [x[0] for x in data]
+y_val = [x[1] for x in data]
+
+plt.plot(x_val,y_val)
+plt.plot(x_val,y_val,'or')
+plt.show()
+

initial route ('A',)
+initial route length 1
+initial route cost 0.0
+('A', 'T', 'D', 'C', 'B', 'U', 'E', 'V', 'N', 'F', 'S')
+weighted astar
+PATH COST 1369.4886803733978
+EX TIME 43.13364887237549
+('A', 'T', 'D', 'C', 'B', 'U', 'E', 'V', 'N', 'F', 'S')
+astar
+PATH COST 1369.4886803733978
+EX TIME 68.24704599380493
+

+

from utils import *
+
+def init_population(pop_number, gene_pool, state_length):
+    """Initializes population for genetic algorithm
+    pop_number  :  Number of individuals in population
+    gene_pool   :  List of possible values for individuals
+    state_length:  The length of each individual"""
+    g = len(gene_pool)
+    population = []
+    for i in range(pop_number):
+        new_individual = [gene_pool[random.randrange(0, g)] for j in range(state_length)]
+        population.append(new_individual)
+
+    return population
+
+def fitness_threshold(fitness_fn, f_thres, population):
+    if not f_thres:
+        return None
+
+    fittest_individual = max(population, key=fitness_fn)
+    if fitness_fn(fittest_individual) >= f_thres:
+        return fittest_individual
+
+    return None
+
+def genetic_algorithm(population, fitness_fn, gene_pool=[0, 1], f_thres=None, ngen=1000, pmut=0.1):
+    """[Figure 4.8]"""
+    for i in range(ngen):
+        population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, pmut)
+                      for i in range(len(population))]
+
+        fittest_individual = fitness_threshold(fitness_fn, f_thres, population)
+        if fittest_individual:
+            return fittest_individual
+
+
+    return max(population, key=fitness_fn)
+
+def select(r, population, fitness_fn):
+    fitnesses = map(fitness_fn, population)
+    sampler = weighted_sampler(population, fitnesses)
+    return [sampler() for i in range(r)]
+
+def recombine(x, y):
+    n = len(x)
+    c = random.randrange(0, n)
+    return x[:c] + y[c:]
+
+def mutate(x, gene_pool, pmut):
+    if random.uniform(0, 1) >= pmut:
+        return x
+
+    n = len(x)
+    g = len(gene_pool)
+    c = random.randrange(0, n)
+    r = random.randrange(0, g)
+
+    new_gene = gene_pool[r]
+    return x[:c] + [new_gene] + x[c + 1:]
+

target = 'Anthony is cool'
+
+# The ASCII values of uppercase characters ranges from 65 to 91
+u_case = [chr(x) for x in range(65, 91)]
+# The ASCII values of lowercase characters ranges from 97 to 123
+l_case = [chr(x) for x in range(97, 123)]
+
+gene_pool = []
+gene_pool.extend(u_case) # adds the uppercase list to the gene pool
+gene_pool.extend(l_case) # adds the lowercase list to the gene pool
+gene_pool.append(' ')   
+
+max_population = 100
+mutation_rate = 0.07 # 7%
+
+def fitness_fn(sample):
+    # initialize fitness to 0
+    fitness = 0
+    for i in range(len(sample)):
+        # increment fitness by 1 for every matching character
+        if sample[i] == target[i]:
+            fitness += 1
+    return fitness
+
+
+population = init_population(max_population, gene_pool, len(target))
+result = genetic_algorithm(population, fitness_fn, gene_pool, f_thres=None, ngen=1000, pmut=0.1)
+print(result)
+

['A', 'n', 't', 'h', 'o', 'n', 'y', ' ', 'i', 's', ' ', 'c', 'o', 'o', 'l']
+

edges = {
+    'A': [0, 1],
+    'B': [0, 3],
+    'C': [1, 2],
+    'D': [2, 3],
+    'E': [0, 4],
+    'F': [1, 4],
+    'G': [2, 4],
+    'H': [3, 4],
+    'I': [5, 0],
+    'J': [5, 1],
+    'K': [5, 4]
+}
+
+gene_pool = ['R', 'G', 'B', 'Y']
+population = init_population(50, gene_pool, 6)
+
+def fitness(c):
+    return sum(c[n1] != c[n2] for (n1, n2) in edges.values())
+
+solution = genetic_algorithm(population, fitness, gene_pool)
+print(solution)
+

['G', 'B', 'G', 'Y', 'R', 'Y']
+

population = init_population(1000, range(8), 8)
+
+def fitness(q):
+    non_attacking = 0
+    for row1 in range(len(q)):
+        for row2 in range(row1+1, len(q)):
+            col1 = int(q[row1])
+            col2 = int(q[row2])
+            row_diff = row1 - row2
+            col_diff = col1 - col2
+
+            if col1 != col2 and row_diff != col_diff and row_diff != -col_diff:
+                non_attacking += 1
+
+    return non_attacking
+
+solution = genetic_algorithm(population, fitness, f_thres=25, gene_pool=range(8), ngen=1000, pmut = 0.1)
+print(solution)
+print(fitness(solution))
+

[3, 0, 7, 1, 6, 7, 2, 4]
+26
+

from search_2 import *
+from utils import *
+import numpy as np
+import matplotlib.pyplot as plt
+
+romania = {'A': ( 76, 497), 'B': (400, 327), 'C': (246, 285), 'D': (160, 296), 'E': (558, 294), 
+           'F': (285, 460), 'G': (368, 257), 'H': (548, 355), 'I': (488, 535), 'L': (162, 379),
+           'M': (160, 343), 'N': (407, 561), 'O': (117, 580), 'P': (311, 372), 'R': (227, 412),
+           'S': (187, 463), 'T': ( 83, 414), 'U': (471, 363), 'V': (535, 473), 'Z': (92, 539)}
+
+distances = {}
+cities = []
+
+for city in romania.keys():
+    distances[city] = {}
+    cities.append(city)
+
+for name_1, coordinates_1 in romania.items():
+        for name_2, coordinates_2 in romania.items():
+            distances[name_1][name_2] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+            distances[name_2][name_1] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+
+def cost(route):
+    c = 0
+    for i in range(len(route)-1):
+        c += distances[route[i]][route[i+1]]
+    c += distances[route[0]][route[-1]]
+    return c
+
+class TSP(Problem):
+    
+    def two_opt(self, state):
+        neighbour_state = state[:]
+        left = random.randint(0, len(neighbour_state) - 1)
+        right = random.randint(0, len(neighbour_state) - 1)
+        if left > right:
+            left, right = right, left
+        neighbour_list = list(neighbour_state)
+        x = neighbour_list[left: right + 1]
+        neighbour_list[left: right + 1] = x[::-1]
+        neighbour_state = tuple(neighbour_list)
+        return neighbour_state
+        
+    def is_goal(self, state):
+        return cost(state) < 1603
+    
+    def actions(self, state): 
+        """The places neighboring `state`."""
+        new_states = set()
+        new_states.add(state)
+        for i in range(5):
+            new_state = self.two_opt(state)
+            new_states.add(new_state)
+        return new_states
+    
+    def result(self, state, action):
+        """Go to the `action` place, if the map says that is possible."""
+        return action
+    
+    def action_cost(self, s, action, s1):
+        """The distance (cost) to go from s to s1."""
+        if(type(s1) == tuple):
+            return cost(s1)
+        if(type(s1) == list):
+            return cost(tuple(s1))
+       
+
+    def value(self, state):
+        """ value of path cost given negative for the given state """
+        return -1 * self.action_cost(None, None, state)
+
+def hill_climbing(problem):
+    
+    """From the initial node, keep choosing the neighbor with highest value,
+    stopping when no neighbor is better. [Figure 4.2]"""
+    
+    def find_neighbors(state, number_of_neighbors=1000):
+        """ finds neighbors using two_opt method """
+        
+        neighbors = []
+        
+        for i in range(number_of_neighbors):
+            new_state = problem.two_opt(state)
+            neighbors.append(Node(new_state))
+            state = new_state
+
+        return neighbors
+
+    # as this is a stochastic algorithm, we will set a cap on the number of iterations
+    iterations = 10000
+
+    current = Node(problem.initial)
+    
+    while iterations:
+        neighbors = find_neighbors(current.state)
+        if not neighbors:
+            break
+        neighbor = argmax_random_tie(neighbors,key=lambda node: problem.value(node.state))
+        if problem.value(neighbor.state) >= problem.value(current.state):
+            current.state = neighbor.state
+        iterations -= 1
+        
+    return current.state
+
+
+tsp = TSP(cities)
+path = hill_climbing(tsp)
+
+data = []
+for p in path:
+    data.append(romania[p])
+data.append(data[0])
+
+x_val = [x[0] for x in data]
+y_val = [x[1] for x in data]
+
+plt.plot(x_val,y_val)
+plt.plot(x_val,y_val,'or')
+plt.show()
+

from search_2 import *
+
+# My implementation of iterative lengthening search from problem 3.17.
+# I don't really see the point in this algorithm - just use uniform-cost search?
+# Maybe it is for people who want partial solutions???
+
+def best_first_limited_cost_search(problem, f, cost_limit):
+    node = Node(problem.initial)
+    frontier = PriorityQueue([node], key=f)
+    reached = {problem.initial : node}
+    result = failure
+    lowest_path_cost = None;
+    while frontier:
+        node  = frontier.pop()
+        if problem.is_goal(node.state):
+            # we found a solution
+            return node
+        for child in expand(problem, node):
+            s = child.state
+            # if the path_cost is larger than cost_limit, we need to ignore this child.
+            if child.path_cost > cost_limit:
+                if lowest_path_cost == None or child.path_cost < lowest_path_cost:
+                    lowest_path_cost = child.path_cost
+                    result = Node('cost_limit_reached',
+                                  path_cost = lowest_path_cost,
+                                  parent = node)
+            elif s not in reached or child.path_cost < reached[s].path_cost:
+                reached[s] = child
+                frontier.add(child)
+    return result
+
+def iterative_lengthening_search(problem):
+    n = best_first_limited_cost_search(problem, g, 0)
+    iteration = 0
+    while(n.state == 'cost_limit_reached'):
+        n = best_first_limited_cost_search(problem, g, n.path_cost)
+        iteration = iteration + 1
+        print(path_states(n))
+    print(iteration)
+    return n
+

romania = Map(
+    {('O', 'Z'):  71, ('O', 'S'): 151, ('A', 'Z'): 75, ('A', 'S'): 140, ('A', 'T'): 118, 
+     ('L', 'T'): 111, ('L', 'M'):  70, ('D', 'M'): 75, ('C', 'D'): 120, ('C', 'R'): 146, 
+     ('C', 'P'): 138, ('R', 'S'):  80, ('F', 'S'): 99, ('B', 'F'): 211, ('B', 'P'): 101, 
+     ('B', 'G'):  90, ('B', 'U'):  85, ('H', 'U'): 98, ('E', 'H'):  86, ('U', 'V'): 142, 
+     ('I', 'V'):  92, ('I', 'N'):  87, ('P', 'R'): 97},
+    {'A': ( 76, 497), 'B': (400, 327), 'C': (246, 285), 'D': (160, 296), 'E': (558, 294), 
+     'F': (285, 460), 'G': (368, 257), 'H': (548, 355), 'I': (488, 535), 'L': (162, 379),
+     'M': (160, 343), 'N': (407, 561), 'O': (117, 580), 'P': (311, 372), 'R': (227, 412),
+     'S': (187, 463), 'T': ( 83, 414), 'U': (471, 363), 'V': (535, 473), 'Z': (92, 539)})
+
+r1 = RouteProblem('A', 'B', map=romania)
+r2 = RouteProblem('N', 'L', map=romania)
+r3 = RouteProblem('E', 'T', map=romania)
+r4 = RouteProblem('O', 'M', map=romania)
+

path_states(iterative_lengthening_search(r1))
+path_states(iterative_lengthening_search(r2))
+path_states(iterative_lengthening_search(r3))
+path_states(iterative_lengthening_search(r4))
+

['A', 'cost_limit_reached']
+['A', 'cost_limit_reached']
+['A', 'Z', 'cost_limit_reached']
+['A', 'Z', 'cost_limit_reached']
+['A', 'Z', 'O', 'cost_limit_reached']
+['A', 'S', 'cost_limit_reached']
+['A', 'T', 'cost_limit_reached']
+['A', 'T', 'cost_limit_reached']
+['A', 'S', 'cost_limit_reached']
+['A', 'S', 'cost_limit_reached']
+['A', 'S', 'cost_limit_reached']
+['A', 'Z', 'O', 'cost_limit_reached']
+['A', 'T', 'L', 'cost_limit_reached']
+['A', 'S', 'R', 'cost_limit_reached']
+['A', 'S', 'R', 'cost_limit_reached']
+['A', 'S', 'F', 'cost_limit_reached']
+['A', 'T', 'L', 'cost_limit_reached']
+['A', 'S', 'R', 'cost_limit_reached']
+['A', 'T', 'L', 'M', 'cost_limit_reached']
+['A', 'T', 'L', 'M', 'cost_limit_reached']
+['A', 'S', 'R', 'P', 'cost_limit_reached']
+['A', 'S', 'R', 'P', 'cost_limit_reached']
+['A', 'S', 'R', 'P', 'B']
+23
+['N', 'I', 'cost_limit_reached']
+['N', 'I', 'cost_limit_reached']
+['N', 'I', 'V', 'cost_limit_reached']
+['N', 'I', 'V', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'H', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'H', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'G', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'H', 'E', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'F', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'S', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'S', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'F', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'S', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'D', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'D', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'S', 'A', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'R', 'S', 'O', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'D', 'M', 'cost_limit_reached']
+['N', 'I', 'V', 'U', 'B', 'P', 'C', 'D', 'M', 'L']
+35
+['E', 'H', 'cost_limit_reached']
+['E', 'H', 'cost_limit_reached']
+['E', 'H', 'U', 'cost_limit_reached']
+['E', 'H', 'U', 'cost_limit_reached']
+['E', 'H', 'U', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'cost_limit_reached']
+['E', 'H', 'U', 'V', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'G', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'cost_limit_reached']
+['E', 'H', 'U', 'V', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'cost_limit_reached']
+['E', 'H', 'U', 'V', 'I', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'cost_limit_reached']
+['E', 'H', 'U', 'V', 'I', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'F', 'cost_limit_reached']
+['E', 'H', 'U', 'V', 'I', 'N', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'F', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'D', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'D', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'A', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'O', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'D', 'M', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'C', 'D', 'M', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'A', 'cost_limit_reached']
+['E', 'H', 'U', 'B', 'P', 'R', 'S', 'A', 'T']
+37
+['O', 'Z', 'cost_limit_reached']
+['O', 'Z', 'cost_limit_reached']
+['O', 'cost_limit_reached']
+['O', 'Z', 'A', 'cost_limit_reached']
+['O', 'S', 'cost_limit_reached']
+['O', 'S', 'cost_limit_reached']
+['O', 'Z', 'A', 'cost_limit_reached']
+['O', 'Z', 'A', 'cost_limit_reached']
+['O', 'S', 'cost_limit_reached']
+['O', 'S', 'cost_limit_reached']
+['O', 'S', 'R', 'cost_limit_reached']
+['O', 'S', 'R', 'cost_limit_reached']
+['O', 'S', 'F', 'cost_limit_reached']
+['O', 'Z', 'A', 'T', 'cost_limit_reached']
+['O', 'S', 'R', 'cost_limit_reached']
+['O', 'Z', 'A', 'T', 'cost_limit_reached']
+['O', 'S', 'R', 'P', 'cost_limit_reached']
+['O', 'S', 'R', 'P', 'cost_limit_reached']
+['O', 'Z', 'A', 'T', 'L', 'cost_limit_reached']
+['O', 'Z', 'A', 'T', 'L', 'M']
+20
+

['O', 'Z', 'A', 'T', 'L', 'M']

from search_2 import *
+import numpy as np
+import matplotlib.pyplot as plt
+
+romania = {'A': ( 76, 497), 'D': (160, 296),
+           'E': (558, 294), 'G': (368, 257),
+           'N': (407, 561), 'R': (227, 412),
+           'T': ( 83, 414), 'V': (535, 473),
+           'O': (117, 580), 'P': (311, 372),
+           'C': (246, 285), 'F': (285, 460)}
+
+distances = {}
+
+a_good_path = ('T', 'A', 'O', 'R', 'P', 'F', 'N', 'V', 'E', 'G', 'C', 'D')
+
+for city in romania.keys():
+    distances[city] = {}
+
+for name_1, coordinates_1 in romania.items():
+        for name_2, coordinates_2 in romania.items():
+            distances[name_1][name_2] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+            distances[name_2][name_1] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+
+def cost(route):
+    c = 0
+    for i in range(len(route)-1):
+        c += distances[route[i]][route[i+1]]
+    c += distances[route[0]][route[-1]]
+    return c
+
+class TSP(Problem):
+    
+    def two_opt(self, state):
+        neighbour_state = state[:]
+        left = random.randint(0, len(neighbour_state) - 1)
+        right = random.randint(0, len(neighbour_state) - 1)
+        if left > right:
+            left, right = right, left
+        neighbour_list = list(neighbour_state)
+        x = neighbour_list[left: right + 1]
+        neighbour_list[left: right + 1] = x[::-1]
+        neighbour_state = tuple(neighbour_list)
+        return neighbour_state
+        
+    def is_goal(self, state):
+        return cost(state) < 1603
+    
+    def actions(self, state): 
+        """The places neighboring `state`."""
+        new_states = set()
+        for i in range(6):
+            new_state = self.two_opt(state)
+            new_states.add(new_state)
+        return new_states
+    
+    def result(self, state, action):
+        """Go to the `action` place, if the map says that is possible."""
+        return action
+    
+    def action_cost(self, s, action, s1):
+        """The distance (cost) to go from s to s1."""
+        if(type(action) == tuple):
+            return cost(action)
+
+
+initial_route = list(romania.keys())
+random.shuffle(initial_route)
+
+initial_route = tuple(initial_route)
+
+print("initial route", initial_route)
+print("initial route cost", cost(initial_route))
+print("a_good_path", a_good_path)
+print("a_good_path cost", cost(a_good_path))
+
+r0 = TSP(initial = initial_route)
+path = path_states(uniform_cost_search(r0)) 
+print(path[-1])
+print(cost(path[-1]))
+
+data = []
+for p in a_good_path:
+    data.append(romania[p])
+data.append(data[0])
+
+x_val = [x[0] for x in data]
+y_val = [x[1] for x in data]
+
+plt.plot(x_val,y_val)
+plt.plot(x_val,y_val,'or')
+plt.show()
+

initial route ('N', 'V', 'T', 'O', 'R', 'F', 'P', 'G', 'C', 'E', 'A', 'D')
+initial route cost 2817.232683928372
+a_good_path ('T', 'A', 'O', 'R', 'P', 'F', 'N', 'V', 'E', 'G', 'C', 'D')
+a_good_path cost 1602.00375849783
+('G', 'E', 'V', 'N', 'F', 'P', 'R', 'O', 'A', 'T', 'D', 'C')
+1602.0037584978302
+

+

+

""" The goal of this code is to take a collection of polygons
+    and returns a path that traverses the obstacles """
+
+from search_2 import *
+# This is not part of the aima-python repo.
+# I took the code from "search4e.ipynb" and
+# pasted it into a file called search_2 :)
+
+from matplotlib.patches import Polygon
+
+polygons = [[(1,1)],
+            [(2,2), (4,2), (4,4), (2,4), (1,3)],
+            [(3,6), (6,6), (6,9)],
+            [(10,2), (12,2), (12,14), (10,14)],
+            [(13,4), (14,4), (14,12), (13,12)],
+            [(8,1), (9,1), (9,10), (8,10)],
+            [(6,12), (9,12), (9,13), (6,13)],
+            [(3,9), (5,9), (4,12), (2,12)],
+            [(7.5,10.5), (8.5,10.5), (8.5,11), (7.5,11)],
+            [(14,14)]]
+
+start = polygons[0][0]
+end = polygons[-1][0]
+
+polygon_plot = []
+
+for p in polygons:
+    polygon_plot.append(Polygon(p, facecolor = 'y'))
+
+
+fig,ax = plt.subplots()
+
+# begin
+ax.plot(start[0], start[1],'-ro')
+# end
+ax.plot(end[0], end[1],'-yo')
+
+for p in polygon_plot:
+    ax.add_patch(p)
+
+ax.set_xlim([0,15])
+ax.set_ylim([0,15])
+plt.show()
+

def line_intersection(a, b, c, d):
+    denom = ((a[0] - b[0]) * (c[1] - d[1]) - (a[1] - b[1]) * (c[0] - d[0]))
+    if denom == 0:
+        return False
+    t = ((a[0] - c[0]) * (c[1] - d[1]) - (a[1] - c[1]) * (c[0] - d[0])) / denom
+    u = ((a[0] - c[0]) * (a[1] - b[1]) - (a[1] - c[1]) * (a[0] - b[0])) / denom
+    # check if line actually intersect
+    if (0 <= t and t <= 1 and 0 <= u and u <= 1):
+        return [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])]
+    else: 
+        return False
+
+def distance2(a,b):
+    return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
+
+D = dict()
+
+def intersection(u, v):
+    for p in polygons:
+        N = len(p)
+        r = distance2(u,v)
+        for i in range(N):
+            if(i < N - 1):
+                z = line_intersection(u, v, p[i], p[i+1])
+            if(i == N - 1):
+                z = line_intersection(u, v, p[N-1], p[0])
+            if(z):
+                r2 = distance2(u,z)
+                if(r2 < r and r2 > 0):
+                    return True
+    return False
+
+def self_intersection(p):
+    N = len(p)
+    if(N < 4):
+        return
+    for i in range(N-2):
+        D[(p[i],p[i+2])] = True
+        D[(p[i+2],p[i])] = True
+    D[(p[N-2],p[0])] = True
+    D[(p[N-1],p[1])] = True
+    D[(p[0],p[N-2])] = True
+    D[(p[1],p[N-1])] = True
+    
+for p in polygons:
+    for q in polygons:
+        if p == q:
+            # We assume that the obstacles are convex
+            # we need to revisit this function otherwise :)
+            self_intersection(p)
+            continue
+        for u in p:
+            for v in q:
+                # We need to check if (u, v) intersects any polygon.
+                # u and v are guaranteed to be on different polygons.
+                if(intersection(u,v)):
+                    D[(u,v)] = True
+

vertices = [x for xs in polygons for x in xs]
+

DD = dict()
+for x in vertices:
+    for y in vertices:
+        DD[(x,y)] = True
+

for i in D:
+    if(D[i]):
+        DD[i] = False
+
+lines = []
+for i in DD:
+    if(DD[i]):
+        lines.append(i)
+

from matplotlib import collections  as mc
+
+polygon_plot = []
+
+for p in polygons:
+    polygon_plot.append(Polygon(p, facecolor = 'y'))
+
+
+fig,ax = plt.subplots()
+
+# begin
+ax.plot(start[0], start[1],'-ro')
+# end
+ax.plot(end[0], end[1],'-yo')
+
+for p in polygon_plot:
+    ax.add_patch(p)
+
+lc = mc.LineCollection(lines, linewidths=0.5)
+ax.add_collection(lc)
+
+ax.set_xlim([0,15])
+ax.set_ylim([0,15])
+
+plt.show()
+

path_finder_map = dict()
+locations = dict()
+
+for i in DD:
+    if(DD[i]):
+        r = math.sqrt(distance2(i[0],i[1]))
+        if r < 0.000001:
+            continue
+        path_finder_map[(i[0],i[1])] = r
+
+for i in vertices:
+    locations[i] = i
+
+path_finder = Map(path_finder_map,locations)
+route_problem = RouteProblem((1,1), (14,14), map=path_finder)
+
+
+# Heuristic
+def h(n):
+    return math.sqrt(distance2(n.state, (14,14))) 
+

%%timeit
+uniform_cost_search_route = path_states(uniform_cost_search(route_problem)) 
+

725 μs ± 5.75 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
+

%%timeit
+breadth_first_search_route = path_states(breadth_first_search(route_problem))
+

443 μs ± 7.8 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
+

%%timeit
+depth_limited_search_route = path_states(depth_limited_search(route_problem))
+

2.41 ms ± 34.8 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
+

%%timeit
+astar_search_route = path_states(astar_search(route_problem, h))
+

539 μs ± 11.9 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
+

%%timeit
+weighted_astar_search_route = path_states(weighted_astar_search(route_problem, h))
+

237 μs ± 4.39 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
+

from matplotlib import collections  as mc
+
+polygon_plot = []
+
+for p in polygons:
+    polygon_plot.append(Polygon(p, facecolor = 'y'))
+
+
+fig,ax = plt.subplots()
+
+# begin
+ax.plot(start[0], start[1],'-ro')
+# end
+ax.plot(end[0], end[1],'-yo')
+
+for p in polygon_plot:
+    ax.add_patch(p)
+
+plt.plot(*zip(*uniform_cost_search_route), color='r')
+plt.plot(*zip(*breadth_first_search_route), color='b')
+plt.plot(*zip(*depth_limited_search_route), color='c')
+plt.plot(*zip(*astar_search_route), color='g', linestyle='--')
+plt.plot(*zip(*weighted_astar_search_route), color='m')
+
+ax.set_xlim([0,15])
+ax.set_ylim([0,15])
+
+plt.show()
+

def calculate_path_cost(path):
+    cost = 0
+    N = len(path)
+    for i in range(N-1):
+        cost += math.sqrt(distance2(path[i], path[i+1]))
+    return cost
+

uniform_cost_search_cost = calculate_path_cost(uniform_cost_search_route)
+breadth_first_search_cost = calculate_path_cost(breadth_first_search_route)
+depth_limited_search_cost = calculate_path_cost(depth_limited_search_route)
+astar_search_cost = calculate_path_cost(astar_search_route)
+weighted_astar_search_cost = calculate_path_cost(weighted_astar_search_route)
+print(uniform_cost_search_cost)
+print(breadth_first_search_cost)
+print(depth_limited_search_cost)
+print(astar_search_cost)
+print(weighted_astar_search_cost)
+

20.37120691423263
+25.162277660168378
+34.5672465993875
+20.37120691423263
+20.62154290428604
+

report([uniform_cost_search, 
+        breadth_first_search, 
+        depth_limited_search,
+        astar_search, 
+        weighted_astar_search], [route_problem])
+

uniform_cost_search:
+      319 nodes |       45 goal |   20 cost |      51 actions | RouteProblem((1, 1), (14, 14))
+      319 nodes |       45 goal |   20 cost |      51 actions | TOTAL
+
+breadth_first_search:
+      207 nodes |      208 goal |   25 cost |      34 actions | RouteProblem((1, 1), (14, 14))
+      207 nodes |      208 goal |   25 cost |      34 actions | TOTAL
+
+depth_limited_search:
+      618 nodes |      570 goal |   35 cost |      93 actions | RouteProblem((1, 1), (14, 14))
+      618 nodes |      570 goal |   35 cost |      93 actions | TOTAL
+
+astar_search:
+      197 nodes |       27 goal |   20 cost |      33 actions | RouteProblem((1, 1), (14, 14))
+      197 nodes |       27 goal |   20 cost |      33 actions | TOTAL
+
+weighted_astar_search:
+       70 nodes |       11 goal |   21 cost |      17 actions | RouteProblem((1, 1), (14, 14))
+       70 nodes |       11 goal |   21 cost |      17 actions | TOTAL
+
+

# remember that search_2 file is a file that I generated that 
+# used the data structures that work with the 4th edition code.
+# you will need to visit my github repo https://github.com/hmp-anthony
+# to access it.
+from search_2 import *
+from utils import *
+import numpy as np
+import matplotlib.pyplot as plt
+
+romania = {'A': ( 76, 497), 'B': (400, 327), 'C': (246, 285), 'D': (160, 296), 'E': (558, 294), 
+           'F': (285, 460), 'G': (368, 257), 'H': (548, 355), 'I': (488, 535), 'L': (162, 379),
+           'M': (160, 343), 'N': (407, 561), 'O': (117, 580), 'P': (311, 372), 'R': (227, 412),
+           'S': (187, 463), 'T': ( 83, 414), 'U': (471, 363), 'V': (535, 473), 'Z': (92, 539)}
+
+distances = {}
+cities = []
+
+for city in romania.keys():
+    distances[city] = {}
+    cities.append(city)
+
+for name_1, coordinates_1 in romania.items():
+        for name_2, coordinates_2 in romania.items():
+            distances[name_1][name_2] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+            distances[name_2][name_1] = np.linalg.norm(
+                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])
+
+def cost(route):
+    c = 0
+    for i in range(len(route)-1):
+        c += distances[route[i]][route[i+1]]
+    c += distances[route[0]][route[-1]]
+    return c
+
+class TSP(Problem):
+    
+    def two_opt(self, state):
+        neighbour_state = state[:]
+        left = random.randint(0, len(neighbour_state) - 1)
+        right = random.randint(0, len(neighbour_state) - 1)
+        if left > right:
+            left, right = right, left
+        neighbour_list = list(neighbour_state)
+        x = neighbour_list[left: right + 1]
+        neighbour_list[left: right + 1] = x[::-1]
+        neighbour_state = tuple(neighbour_list)
+        return neighbour_state
+        
+    def is_goal(self, state):
+        return cost(state) < 1603
+    
+    def actions(self, state): 
+        """The places neighboring `state`."""
+        new_states = []
+        new_states.append(state)
+        for i in range(10):
+            new_state = self.two_opt(state)
+            new_states.append(new_state)
+        return new_states
+    
+    def result(self, state, action):
+        """Go to the `action` place, if the map says that is possible."""
+        return action
+    
+    def action_cost(self, s, action, s1):
+        """The distance (cost) to go from s to s1."""
+        if(type(s1) == tuple):
+            return cost(s1)
+        if(type(s1) == list):
+            return cost(tuple(s1))
+       
+
+    def value(self, state):
+        """ value of path cost given negative for the given state """
+        return -1 * self.action_cost(None, None, state)
+
+
+def exp_schedule(k=20, lam=0.15, limit=4000):
+    """One possible schedule function for simulated annealing"""
+    return lambda t: (k * math.exp(-lam * t) if t < limit else 0)
+
+
+def simulated_annealing(problem, schedule=exp_schedule()):
+    """[Figure 4.5] CAUTION: This differs from the pseudocode as it
+    returns a state instead of a Node."""
+    current = Node(problem.initial)
+    for t in range(sys.maxsize):
+        T = schedule(t)
+        if T == 0:
+            return current.state
+        neighbors = expand_and_return_node_list(problem, current)
+        if not neighbors:
+            return current.state
+        next_choice = random.choice(neighbors)
+        delta_e = problem.value(next_choice.state) - problem.value(current.state)
+        if delta_e > 0 or probability(math.exp(delta_e / T)):
+            current = next_choice
+
+
+tsp = TSP(cities)
+path = simulated_annealing(tsp)
+
+data = []
+for p in path:
+    data.append(romania[p])
+data.append(data[0])
+
+x_val = [x[0] for x in data]
+y_val = [x[1] for x in data]
+
+plt.plot(x_val,y_val)
+plt.plot(x_val,y_val,'or')
+plt.show()
+

+

+

from search_2 import *
+import time
+from agents import *
+import numpy as np
+
+N = 100
+
+# First we code up the search agent
+class VacuumSearch(Problem):
+    def __init__(self, initial=(0,0), goal=None, dirt=[], **kwds):
+        Problem.__init__(self, initial=initial, goal=goal, dirt=dirt, **kwds)
+        self.dirt = dirt
+        
+    directions = [(-1, 0), (+1, 0), (0, +1), (0, -1)]
+
+    def action_cost(self, s, action, s1):
+        if s == s1:
+            return -100
+        return 1
+    
+    def is_goal(self, state):
+        return self.dirt == []
+
+    def result(self, state, action):
+        return action
+    
+    def actions(self, state):
+        if state in self.dirt:
+            self.dirt.remove(state)
+            S = {(state[0],state[1])}
+            return S
+        x, y = state
+        S = {(x + dx, y + dy) for (dx, dy) in self.directions}
+        Z = {x for x in S if x[0] in range(N) and x[1] in range(N)}
+        return Z
+
+class VacuumAgent(Agent):
+
+    def __init__(self, program = None):
+        super().__init__(program)
+        self.location = [0, 0]
+        self.direction = 'R' # 'R', 'L', 'U', 'D'
+
+# The agent should have no knowledge of the dirt distribution.
+# The environment has the dirt distribution. 
+def program(percept):
+    if percept:
+        return ('Suck','None')
+    else:
+        bump = 'Bump' if agent.bump else 'None'
+        return ('Move', bump)
+
+class Environment:
+    
+    def __init__(self, dirt):
+        self.agents = []
+        self.dirt = dirt
+        
+    def percept(self, agent):
+        loc = agent.location
+        s = (loc[0], loc[1])
+        return s in self.dirt
+
+    def execute_action(self, agent, action):
+        if action[0] == 'Suck':
+            loc = agent.location
+            s = (loc[0], loc[1])
+            self.dirt.remove(s)
+            agent.performance -= 100
+        if action[0] == 'Move':
+            agent.performance += 1
+            if action[1] == 'Bump':
+                agent.bump = False
+            else:
+                agent.direction = random.choice(['R', 'L', 'U', 'D'])
+                agent.bump = self.move_agent(agent)
+
+    def move_agent(self, agent):
+        loc = agent.location
+        if agent.direction == 'R':
+            if loc[0] + 1 == N:
+                agent.bump = True
+            else:
+                agent.location[0] += 1
+        elif agent.direction == 'L':
+            if loc[0] - 1 == -1:
+                agent.bump = True
+            else:
+                agent.location[0] -= 1
+        elif agent.direction == 'U':
+            if loc[1] + 1 == N:
+                agent.bump = True
+            else:
+                agent.location[1] += 1
+        elif agent.direction == 'D':
+            if loc[1] - 1 == -1:
+                agent.bump = True
+            else:
+                agent.location[1] -= 1
+        return agent.bump
+
+    def step(self):
+        action = agent.program(self.percept(agent))
+        self.execute_action(self.agents[0], action)
+        #print(self.agents[0].location, self.agents[0].bump, self.agents[0].direction)
+        
+    def run(self, steps=100000000):
+        for step in range(steps): 
+            if not self.dirt:
+                print("\tall dirt found")
+                break
+            self.step()
+
+
+    def add_agent(self, agent):
+        self.agents.append(agent)
+

# We are going to compare the performace between 
+# a search agent and a random reflex agent
+
+k = int(0.2 * N)
+dirt = [(x,y) for x in range(N) for y in range(N)]
+dirt = random.sample(dirt, k=k)
+
+v = VacuumSearch(dirt=dirt.copy())
+
+# execution time
+t0 = time.time()
+u1 = uniform_cost_search(v)
+t1 = time.time()
+print("The search agent takes: ", t1-t0)
+print("With path cost: ", u1.path_cost) 
+
+env = Environment(dirt.copy())
+agent = VacuumAgent(program)
+env.add_agent(agent)
+
+t0 = time.time()
+env.run()
+t1 = time.time()
+print("The random reflex agent takes: ", t1-t0)
+print("With path cost: ", agent.performance)
+

The search agent takes:  0.8268561363220215
+With path cost:  -1399
+	all dirt found
+The random reflex agent takes:  0.44652366638183594
+With path cost:  239009
+

# Time taken
+T = [(5, 0.0005152, 0.000409),
+     (10, 0.01320, 0.000814),
+     (50, 0.36978, 0.052511),
+     (100, 0.36709, 0.29217),
+     (150, 2.041389, 1.267393),
+     (200, 2.98996, 1.4945),
+     (300, 9.1033, 4.1168),
+     (400, 15.87725, 10.9956),
+     (500, 26.3129, 19.18689),
+     (600, 48.5008, 22.227),
+     (700, 71.76588, 36.5527)]
+

x_val = [x[0] for x in T]
+y1_val = [x[1] for x in T]
+y2_val = [x[2] for x in T]
+
+plt.plot(x_val,y1_val)
+plt.plot(x_val,y1_val,'or')
+
+plt.plot(x_val,y2_val)
+plt.plot(x_val,y2_val,'or')
+
+plt.title("Execution Time")
+plt.xlabel("Size of square grid")
+plt.ylabel("Time taken (seconds)")
+
+plt.show()
+

+

import requests
+from bs4 import BeautifulSoup
+
+from search_2 import *
+
+start_url = "https://flatspot.com"
+end_url = "https://support.google.com/youtube/answer/3399767?hl=en&ref_topic=9282365"
+
+def extract_links(url):
+    links = []
+    source_url = requests.get(url)
+    soup = BeautifulSoup(source_url.content, "html.parser")
+    for link in soup.find_all('a',href=True):
+        if link.get('href').startswith("https://") and link.get("href") not in links:
+            links.append(link.get('href'))
+
+    return links
+
+class WebPageProblem(Problem):
+    def __init__(self, initial=start_url, goal=end_url, **kwds):
+        Problem.__init__(self, initial=initial, goal=goal, **kwds)
+
+    def result(self, state, action):
+        return action
+
+    def actions(self, state):
+        links = extract_links(state)
+        return links
+
+
+w = WebPageProblem(start_url, end_url)
+print(path_states(breadth_first_search(w)))
+

['https://flatspot.com', 'https://youtube.com/channel/UCXhZ35FXbrWJ8jnql3Zootg', 'https://www.youtube.com/about/policies/', 'https://support.google.com/youtube/answer/3399767?hl=en&ref_topic=9282365']
+