Beispiel #1
0
def dijkstra(start, end, board):
    Node = namedtuple("Node", ["pos", "d", "p"])
    seen = {}
    q = PriorityQueue()

    q.add(Node(start, 0, None), 0)
    while (len(q) > 0):
        cur = q.pop()
        if (cur.pos in seen):
            continue

        seen[cur.pos] = {'d': cur.d, 'p': cur.p}

        #Terminate early if we find the end
        if (cur.pos == end):
            break

        neighbors = [
            tile for tile in adjacent_positions(cur.pos)
            if (tile == end or tile_is_empty(tile, board))
        ]
        for tile in neighbors:
            q.add(Node(tile, cur.d + 1, cur.pos), cur.d + 1)

    if (end not in seen):
        return None

    path = []
    current = end
    while (current is not None):
        path.insert(0, current)
        current = seen[current]['p']

    return path
Beispiel #2
0
def a_star(start, end, board):
    Node = namedtuple("Node", ["pos", "d", "prev"])
    seen = {}
    q = PriorityQueue()

    q.add(Node(start, 0, None), manhattan(start, end))

    while (len(q) > 0):
        current = q.pop()

        if (current.pos in seen):
            continue

        seen[current.pos] = current.prev

        if (current.pos == end):
            break

        neighbors = [
            tile for tile in adjacent_positions(current.pos)
            if (tile == end or tile_is_empty(tile, board))
        ]
        for neighbor in neighbors:
            q.add(Node(neighbor, current.d + 1, current.pos),
                  current.d + 1 + manhattan(neighbor, end))

    if (end not in seen):
        return None

    path = []
    current = end
    while (current is not None):
        path.insert(0, current)
        current = seen[current]

    return path
class test_avltree(TestCase):
    def setUp(self):
        self.priorityqueue = PriorityQueue()
        self.priorityqueue.add(5, 5)
        self.priorityqueue.add(4, 4)
        self.priorityqueue.add(3, 3)
        self.priorityqueue.add(2, 2)
        self.priorityqueue.add(1, 1)

    def test_min(self):
        self.assertEqual(self.priorityqueue.min()[1], 1)