人工智能迷宫盲目宽度
代码
# -*- coding:utf-8 -*-
class Maze:
def __init__(self, map, n, m, x, y):
self.ans = 0 #最短步长结果
self.map = map #迷宫地图map[0,n-1][0,m-1]（下标0开始）
self.n = n #迷宫地图行数n
self.m = m #迷宫地图列数m
self.x = x #起点，行坐标（下标0开始）
self.y = y #起点，列坐标（下标0开始）
class Solution:
def solveMaze(self, maze):
"""求解迷宫问题
:type: maze: class Maze #迷宫的数据结构类
:rtype: maze.ans: int #返回最短路径长度
"""
#请在这里补充代码，完成本关任务
#********** Begin **********#
#********** End **********#
答案 广度优先算法
# -*- coding:utf-8 -*-
class Maze:
def __init__(self, map, n, m, x, y):
self.ans = 0 #最短步长结果
self.map = map #迷宫地图map[0,n-1][0,m-1]（下标0开始）
self.n = n #迷宫地图行数n
self.m = m #迷宫地图列数m
self.x = x #起点，行坐标（下标0开始）
self.y = y #起点，列坐标（下标0开始）
class Solution:
def solveMaze(self, maze):
"""求解迷宫问题
:type: maze: class Maze #迷宫的数据结构类
:rtype: maze.ans: int #返回最短路径长度
"""
#请在这里补充代码，完成本关任务
#********** Begin **********#
minpath=[]
dir=[[1,0],[-1,0],[0,-1],[0,1]]
row=maze.n
clm=maze.m
sx=maze.x
sy=maze.y
vis=[[False for i in range(clm+1)] for i in range(row+1)]
queue=[(sx,sy,0)]
vis[sx][sy]=True
while queue:
t=queue.pop()
tx=t[0]
ty=t[1]
ans=t[2]
for i in range(4):
if 0<=tx+dir[i][0]|
有测试的代码
class Maze:#地图类
def __init__(self, map, n, m, x, y):
self.ans = 0 # 最短步长结果
self.map = map # 迷宫地图map[0,n-1][0,m-1]（下标0开始）
self.n = n # 迷宫地图行数n
self.m = m # 迷宫地图列数m
self.x = x # 起点，行坐标（下标0开始）
self.y = y # 起点，列坐标（下标0开始）
class Solution:#解决问题
def solveMaze(self, maze):
"""求解迷宫问题
:type: maze: class Maze #迷宫的数据结构类
:rtype: maze.ans: int #返回最短路径长度
"""
# 请在这里补充代码，完成本关任务
# ********** Begin **********#
minpath=[]
dir=[[1,0],[-1,0],[0,-1],[0,1]]
row=maze.n
clm=maze.m
sx=maze.x
sy=maze.y
vis=[[False for i in range(clm+1)] for i in range(row+1)]
queue=[(sx,sy,0)]
vis[sx][sy]=True
while queue:
t=queue.pop()
tx=t[0]
ty=t[1]
ans=t[2]
for i in range(4):
if 0<=tx+dir[i][0]|
深度
深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。
算法思想
回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。
模板
int check(参数)
{
if(满足条件)
return 1;
return 0;
}
void dfs(int step)
{
判断边界
{
相应操作
}
尝试每一种可能
{
满足check条件
标记
继续下一步dfs(step+1)
恢复初始状态（回溯的时候要用到）
}
} 1、全排列问题
//全排列问题
#include
#include
int n;
char a[15];
char re[15];
int vis[15];
//假设有n个字符要排列，把他们依次放到n个箱子中
//先要检查箱子是否为空，手中还有什么字符，把他们放进并标记。
//放完一次要恢复初始状态，当到n+1个箱子时，一次排列已经结束
void dfs(int step)
{
int i;
if(step==n+1)//判断边界
{
for(i=1;i<=n;i++)
printf("%c",re[i]);
printf("\n");
return ;
}
for(i=1;i<=n;i++)//遍历每一种情况
{
if(vis[i]==0)//check满足
{
re[step]=a[i];
vis[i]=1;//标记
dfs(step+1);//继续搜索
vis[i]=0;//恢复初始状态
}
}
return ;
}
int main(void)
{
int T;
scanf("%d",&T);
getchar();
while(T--)
{
memset(a,0,sizeof(a));
memset(vis,0,sizeof(vis));//对存数据的数组分别初始化
scanf("%s",a+1);
n=strlen(a+1);
dfs(1);//从第一个箱子开始
}
return 0;
} 深度优先算法
头歌答案
# -*- coding:utf-8 -*-
class Solution:
def __init__(self, n=0):
self.vis = [[]] #用于标记是否存在皇后的二维列表（初始值全为0）
self.ans = 0 #用于存储答案（N皇后方案数，初始值0）
self.n = n #用于存储皇后数量n
def solveNQueens(self):
"""求解N皇后问题（调用self.DFS函数）
:rtype: self.ans: int #返回N皇后放置方案数
"""
#请在这里补充代码，完成本关任务
#********** Begin **********#
# 产生一个3行50列的数组，第一行代表左斜线，第二行代表所在的列，第三行代表有索引，初始值都为0
self.vis = [[0 for j in range(50)] for i in range(3)]
self.DFS(1,self.n) # 递归
return self.ans
#********** End **********#
def DFS(self, row, n):
"""深度优先搜索N皇后问题的解空间
:type: row: int #NxN棋盘的第row行
:type: n: int #皇后数量n
:rtype: None #无返回值
"""
#请在这里补充代码，完成本关任务
#********** Begin **********#
if row == n+1: # 行数大于皇后的个数，说明这个方案可行，方案数加1，递归结束（递归结束条件），
self.ans += 1
return
for i in range(1,n+1,1):
# vis[0][row-i+n] == 0 row-i即行的索引减去列的索引，左斜线等于0，左斜线没有放置皇后，+n是为了防止产生负数
# vis[1][i] == 0 第i列为0
# vis[2][row+i] == 0 即所在的右斜线上并没有存放皇后，row+i即行索引加上列索引，同一右斜线的行索引加列索引所得的值相等。
if self.vis[0][row-i+n] == 0 and self.vis[1][i] == 0 and self.vis[2][row+i] == 0: # 第row行第i列可以存放皇后
self.vis[0][row-i+n] = self.vis[1][i] = self.vis[2][row+i] = 1 # 将对应的列，左斜线、右斜线都置为1
self.DFS(row+1,n) # 存放下一个皇后
# 如果下一个皇后的位置无法正确放置，则调整当前皇后的放置位置
self.vis[0][row-i+n] = self.vis[1][i] = self.vis[2][row+i] = 0
# 继续本次循环，知道找到本行的列中有合适的存放位置为止，如果本行无合适位置，则继续返回上一层
#********** End **********#
有测试的
```python
# -*- coding:utf-8 -*-
class Solution:
def __init__(self, n=0):
self.vis = [[]] #用于标记是否存在皇后的二维列表（初始值全为0）
self.ans = 0 #用于存储答案（N皇后方案数，初始值0）
self.n = n #用于存储皇后数量n
def solveNQueens(self):
"""求解N皇后问题（调用self.DFS函数）
:rtype: self.ans: int #返回N皇后放置方案数
"""
# 产生一个3行50列的数组，第一行代表左斜线，第二行代表所在的列，第三行代表有索引，初始值都为0
self.vis = [[0 for j in range(50)] for i in range(3)]
self.DFS(1,self.n) # 递归
return self.ans
def DFS(self, row, n):
"""深度优先搜索N皇后问题的解空间
:type: row: int #NxN棋盘的第row行
:type: n: int #皇后数量n
:rtype: None #无返回值
"""
if row == n+1: # 行数大于皇后的个数，说明这个方案可行，方案数加1，递归结束（递归结束条件），
self.ans += 1
return
for i in range(1,n+1,1):
# vis[0][row-i+n] == 0 row-i即行的索引减去列的索引，左斜线等于0，左斜线没有放置皇后，+n是为了防止产生负数
# vis[1][i] == 0 第i列为0
# vis[2][row+i] == 0 即所在的右斜线上并没有存放皇后，row+i即行索引加上列索引，同一右斜线的行索引加列索引所得的值相等。
if self.vis[0][row-i+n] == 0 and self.vis[1][i] == 0 and self.vis[2][row+i] == 0: # 第row行第i列可以存放皇后
self.vis[0][row-i+n] = self.vis[1][i] = self.vis[2][row+i] = 1 # 将对应的列，左斜线、右斜线都置为1
self.DFS(row+1,n) # 存放下一个皇后
# 如果下一个皇后的位置无法正确放置，则调整当前皇后的放置位置
self.vis[0][row-i+n] = self.vis[1][i] = self.vis[2][row+i] = 0
# 继续本次循环，知道找到本行的列中有合适的存放位置为止，如果本行无合适位置，则继续返回上一层
if __name__ == '__main__':
queen = Solution()
queen.__init__(8)
ans = queen.solveNQueens()
print(ans)