A*算法求解N数码问题（AI实验一）

最新推荐文章于 2020-12-12 18:45:42 发布

清风er

最新推荐文章于 2020-12-12 18:45:42 发布

阅读量6k

点赞数 9

分类专栏： Python AI 文章标签：算法 python

本文链接：https://blog.csdn.net/qq_43727105/article/details/106263926

版权

Python 同时被 2 个专栏收录

16 篇文章 8 订阅

订阅专栏

11 篇文章 0 订阅

订阅专栏

1.实验题目

A*算法求解N数码问题，要求程序内，输入给定初始状态和目标状态，输出所需步数，过程状态及时间（程序可直接运行，无需再手动输入）。

2.实验目的及要求

熟悉和掌握启发式搜索的定义、估价函数和算法过程
利用A*算法求解N数码难题，理解求解流程和搜索顺序
熟练掌握numpy库的相关函数

3.实验原理

A*算法是一种启发式图搜索算法，其特点在于对估价函数的定义上。对于一般的启发式图搜索，总是选择估价函数f值最小的结点作为扩展结点。因此，f是根据需要找到一条最小代价路径的观点来估算结点的，所以，可考虑每个结点n的估价函数值为两个分量：从起始结点到结点n的实际代价以及从结点n到达目标结点的估价代价。
启发式图搜索的基本特点：如何寻找并设计一个与问题有关的h(n)以及构出f(n)=g(n)+h(n),然后以f(n)的大小来排列待扩展状态的次序，每次选择f(n)的最小值进行扩展。

open表：保留所有已生成而未扩展的状态
closed表：记录已扩展后的状态
进入open表的状态是根据估值的大小插入到表中合适的位置，每次从表中优先取出启发估价函数值最小的状态加以扩展。

4.实验内容

以8数码问题为例实现A*算法的求解程序
original state:

2	8	3
1	6	4
7		5

target state:

1	2	3
8		4
7	6	5

估价函数f(n)=g(n)+h(n)
g(n)=d(n) ------结点n在搜索树中的深度
h(n)可选择h1(n) — 结点n中“不在位”的数码个数或 h2(n)=p(n)–当前状态到终点的曼哈顿距离
2. 在求解8数码问题的A* 算法程序中，设置相同的初始状态和目标状态，针对不同的估价函数，求得问题的解，并比较它们对搜索算法性能的影响，包括扩展结点数、生成结点数等
3. 画出A*算法求解框图

5.实验分析

每移动一次空格，就产生一种状态。使用BFS来搜索，但这里使用优先队列而不是普通的队列，这样就可以利用A*算法的核心——评估函数f(n)=g(n)+h(n)，对每一种状态用评估函数进行优先队列的排序（只要你给了评估函数的值，优先队列会自己帮我们排序）。
搜索过程如下：
在这里插入图片描述

6.代码实现

from queue import PriorityQueue
import datetime

class node:
    def __lt__(self,other):
        return self.cost < other.cost
       
    def __init__(self,n,s,p):
        self.num = n#str的数组
        self.step = s#当前已经走了的步数,int
        self.zeroPos = p#0的位置,int
        self.cost = 0
        self.parent = None#父指针
        self.setCost()

    def setCost(self):
        global des
        count = 0
        for i in range(len(des)):
            if self.num[i] != des[i]:
                count += 1
        self.cost = count + self.step

    def setParent(self,father):
        self.parent = father

def swap(li,first,second):
    temp = li[first]
    li[first] = li[second]
    li[second] = temp

def format_p(s,N):
    for i in range(N):
        print('\t'.join(s[i*N:(i+1)*N]))
    print()
    
def makeChangeId(N):
    #根据N实现changeId
    li = []
    MAX = N**2
    for i in range(MAX):
        temp = []
        row = i//N#行
        col = i%N#列
        if row is not 0:#上，如果行为0，那么肯定不往上移动了
            temp.append(i-N)
        else:
            temp.append(-1)
        if col is not 0:#左
            temp.append(i-1)
        else:
            temp.append(-1)
        if row is not N-1:#下
            temp.append(i+N)
        else:
            temp.append(-1)        
        if col is not N-1:#右
            temp.append(i+1)
        else:
            temp.append(-1)
        li.append(temp)
    return li

def bfs(start,zeroPos):
    #start is str's list
    #zeroPos is int
    global changeId,visit,que,des,N
    #该函数返回最后一个状态即最后一个node
    startNode = node(start,0,zeroPos)
    que.put(startNode)
    while(not que.empty()):
        outNode = que.get()
        strList = outNode.num#这里是list
        strTuple = tuple(strList)#状态表示，这里是tuple
        if strTuple in visit:
            continue
        visit[strTuple] = 1
        pos = outNode.zeroPos#零的位置
        for i in range(4):
            if changeId[pos][i] != -1:
                swap(strList,pos,changeId[pos][i])               
                joinTuple = tuple(strList)
                if strList == des:
                    print('bingo')
                    swap(strList,pos,changeId[pos][i])
                    #找到了先交换回去，因为这里strList是状态对象的成员了，直接返回的话，就不会执行
                    #下面那句swap了，所以这里得加上一句swap
                    return outNode
                if joinTuple not in visit:
                    new = node(strList.copy(),outNode.step+1,changeId[pos][i])
                    #注意这里必须使用copy，因为不复制传进去的就只是个引用，会导致所有node的成员都是同一个list
                    new.setParent(outNode)
                    que.put(new)
                swap(strList,pos,changeId[pos][i])
                

visit = dict()
que = PriorityQueue()
print('Please input N:')
N = eval(input())
print('Please input the original state:')
src = input().split()#和之前不同，这里存的都是str的list
print('Please input the target state:')
des = input().split()
for i in range(len(src)):
    if src[i] == '0':
        break
start_t = datetime.datetime.now()
changeId = makeChangeId(N)
last = bfs(src,i)

result = [des]#先装des，用作栈使用

def findroot(last,result):
    result.append(last.num)
    if last.parent == None:
        return
    else:
        findroot(last.parent,result)
        
findroot(last,result)

end_t = datetime.datetime.now()
print('The transition from original state to the target state:')
while(len(result)):
    format_p(result.pop(),N)
print('Step number:'+str(last.step+1)+'steps')
print("time = ", (end_t - start_t).total_seconds(), "s")
print('end')