Added search strategis

Author: snrazavi

Search/01-Search_Problem_Formulation_NPuzzle.ipynb

@@ -0,0 +1,103 @@
+import math
+import matplotlib.pyplot as plt
+
+
+class NPuzzleState:
+    
+    def __init__(self, N=8, tiles=None):
+        if tiles is None:
+            self.tiles = tuple(range(N + 1))  # [0, 1, 2, ..., N] and 0 is blank
+        else:
+            N = len(tiles) - 1
+            self.tiles = tuple(tiles[:])
+        
+        self.N = N
+        self.grid_size = int(math.sqrt(N + 1))  # for 8-puzzle, this is 3x3
+            
+    def successors(self):
+        ''' Returns a list of possible actions, their costs and their resulting states.
+        '''
+        
+        blank_idx = self.tiles.index(0)
+        successors = []
+        
+        # left
+        if blank_idx % self.grid_size > 0:
+            tiles = list(self.tiles)
+            tiles[blank_idx], tiles[blank_idx - 1] = tiles[blank_idx - 1], tiles[blank_idx]
+            successor = NPuzzleState(tiles=tiles)
+            successors.append((successor, 'Left', 1))
+        
+        # up
+        if blank_idx >= self.grid_size:
+            tiles = list(self.tiles)
+            tiles[blank_idx], tiles[blank_idx - self.grid_size] = tiles[blank_idx - self.grid_size], tiles[blank_idx]
+            successor = NPuzzleState(tiles=tiles)
+            successors.append((successor, 'Up', 1))
+        
+        # right
+        if blank_idx % self.grid_size < self.grid_size - 1:
+            tiles = list(self.tiles)
+            tiles[blank_idx], tiles[blank_idx + 1] = tiles[blank_idx + 1], tiles[blank_idx]
+            successor = NPuzzleState(tiles=tiles)
+            successors.append((successor, 'Right', 1))
+            
+        # down
+        if blank_idx + self.grid_size < len(self.tiles):
+            tiles = list(self.tiles)
+            tiles[blank_idx], tiles[blank_idx + self.grid_size] = tiles[blank_idx + self.grid_size], tiles[blank_idx]
+            successor = NPuzzleState(tiles=tiles)
+            successors.append((successor, 'Down', 1))
+        
+        return successors
+    
+    def is_goal(self, goal_state):
+        return self == goal_state
+    
+    def plot(self, ax=None, title=None, fs=20):
+        if ax is None:
+            fig, ax = plt.subplots(1)
+            
+        size = 10
+        gs = self.grid_size
+        
+        # draw border
+        border = plt.Rectangle((0, 0), gs * size, gs * size, ec='k', fc='w', lw=3)
+        ax.add_patch(border)
+        
+        # draw tiles
+        for i, tile in enumerate(self.tiles):
+            if tile == 0: continue
+            col = self.grid_size - 1 - i // self.grid_size
+            row = i %  self.grid_size
+            cell = plt.Rectangle((row * size, col * size), size, size, fc='gray', ec='k', lw=3)
+            ax.add_patch(cell)
+            ax.text(row * size + size//2, col * size + size//2, "%d" % tile, color='w', 
+                    fontsize=fs, verticalalignment='center', horizontalalignment='center')
+        
+        ax.axis('square')
+        ax.axis('off')
+        if title:
+            ax.set_title(title, fontsize=fs)
+            
+    def __hash__(self):
+        return hash(self.tiles)
+    
+    def __eq__(self, other):
+        if self is other: return True  # True object equallity test for efficiency
+        if not isinstance(other, NPuzzleState): return False
+        
+        return self.tiles == other.tiles
+    
+    def __str__(self):
+        """ An string representation of the tiles configuration in 2d format.
+        """
+        result = ''
+        for i in range(len(self.tiles)):
+            result += f' {self.tiles[i]:2d} ' if self.tiles[i] != 0 else '    '
+            if i % self.grid_size == self.grid_size - 1 and i < self.N:
+                result += '\n'
+        return result
+    
+    def __repr__(self):
+        return f'NPuzzleState(N={self.N}, tiles={self.tiles})'

Search/02-Data_Structures.ipynb

@@ -0,0 +1,164 @@
+import math
+import heapq, random
+
+import matplotlib.pyplot as plt
+
+
+def print_solution(start_state, path):
+    if path is None:
+        print("No solution found!")
+        return
+    
+    print(start_state)
+    for state, action in path:
+        print("\n {} \n".format(action))
+        print(state)
+
+
+def show_solution(start_state, path, ncols=5):
+    if not isinstance(path, list):
+        print("No solution found!")
+        return
+    
+    N = len(path) + 1
+    nrows = int(math.ceil(N / ncols))
+    
+    fig, axes = plt.subplots(nrows, ncols, figsize=(3 * ncols, 3 * nrows))
+    
+    if nrows > 1:
+        start_state.plot(axes[0][0], 'start', 18)
+        for i, (state, action) in enumerate(path):
+            state.plot(axes[(i + 1) // ncols][(i + 1) % ncols], action, 18)
+        for i in range(N, nrows * ncols):
+            axes[nrows-1][i % ncols].axis('off')
+    
+    else:
+        start_state.plot(axes[0], 'start', 18)
+        for i, (state, action) in enumerate(path):
+            state.plot(axes[i + 1], action, 18)
+        for i in range(N, ncols):
+            axes[i].axis('off')
+
+
+def solution(node):
+    path = []
+    while node.parent is not None:
+        path = [(node.state, node.action)] + path
+        node = node.parent
+    return path
+
+
+def manhatan_distance(tile, state1, state2):
+    i = state1.tiles.index(tile)
+    j = state2.tiles.index(tile)
+    
+    gs = state1.grid_size
+    
+    row_i, col_i = i // gs, i % gs
+    row_j, col_j = j // gs, j % gs
+    
+    return abs(row_i - row_j) + abs(col_i - col_j)
+
+
+"""
+ Data structures useful for implementing Search Strategies
+"""
+
+class Stack:
+    def __init__(self, items=None):
+        self._items = []
+        
+        if items:
+            for item in items:
+                self.push(item)
+    
+    def push(self, item):
+        '''Add to the end'''
+        self._items.append(item)
+    
+    def pop(self):
+        '''Remove from end'''
+        try:
+            item = self._items.pop()
+            return item
+        except:
+            print('ERROR! trying to pop an element from an empty stack.')
+                
+    
+    def is_empty(self):
+        return len(self._items) == 0
+    
+    def __repr__(self):
+        return f'Stack(items={self._items})'
+    
+    def __str__(self):
+        return f"[{', '.join(self._items)}]"
+    
+
+class Queue:
+    def __init__(self, items=None):
+        self._items = []
+        
+        if items:
+            for item in items:
+                self.push(item)
+    
+    def push(self, item):
+        '''Add to the rear'''
+        self._items.append(item)
+    
+    def pop(self):
+        '''Remove from front'''
+        try:
+            item = self._items[0]
+            self._items = self._items[1:]
+            return item
+        except:
+            print('ERROR! trying to pop an element from an empty queue.')
+                
+    
+    def is_empty(self):
+        return len(self._items) == 0
+    
+    def __repr__(self):
+        return f'Queue(items={self._items})'
+    
+    def __str__(self):
+        return f"[{', '.join(self._items)}]"
+    
+
+class PriorityQueue:
+    def __init__(self, items=None):
+        self._items = []
+        self.index = 0
+        
+        if items:
+            for item, priority in items:
+                self.push(item, priority)
+        
+    def push(self, item, priority):
+        '''Add to the rear'''
+        entry = (priority, self.index, item)
+        heapq.heappush(self._items, entry)
+        self.index += 1
+    
+    def pop(self):
+        '''Remove the item with highest priority'''
+        try:
+            _, _, item = heapq.heappop(self._items)
+            return item
+        except:
+            print('ERROR! trying to pop an element from an empty priority queue.')
+    
+    def is_empty(self):
+        return len(self._items) == 0
+    
+    def __repr__(self):
+        return f'PriorityQueue(items={self._items})'
+    
+    def __str__(self):
+        res = '['
+        for priority, _, item in self._items:
+            res += f' {item}({priority}) '
+        res += ']'
+        return res