from utils import ( PriorityQueue)
import copy
infinity = float('inf')
def best_first_graph_search(problem, f):
#定义初始节点
node = Node(problem.initial)
node.fvalue=f(node)
#如果是最终结果，返回节点
if problem.goal_test(node):
return node
#frotier是一个顺序队列，从小到大排列，排列比较通过f函数
#如果order是min，最小的先出队
frontier = PriorityQueue(min, f)
#加入节点
frontier.append(node)
#print(node.fvalue)
#展开的节点
explored = set()
#当栈不为空
while frontier:
#节点出队
node = frontier.pop()
#print("pop")
#node.state.display()
#print(node.fvalue)
# 如果是最终结果，返回节点
if problem.goal_test(node):
return node
#加入展开的节点
explored.add(node)
#对于出栈的子节点
for child in node.expand(problem):
#如果节点没有展开，并且子节点没在队中
if child not in explored and child not in frontier:
#子节点入队
frontier.append(child)
#print(child.fvalue)
#如果子节点在队中
elif child in frontier:
incumbent = frontier[child]
#如果子节点的f值小于队中节点的f值
if f(child) < f(incumbent):
#删除栈中的节点，子节点入队
del frontier[incumbent]
frontier.append(child)
#print("change fvalue",child.state.display(),child.fvalue)
return None
#a*算法 f=g+h
def astar_search(problem, h=None):
h = problem.h
return best_first_graph_search(problem, lambda n:h(n) + n.path_cost)
class Problem(object):
def __init__(self, initial, goal=None):
self.initial = initial
self.goal = goal
def actions(self, state):
raise NotImplementedError
def result(self, state, action):
raise NotImplementedError
def goal_test(self, node):
return (node.state.board==self.goal.board)
def path_cost(self, c, state1, action, state2):
return c + 1
def value(self, state):
raise NotImplementedError
class PuzzleProblem(Problem):
def __init__(self, initial=None, goal=None):
Problem.__init__(self, initial, goal)
self.state=initial
self.goal=goal
def actions(self, state):
x,y=state.location(0)
#空格在边缘时减少活动
action=[(0,1),(0,-1),(1,0),(-1,0)]
if (x == 0):
action.remove((-1,0))
if (x == 2):
action.remove((1, 0))
if (y == 0):
action.remove((0, -1))
if (y == 2):
action.remove((0, 1))
return list(action)
def result(self, state, action):
#返回移动空格后的棋盘
x,y=state.location(0)
a,b=action
n= state.board[x+a][y+b]
s=copy.deepcopy(state)
s.board[x+a][y+b]=0
s.board[x][y]=n
return s
def path_cost( self,node):
#展开子节点cost+1
return node.path_cost+1
def h(self, now):
#当前棋盘每个格到目标棋盘的距离的平方和
if now.state or self.goal:
return now.state.distance(self.goal)
else:
return infinity
class Node:
def __init__(self, state, parent=None, action=None, path_cost=0):
self.state = state
self.parent = parent
self.action = action
self.path_cost = path_cost
self.fvalue=0
self.depth = 0
if parent:
self.depth = parent.depth + 1
def __repr__(self):
return "<Node {}>".format(self.state.board)
def __lt__(self, node):
#<运算符 队列排序使用
return self.fvalue < node.fvalue
def expand(self, problem):
#展开子节点
l = []
for action in problem.actions(self.state):
n=self.child_node(problem, action)
l.append(n)
return l
def child_node(self, problem, action):
next = problem.result(self.state, action)
return Node(next, self, action,problem.path_cost(self))
def solution(self):
return self.path()
def printsolution(self):
l=self.path()
print("selution：")
for x in range(len(l)- 1, -1, -1):
print(" ↓")
l[x].state.display()
def path(self):
#返回父节点路径list
node, path_back = self, []
while node:
path_back.append(node)
node = node.parent
return path_back
def __eq__(self, other):
#==运算符
return isinstance(other, Node) and self.state.board==other.state.board
def __hash__(self):
#not in 使用 比较对象Node
board=self.state.board
sum=0
for x in range(0, 3):
for y in range(0, 3):
number = board[x][y]
sum=sum*10+number
return sum
class GameState:
def __init__(self,board=None,action=None):
self.board=board
self.action=action
def display(state):
board = state.board
if board:
for x in range(0, 3):
for y in range(0, 3):
print(board[x][y], end=' ')
print()
def location(state, number):
#数字对应坐标
for x in range(0, 3):
for y in range(0, 3):
if state.board[x][y] == number:
return (x, y)
return (0, 0)
def distance(statea, stateb):
#棋盘的距离
board = statea.board
s = 0
for x in range(0, 3):
for y in range(0, 3):
number = board[x][y]
a, b = stateb.location(number)
d = (x - a) ** 2 + (y - b) ** 2
s = s + d
return s
"""Provides some utilities widely used by other modules"""
import bisect
class Queue:
"""Queue is an abstract class/interface. There are three types:
Stack(): A Last In First Out Queue.
FIFOQueue(): A First In First Out Queue.
PriorityQueue(order, f): Queue in sorted order (default min-first).
Each type supports the following methods and functions:
q.append(item) -- add an item to the queue
q.extend(items) -- equivalent to: for item in items: q.append(item)
q.pop() -- return the top item from the queue
len(q) -- number of items in q (also q.__len())
item in q -- does q contain item?
Note that isinstance(Stack(), Queue) is false, because we implement stacks
as lists. If Python ever gets interfaces, Queue will be an interface."""
def __init__(self):
raise NotImplementedError
def extend(self, items):
for item in items:
self.append(item)
class PriorityQueue(Queue):
"""A queue in which the minimum (or maximum) element (as determined by f and
order) is returned first. If order is min, the item with minimum f(x) is
returned first; if order is max, then it is the item with maximum f(x).
Also supports dict-like lookup.
如果是order=MIN,最小f(x)值的item将出队"""
def __init__(self, order=min, f=lambda x: x):
self.A = []
self.order = order
self.f = f
#按顺序插入,按f（x）从小到大
def append(self, item):
item.fvalue=self.f(item)
bisect.insort(self.A, item)
#print("push")
#item.state.display()
def __len__(self):
return len(self.A)
#order=min输出最小 否则输出最大
def pop(self):
if self.order == min:
return self.A.pop(0)
else:
return self.A.pop()
def __contains__(self, item):
return any(item.state.board == pair.state.board for pair in self.A)
def __getitem__(self, key):
for item in self.A:
if item == key:
return item
def __delitem__(self, key):
for item in enumerate(self.A):
if item == key:
self.A.pop(item)
from eightpuzzle import *
goal = GameState( [[7,1,6],
[5,3,2],
[0,8,4]] )
start = GameState([[2,0,3,],
[1,8,4,],
[7,6,5]] )
goal.action=PuzzleProblem().actions(goal)
start.action=PuzzleProblem().actions(start)
p=PuzzleProblem(start,goal)
result=astar_search(p)
result.printsolution()