コード例 #1
0
 def test_h_manhattan(self):
     a = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
     self.assertTrue(a.h_manhattan() == 3)
     b = E.State([[8, 7, 6], [5, 4, 3], [2, 1, 0]])
     self.assertTrue(b.h_manhattan() == 20)
     c = E.State([[7, 2, 4], [5, 0, 6], [8, 3, 1]])
     self.assertTrue(c.h_manhattan() == 18)
     print("Manhattan passes!")
コード例 #2
0
 def test_custom(self):
     a = E.State([[0, 2, 1], [3, 7, 8], [4, 6, 5]])
     self.assertTrue(a.h_manhattan() == 8)
     self.assertTrue(a.h_custom() == 10)
     b = E.State([[8, 7, 6], [5, 4, 3], [2, 1, 0]])
     self.assertTrue(b.h_manhattan() == 20)
     self.assertTrue(b.h_custom() == 22)
     print("custom tests passed")
コード例 #3
0
def AStar(initial_state):
    global COUNT, BACKLINKS
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = PriorityQ()
    # inserts the initial state with a priority of 0 (priority for initial state is irrelevant to algorithm)
    OPEN.insert(initial_state, 0)
    CLOSED = []
    BACKLINKS[initial_state] = None

    while OPEN.__len__() > 0:
        # S = min-priority state (priority value gets discarded, only state is looked at)
        S = OPEN.deletemin()[0]
        while S in CLOSED:
            S = OPEN.deletemin()
        CLOSED.append(S)

        # DO NOT CHANGE THIS SECTION: beginning
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            return path, Problem.PROBLEM_NAME
            # DO NOT CHANGE THIS SECTION: end

        COUNT += 1
        # if (COUNT % 32)==0:
        if True:
            # print(".",end="")
            # if (COUNT % 128)==0:
            if True:
                print("COUNT = " + str(COUNT))
                print("len(OPEN)=" + str(len(OPEN)))
                print("len(CLOSED)=" + str(len(CLOSED)))

        L = []
        # looks at all possible new states from operations on S
        # if the new state has not already been put on CLOSED, append to L
        for op in Problem.OPERATORS:
            if op.precond(S):
                new_state = op.state_transf(S)
                #print(new_state.__str__())
                if not occurs_in(new_state, CLOSED):
                    L.append(new_state)
                    BACKLINKS[new_state] = S

        # adds new states in L into OPEN with their priorities
        # if any state already occurs in OPEN...
        #   if L's state has a lower priority, change OPEN's state priority to L's
        #   otherwise, keep OPEN's state in OPEN, ignore L's
        for state in L:
            g_state = G(state)
            if OPEN.__contains__(state):
                if g_state < OPEN.getpriority(state):
                    OPEN.remove(state)
                else:
                    break
            OPEN.insert(state, g_state)
コード例 #4
0
ファイル: AStar.py プロジェクト: chiho828/State-Space-Search
def AStar(initial_state):
    global COUNT, BACKLINKS
    # TODO: initialze and put first state into
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = []
    CLOSED = []
    BACKLINKS[initial_state] = -1
    OPEN.append(initial_state)
    PRI.append(0)
    G = {}
    F = {}
    G[initial_state] = 0

    while len(OPEN) > 0:
        index = findMin()
        S = OPEN[index]
        del OPEN[index]
        del PRI[index]
        while S in CLOSED:
            index = findMin()
            S = OPEN[index]
            del OPEN[index]
            del PRI[index]
        CLOSED.append(S)

        # DO NOT CHANGE THIS SECTION: begining
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            return path, Problem.PROBLEM_NAME
        # DO NOT CHANGE THIS SECTION: end

        # TODO: finish A* implementation
        COUNT += 1
        for op in Problem.OPERATORS:
            if op.precond(S):
                new_state = op.state_transf(S)
                if not (new_state in OPEN) and not (new_state in CLOSED):
                    G[new_state] = G[S] + 1
                    F[new_state] = G[new_state] + heuristics(new_state)
                    BACKLINKS[new_state] = S
                    OPEN.append(new_state)
                    PRI.append(F[new_state])
                elif BACKLINKS[new_state] != -1:
                    other_parent = BACKLINKS[new_state]
                    temp = F[new_state] - G[other_parent] + G[S]
                    if temp < F[new_state]:
                        G[new_state] = G[new_state] - F[new_state] + temp
                        F[new_state] = temp
                        BACKLINKS[new_state] = S
                        if new_state in CLOSED:
                            OPEN.append(new_state)
                            PRI.append(F[new_state])
                            CLOSED.remove(new_state)
コード例 #5
0
    def test_h_euclidian(self):
        a = E.State([[8, 1, 2], [3, 4, 5], [6, 7, 0]])
        self.assertTrue(a.h_euclidian() == m.sqrt(8))
        b = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
        self.assertTrue(b.h_euclidian() == 3)
        c = E.State(([[8, 7, 6], [5, 4, 3], [2, 1, 0]]))
        result = c.h_euclidian()
        #print(result)
        #self.assertTrue(c.h_euclidian() == 3*m.sqrt(8) + 8)

        print("Euclidian passes!")
コード例 #6
0
def backtrace(S):
    global BACKLINKS

    path = []
    while not S == -1:
        path.append(S)
        S = BACKLINKS[Problem.HASHCODE(S)]
    path.reverse()
    print("Solution path: ")
    for s in path:
        print(Problem.DESCRIBE_STATE(s))
    return path    
コード例 #7
0
 def test_isSolvable(self):
     a = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
     self.assertTrue(isSolvable(a))
     b = E.State([[8, 7, 6], [5, 4, 3], [2, 1, 0]])
     self.assertTrue(isSolvable(b))
     c = E.State([[0, 1, 2], [3, 4, 5], [6, 8, 7]])
     self.assertFalse(isSolvable(c))
     d = E.State([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
     self.assertTrue(isSolvable(d))
     e = E.State([[8, 7, 6], [5, 0, 3], [4, 2, 1]])
     self.assertFalse(isSolvable(e))
     print("tests passed")
コード例 #8
0
def runAStar():
    initial_state = puzzle.CREATE_INITIAL_STATE()
    print("Initial State:")
    print(Problem.DESCRIBE_STATE(initial_state))
    if Problem.PROBLEM_NAME == "Basic Eight Puzzle" and Problem.CHECK_INI_STATE(
            initial_state) % 2 != 0:
        print("This particular puzzle is not solvable.")
        return
    global COUNT, BACKLINKS
    COUNT = 0
    BACKLINKS = {}
    IterativeAStar(initial_state)
    print(str(COUNT) + " states examined.")
コード例 #9
0
ファイル: AStar.py プロジェクト: mmb1995/search-algorithms
def AStar(initial_state):
    global COUNT, BACKLINKS, MAX_OPEN_LENGTH

    # STEP 1. Put the start state on a list OPEN
    OPEN = PriorityQB()
    OPEN.insert(initial_state, heur(initial_state))
    x = OPEN.getpriority(initial_state)
    print(x)
    CLOSED = []
    BACKLINKS[initial_state] = None
    moves = {initial_state: 0}

    # STEP 2. If OPEN is empty, output “DONE” and stop.
    while len(OPEN) != 0:
        report(OPEN, CLOSED, COUNT)
        if len(OPEN) > MAX_OPEN_LENGTH: MAX_OPEN_LENGTH = len(OPEN)

        # STEP 3. Select the first state on OPEN and call it S.
        #         Delete S from OPEN.
        #         Put S on CLOSED.
        #         If S is a goal state, output its description
        S = OPEN.deletemin()
        S = S[0]
        CLOSED.append(S)

        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            print('Length of solution path found: ' + str(len(path) - 1) +
                  ' edges')
            return
        COUNT += 1

        # STEP 4. Generate the list L of successors of S and delete
        #         from L those states already appearing on CLOSED.
        L = []
        for op in Problem.OPERATORS:
            if op.precond(S):
                new_state = op.state_transf(S)
                if not (new_state in CLOSED):
                    priority = getPriority(new_state, moves[S] + 1)
                    if new_state in OPEN and priority < OPEN.getpriority(
                            new_state):
                        OPEN.remove(new_state)
                    if new_state not in OPEN:
                        BACKLINKS[new_state] = S
                        moves[new_state] = moves[S] + 1
                        OPEN.insert(new_state, priority)
コード例 #10
0
def AStar(initial_state):
    global COUNT, BACKLINKS
    # TODO: initialze and put first state into
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = PriorityQueue()
    OPEN.put((0,initial_state))
    SEEN = []
    CLOSED = []
    G_SCORE = {}
    G_SCORE[initial_state] = 0
    BACKLINKS[initial_state] = -1
    MAX_GSCORE = 0

    while not OPEN.empty():
        S = OPEN.get()[1]
        while S in CLOSED:
            S = OPEN.get()[1]
        CLOSED.append(S)

        # DO NOT CHANGE THIS SECTION: begining
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            # path = backtrace(S)
            print(len(BACKLINKS))
            return path, Problem.PROBLEM_NAME
        # DO NOT CHANGE THIS SECTION: end

        COUNT += 1
        # TODO: finish A* implementation
        for op in Problem.OPERATORS:
            if op.precond(S):
                next_state = op.state_transf(S)
                # This is a valid move so you need to calculate F(n) = G(n) + H(n)
                if next_state not in SEEN and next_state not in CLOSED:
                    if S in G_SCORE:
                        next_G_SCORE = 1 + G_SCORE[S]
                    else:
                        next_G_SCORE = MAX_GSCORE
                    G_SCORE[next_state] = next_G_SCORE
                    if next_G_SCORE > MAX_GSCORE:
                        MAX_GSCORE = next_G_SCORE
                    next_F_SCORE = next_G_SCORE + heuristics(next_state)
                    OPEN.put((next_F_SCORE, next_state))
                    SEEN.append(next_state)
                    BACKLINKS[next_state] = S
                    print(S)
コード例 #11
0
def runAStar():
    print("Initial State:")
    print(Problem.DESCRIBE_STATE(init_state))
    global COUNT, BACKLINKS
    COUNT = 0
    BACKLINKS = {}
    IterateAStar(init_state)
    print(str(COUNT)+" states examined.")
コード例 #12
0
def occurs_in(s1, lst):
    index = 0
    for s2 in lst:
        if Problem.DEEP_EQUALS(s1, s2[0]):
            return index
        else:
            index = index + 1
    return -1
コード例 #13
0
def IterativeAStar(initial_state):
    global COUNT, BACKLINKS

    OPEN = [initial_state]
    CLOSED = []
    BACKLINKS[Problem.HASHCODE(initial_state)] = -1
    g = {Problem.HASHCODE(initial_state): 0}

    while OPEN != []:
        S = OPEN[0]
        del OPEN[0]
        CLOSED.append(S)

        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            backtrace(S)
            return

        COUNT += 1
        if (COUNT % 32) == 0:
            print(".", end="")
            if (COUNT % 128) == 0:
                print("COUNT = " + str(COUNT))
                print("len(OPEN)=" + str(len(OPEN)))
                print("len(CLOSED)=" + str(len(CLOSED)))
        L = []
        for op in Problem.OPERATORS:
            #Optionally uncomment the following when debugging
            #a new problem formulation.
            #print("Trying operator: "+op.name)
            if op.precond(S):
                new_state = op.state_transf(S)
                if not occurs_in(new_state, CLOSED):
                    L.append(new_state)
                    BACKLINKS[Problem.HASHCODE(new_state)] = S
                    g[Problem.HASHCODE(new_state)] = g[Problem.HASHCODE(S)] + 1
                    #Uncomment for debugging:
                    #print(Problem.DESCRIBE_STATE(new_state))

        for s2 in L:
            for i in range(len(OPEN)):
                if Problem.DEEP_EQUALS(s2, OPEN[i]):
                    del OPEN[i]
                    break

        OPEN = L + OPEN
        OPEN = sorted(OPEN,
                      key=lambda s: g[Problem.HASHCODE(s)] + heuristics(s))
コード例 #14
0
ファイル: AStar.py プロジェクト: kalo37/cse_415
def AStar(initial_state):
    global COUNT, BACKLINKS
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = PriorityQ()
    CLOSED = []
    BACKLINKS[initial_state] = None
    g = {initial_state: 0}

    OPEN.insert(initial_state, heuristics(initial_state))

    while not len(OPEN) == 0:
        S, f = OPEN.deletemin()
        while S in CLOSED:
            S, f = OPEN.deletemin()
        CLOSED.append(S)

        # DO NOT CHANGE THIS SECTION: begining
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            return path, Problem.PROBLEM_NAME
        # DO NOT CHANGE THIS SECTION: end

        COUNT += 1
        print(COUNT)

        L = []
        for op in Problem.OPERATORS:
            if op.precond(S):
                new_state = op.state_transf(S)
                if not occurs_in(new_state, CLOSED):
                    L.append(new_state)
                    BACKLINKS[new_state] = S
                    if new_state not in g.keys():
                        g[new_state] = g[S] + 1

        for s2 in L:
            if s2 in OPEN:
                OPEN.remove(s2)

        for elt in L:
            OPEN.insert(elt, heuristics(elt) + g[elt])
コード例 #15
0
def runAStar():
    # initial_state = Problem.CREATE_INITIAL_STATE(keyVal)
    initial_state = Problem.CREATE_INITIAL_STATE()
    print("Initial State:")
    print(initial_state)
    global COUNT, BACKLINKS
    COUNT = 0
    BACKLINKS = {}
    path, name = AStar(initial_state)
    print(str(COUNT) + " states examined.")
    return path, name
コード例 #16
0
def AStar(initial_state):
    global COUNT, BACKLINKS
    # TODO: initialze and put first state into
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = PriorityQ()
    CLOSED = []
    #define the g score which means
    #the cost of the move will increase by 1 at each depth
    g = {}
    g[initial_state] = 0
    BACKLINKS[initial_state] = None
    #in priority queue, the state is the element
    #and the F score is the priority
    #F socre is the heuristics score plus g scorce
    OPEN.insert(initial_state, g[initial_state] + 0)

    while not OPEN.isEmpty():
        COUNT += 1
        S = OPEN.deletemin()
        while S in CLOSED:
            S = OPEN.deletemin()
        CLOSED.append(S)
        # DO NOT CHANGE THIS SECTION: begining
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            return path, Problem.PROBLEM_NAME
            # DO NOT CHANGE THIS SECTION: end

            # TODO: finish A* implementation
        for op in Problem.OPERATORS:
            if op.precond(S):
                new_state = op.state_transf(S)
                if not (new_state in CLOSED):
                    h = heuristics(new_state)
                    g[new_state] = g[S] + 1
                    if new_state not in OPEN:
                        OPEN.insert(new_state, h + g[new_state])
                        BACKLINKS[new_state] = S
コード例 #17
0
def AStar(initial_state):
    counter = count() # this breaks pq ties
    global COUNT, BACKLINKS
    # TODO: initialze and put first state into
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = PriorityQueue()
    CLOSED = []
    OPEN.put((0, next(counter), initial_state))
    BACKLINKS[initial_state] = -1


    while not OPEN.empty():
        COUNT += 1
        S = OPEN.get()
        while S[2] in CLOSED:
            S = OPEN.get()
        cost = S[0]
        S = S[2]
        CLOSED.append(S)
        # DO NOT CHANGE THIS SECTION: begining
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            return path, Problem.PROBLEM_NAME
        # DO NOT CHANGE THIS SECTION: end

        # TODO: finish A* implementation
        for op in Problem.OPERATORS:
          #Optionally uncomment the following when debugging
          #a new problem formulation.
          # print("Trying operator: "+op.name)
          if op.precond(S):
            new_state = op.state_transf(S)
            if not (new_state in CLOSED):
                h = heuristics(new_state)
                h += cost
                new_pq_item = (h, next(counter), new_state)
                OPEN.put(new_pq_item)
                BACKLINKS[new_state] = S
コード例 #18
0
def AStar(initial_state):
    global COUNT, BACKLINKS
    # priority queue with respective priority
    # add any auxiliary data structures as needed
    OPEN = PriorityQueue()
    OPEN.put((heuristics(initial_state), initial_state))
    OPENlist = [initial_state]
    #OPEN.put(initial_state)
    CLOSED = []
    BACKLINKS[initial_state] = -1
    prioritycount = 0

    while not OPEN.empty():
        S = OPEN.get()[1]
        OPENlist.remove(S)
        while S in CLOSED:
            S = OPEN.get()[1]
        CLOSED.append(S)

        # DO NOT CHANGE THIS SECTION: begining
        if Problem.GOAL_TEST(S):
            print(Problem.GOAL_MESSAGE_FUNCTION(S))
            path = backtrace(S)
            return path, Problem.PROBLEM_NAME
        # DO NOT CHANGE THIS SECTION: end

        COUNT += 1
        for op in Problem.OPERATORS:
            prioritycount += 2
            #print(prioritycount)
            #print("Trying operator: "+op.name)
            if op.precond(S):
                new_state = op.state_transf(S)
                if not (new_state in CLOSED) and not (new_state in OPENlist):
                    #print(heuristics(new_state) +prioritycount)
                    #print(new_state)
                    #print(OPEN.qsize())
                    OPEN.put((heuristics(new_state), new_state))
                    OPENlist.append(new_state)
                    BACKLINKS[new_state] = S
コード例 #19
0
def runAStar():
    initial_state = Problem.CREATE_INITIAL_STATE()

    #Use an externally specified initial state
    if len(sys.argv) > 3:
        initial_state_file = importlib.import_module(sys.argv[3])
        initial_state = initial_state_file.CREATE_INITIAL_STATE()

    print("Initial State:")
    print(initial_state)
    global COUNT, BACKLINKS
    COUNT = 0
    BACKLINKS = {}
    path, name = AStar(initial_state)
    print(str(COUNT) + " states examined.")
    return path, name
コード例 #20
0
ファイル: AStar.py プロジェクト: mmb1995/search-algorithms
def runAStar():
    global Problem
    initial_state = Problem.CREATE_INITIAL_STATE()
    if not isSolvable(initial_state):
        print(
            "There is no possible solution to this puzzle. Please choose a different initial state."
        )
        return
    print("Initial State:")
    print(initial_state)
    global COUNT, BACKLINKS, MAX_OPEN_LENGTH
    COUNT = 0
    BACKLINKS = {}
    MAX_OPEN_LENGTH = 0
    AStar(initial_state)
    print(str(COUNT) + " states expanded.")
    print('MAX_OPEN_LENGTH = ' + str(MAX_OPEN_LENGTH))
コード例 #21
0
 def test_h_hamming(self):
     a = E.State([[0, 3, 2], [1, 7, 4], [8, 5, 6]])
     self.assertTrue(a.h_hamming() == 7)
     b = E.State([[0, 1, 3], [4, 6, 7], [5, 8, 2]])
     self.assertTrue(b.h_hamming() == 7)
     c = E.State([[-2, -5, -6], [99, 82, 45], [99, 17, 56]])
     self.assertTrue(c.h_hamming() == 8)
     d = E.State([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
     self.assertTrue(d.h_hamming() == 0)
     e = E.State(([[0, 1, 2], [4, 3, 5], [7, 6, 8]]))
     self.assertTrue(e.h_hamming() == 4)
     f = E.State([[3, 1, 2], [4, 5, 0], [6, 7, 8]])
     self.assertTrue(f.h_hamming() == 3)
     print("Hamming tests Passed!")
コード例 #22
0
# A* Search of a problem space.
# The Problem should be given in a separate Python
# file using the "QUIET" file format.
# See the TowerOfHanoi.py example file for details.
# Examples of Usage:

# python3 AStar.py EightPuzzleWithHeuristics h_manhattan puzzle10a

import sys
from queue import PriorityQueue

# DO NOT CHANGE THIS SECTION
if sys.argv==[''] or len(sys.argv)<3:
    import EightPuzzleWithHeuristics as Problem
    heuristics = lambda s: Problem.HEURISTICS['h_manhattan'](s)
    initial_state = Problem.CREATE_INITIAL_STATE()

else:
    import importlib
    Problem = importlib.import_module(sys.argv[1])
    heuristics = lambda s: Problem.HEURISTICS[sys.argv[2]](s)
    initial_state = Problem.State(importlib.import_module(sys.argv[3]).CREATE_INITIAL_STATE())



print("\nWelcome to AStar")
COUNT = None
BACKLINKS = {}

# DO NOT CHANGE THIS SECTION
def runAStar():
コード例 #23
0
ファイル: puzzle12a.py プロジェクト: juran321/CSE415
import EightPuzzleWithHeuristics as p

CREATE_INITIAL_STATE = lambda: p.State([3, 1, 2, 6, 8, 7, 5, 4, 0])
コード例 #24
0
ファイル: puzzle16a.py プロジェクト: vaibhavi-r/CSE-415
import EightPuzzleWithHeuristics as Problem

#puzzle16a.py:
CREATE_INITIAL_STATE = lambda: Problem.State([0, 8, 2, 1, 7, 4, 3, 6, 5])

コード例 #25
0
# Ying Dang
# CSE 415 A, Spring 2016
# Homework 3: Part II

#3. A Star COMPLETE

import sys

if len(sys.argv)<2:
    # Use defaults
    import EightPuzzleWithHeuristics as Problem
    init_state = Problem.CREATE_INITIAL_STATE()
    heuristic_choice = 'h_euclidean'
    heuristics = Problem.HEURISTICS[heuristic_choice]
else:
    # Use command line parameters
    import importlib
    Problem = importlib.import_module(sys.argv[1])
    Initial_state = importlib.import_module(sys.argv[3])
    init_state = Initial_state.CREATE_INITIAL_STATE()
    heuristic_choice = sys.argv[2]
    heuristics = Problem.HEURISTICS[heuristic_choice]


print("\nWelcome to A Star")
COUNT = None
BACKLINKS = {}


def runAStar():
    print("Initial State:")
コード例 #26
0
def IterateAStar(initial_state):
    global COUNT, BACKLINKS

    OPEN = [[initial_state, heuristics(initial_state)]]
    CLOSED = []

    # print(initial_state)
    COST = {Problem.HASHCODE(initial_state): 0}

    BACKLINKS[Problem.HASHCODE(initial_state)] = -1

    while OPEN != []:
        S = OPEN[0]
        del OPEN[0]
        CLOSED.append(S)

        if Problem.GOAL_TEST(S[0]):
            print(Problem.GOAL_MESSAGE_FUNCTION(S[0]))
            backtrace(S[0])
            return

        COUNT += 1
        if (COUNT % 32)==0:
            print(".",end="")
            if (COUNT % 128)==0:
                print("COUNT = "+str(COUNT))
                print("len(OPEN)="+str(len(OPEN)))
                print("len(CLOSED)="+str(len(CLOSED)))
        L = []

        # for each possible child in S (state)
        for op in Problem.OPERATORS:
            # is a child
            if op.precond(S[0]):
                new_state = op.state_transf(S[0])

                # index of occurrence in CLOSED
                occur_closed = occurs_in(new_state, CLOSED)

                # index of occurence in OPEN
                occur_open = occurs_in(new_state, OPEN)

                # the moves made so far + 1
                new_cost = COST[Problem.HASHCODE(S[0])] + 1
                # place in neighbor if new state
                if occur_closed == -1 and occur_open == -1:
                    L.append([new_state, heuristics(new_state)])
                    BACKLINKS[Problem.HASHCODE(new_state)] = S[0]
                    COST[Problem.HASHCODE(new_state)] = new_cost

                elif occur_open > -1:
                    # check to see if this move is more efficient
                    if COST[Problem.HASHCODE(new_state)] > new_cost:
                        COST[Problem.HASHCODE(new_state)] = new_cost
                        OPEN[occur_open] = [new_state, new_cost]

        # for all neighbors found, if it equals to states in OPEN,
        # delete it, shouldn't occur but juuuuust in case...
        for s2 in L:
            for i in range(len(OPEN)):
                if Problem.DEEP_EQUALS(s2, OPEN[i][0]):
                    del OPEN[i]; break

        OPEN = L + OPEN
        OPEN.sort(key=lambda x: x[1])
コード例 #27
0
ファイル: puzzle1a.py プロジェクト: vaibhavi-r/CSE-415
import EightPuzzleWithHeuristics as Problem

# puzzle1a:
CREATE_INITIAL_STATE = lambda: Problem.State([1, 0, 2, 3, 4, 5, 6, 7, 8])
コード例 #28
0
ファイル: puzzle14a.py プロジェクト: juran321/CSE415
import EightPuzzleWithHeuristics as p

CREATE_INITIAL_STATE = lambda: p.State([4, 5, 0, 1, 2, 8, 3, 7, 6])
コード例 #29
0
ファイル: puzzle10a.py プロジェクト: vaibhavi-r/CSE-415
import EightPuzzleWithHeuristics as Problem

#puzzle10a.py:
CREATE_INITIAL_STATE = lambda: Problem.State([4, 5, 0, 1, 2, 3, 6, 7, 8])

コード例 #30
0
ファイル: puzzle4a.py プロジェクト: vaibhavi-r/CSE-415
import EightPuzzleWithHeuristics as Problem

# puzzle4a:
CREATE_INITIAL_STATE = lambda: Problem.State([1, 4, 2, 3, 7, 0, 6, 8, 5])