实验三：基于A*算法的迷宫

实验要求：

1、迷宫随机生成

2、玩家走迷宫，留下足迹；

3、系统用A*算法寻路，输出路径

解决问题：

1、如何显示迷宫的图形界面；

2、如何生成随机的迷宫；

3、怎样移动游戏中走迷宫的“玩家”；

4、用A*算法求解迷宫；
一、生成迷宫的图形界面

利用JavaGUI进行图形界面设计

二、如何生成随机的迷宫

迷宫地图的分类：主路扭曲型、自然分岔型、块状分割型

生成迷宫的方法

方法一：深度优先遍历（DFS）

可以这样描述深度遍历：

（1）访问顶点v；

（2）从v的未被访问的邻接点中选取一个顶点w，重复第一步，如果v没有未访问的邻接点，回溯至上一顶点；

（3）重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

迷宫生成策略：利用深度遍历的思想。访问到一个节点时，搜索这个节点没有被访问过的相邻节点，选择一个继续做同样的操作，直到没有邻节点为止再回溯到上一个访问的节点，并选择另外的邻节点。

方法二：随机型迷宫（利用prime算法）

三、如何求解一个迷宫

寻路算法

1）广度优先搜索算法

2）dijkstra(迪杰斯特拉)算法

3）Greed-Best-First（最好优先贪婪算法）

4）A*算法

广度优先搜索算法

算法思想：

从图的某一结点出发，首先依次访问该结点的所有邻接结点Vi1,vi2,vi3,……Vin再按这些顶点被访问的先后次序依次访问与它们相邻接的所有未被访问的顶点；重复此过程，直至所有顶点均被访问位置。

迪杰斯特拉(Dijkstra)算法

1、把V分成两组：

1）S:已求出最短路径的顶点的集合。

2）T=V-S：尚未确定最短路径的顶点集合。

2、将T中顶点按最短路径递增的次序加入到S中。

初始时，S中只有起点V1；T中是除V1之外的顶点，并且T中顶点的路径是”起点V1到该顶点的路径”。然后，从T中找出路径最短的顶点，并将其加入到S中；

接着，更新S中的顶点和顶点对应的路径。然后，再从T中找出路径最短的顶点，并将其加入到S中；

… 重复该操作，直到遍历完所有顶点。

A*算法

在计算机科学中，A*算法作为Dijkstra（迪杰斯特拉）算法的扩展，是一种静态路网中求解最短路径有效的直接搜索方法，因其高效性被广泛应用于寻路及图的遍历中。

了解完算法后有了大致的游戏设计路程，如下：

代码如下：

A*算法代码

package maze;public class AStarSolver extends Solver {public AStarSolver(boolean[][] maze) {super(maze);}/** A* 算法：*  G表示从起点到当前顶点n的实际距离；*  H表示当前顶点n到目标顶点的估算距离（根据所采用的评估函数的不同而变化）；*  F=G+H，代表了该节点的综合预估值，值越小，到达目标的成本就越小，所以访问的时候尽量优先考虑最小的。*//**路径搜索过程如下：* 1.首先需要创建两个集合，一个存储待访问的节点（openlist），一个存储已经访问过的节点(closelist)* 2.添加起点openlist列表，并且计算该点的预估值。* 3.查找openlist里预估值最小的节点，作为当前访问的节点，并且从openlist删除该节点。* 4.获取当前节点的邻居节点，计算出他们的预估值 并且添加到openlist列表中。* 5.把当前节点添加到closelist中，代表已经访问过了。* 6.重复以上步骤3-5，直到找到目标节点位置为止。* 7.循环输出最终节点的父节点，就是我们需要的路径了。*/public void algorithm() {Point current;while(!open.isEmpty() && !closed.contains(end)) {//如果openlist非空，并且closelist不包含终点current = getLowestInList(open);//获取openlist中F最小的点open.remove(current);//openlist删除F最小的点closed.add(current);//将那个点加入到closelist中setupAdjacentPoints(current);//处理这个点周围的点}}//计算点的F值private void setupPoint(Point p) {p.setH(Math.abs(end.getX() - p.getX()) + Math.abs(end.getY() - p.getY()));p.setG(Math.abs(start.getX() - p.getX()) + Math.abs(start.getY() - p.getY()));p.setF();}/*** 对当前方格的 8 个相邻方格的每一个方格：如果它是不可抵达的或者它在 close list 中，忽略它。否则，做如下操作：* （1）如果它不在 open list 中，把它加入 open list ，并且把当前方格设置为它的父亲，记录该方格的 F ， G 和 H 值。* （2）如果它已经在 open list 中，检查这条路径 ( 即经由当前方格到达它那里 ) 是否更好，用 G 值作参考。更小的 G 值表示这是更好的路径。如果是这样，把它的父亲设置为当前方格，并重新计算它的 G 和 F 值。如果你的 open list 是按 F 值排序的话，改变后你可能需要重新排序。*/private void setupAdjacentPoints(Point p) {int x = p.getX();int y = p.getY();int width = points[0].length-1;int height = points.length-1;for(int row = -1; row <= 1; row++) {for(int col = -1; col <= 1; col++) {//检查是否是pif(row == 0 && col==0)continue;//确保他不会超出界限if(x + row < 0 || x + row > width)continue;if(y + col < 0 || y + col > height)continue;//确保他可以被检查if(closed.contains(points[x+row][y+col]))continue;//确保他不是一堵墙if(points[x+row][y+col].isWall())continue;if(row == -1) {if(col == -1)continue;if(col == 1)continue;}if(row == 1) {if(col == -1)continue;if(col == 1)continue;}if(open.contains(points[x+row][y+col])) {if(p.getF() < points[row+x][col+y].getParentPoint().getF())points[x+row][y+col].setParentPoint(p);continue;}setupPoint(points[row+x][col+y]);points[row+x][col+y].setParentPoint(p);addPoint(open, points[row+x][col+y]);}}}
}

深度优先搜索算法：

package maze;import java.util.ArrayList;public class EMap {private ArrayList<Integer> blockPos = new ArrayList<Integer>();private int d[][] = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};//上 右 下 左private boolean a[][];private int width;private int height;private boolean fl = false;public EMap(boolean b[][]) {//b是PMap.java用Prim算法生成的迷宫，复制到a中，使得不修改b中迷宫width = (b.length - 1) / 2;height = (b[0].length - 1) / 2;a = new boolean[b.length][b[0].length];for (int i = 0; i < b.length; i++)for (int j = 0; j < b[0].length; j++)a[i][j] = b[i][j];}/*** 深度优先搜索找迷宫通路* 1.从一个点向四周开始搜索，选择一个方向向下搜索* 2.直到遇到墙返回上一父节点，选择其他方向搜索，不断递归，并对已经搜索过的方向进行标注以免重复搜索，并删除列表中的路径* 3.如果能够到达终点，就追溯之前路径，加入到列表中*/private void dfs(int x, int y, int c) {//c表示不能走的方向；if (x == (width * 2) && y == (height * 2 - 1)) {//找到终点，fl设为truefl = true;return;}for (int i = 0; i < 4; i++) {//从一个点向四周开始搜索if (c == i) continue;//c表示你从一个方向搜过来的，就不要再重新搜回去了int dx = x + d[i][0];int dy = y + d[i][1];if (ise(dx, dy) && a[dx][dy]) {if (fl) break;//如果找到终点，直接跳出，不继续不搜索blockPos.add(dx);blockPos.add(dy);//路径加入到列表中a[dx][dy] = false;dfs(dx, dy, (i + 2) % 4);//从新的结点继续开始搜}}if (!fl) {//没找到终点，说明不通，这次尝试不对，就将不对的移除列表blockPos.remove(blockPos.size() - 1);blockPos.remove(blockPos.size() - 1);}}//private void Astar(){//}public ArrayList<Integer> exitmap() {/* System.out.println(a.length);System.out.println(a[0].length);Solver solver = new AStarSolver(a);ArrayList<Point> solution = solver.getSolution();for(Point p : solution){blockPos.add(p.getY());blockPos.add(p.getX());} */blockPos.add(0);blockPos.add(1);dfs(0, 1, 3);//默认从（0,1）开始，不能走的方向为向下
//      for(int i=0;i<a.length;i++)
//      {
//          for(int j=0;j<a[0].length;j++) {
//              System.out.print(a[i][j]+" ");
//          }
//          System.out.print("\n");
//      }return blockPos;}private boolean ise(int dx, int dy) {return (0 <= dx && dx <= width * 2 && 0 <= dy && dy <= height * 2);}
}

画迷宫的方法：

package maze;import java.awt.Color;
import java.awt.Graphics;
import java.util.ArrayList;import javax.swing.*;public class PaintMap extends JPanel{final int unitSize =10;//单位大小private int width;//宽private int height;//高private int startX;//开始点private int startY;private boolean block;private boolean b[][];private boolean IsDisplay;private boolean flag;private ArrayList<Integer> ToExit = new ArrayList<Integer>(); //通向终点的路径的结点组成的列表public PaintMap(boolean b[][],ArrayList<Integer>a) {//初始化ToExit=a;this.b=b;width=b.length;height=b[0].length;startX=0; //初始位置startY=1;block=true;//初始化全是墙IsDisplay=false;flag=true;}public void paint(Graphics g) {//墙的颜色g.setColor(Color.black);for(int i=0;i<width;i++)for(int j=0;j<height;j++)if(!b[i][j]) {g.fill3DRect(30+i*unitSize, 30+j*unitSize, unitSize, unitSize, true);//参数依次表示为：要填充矩形的x坐标、y坐标、要填充矩形的宽度、高度}//出口路线颜色：红色if(IsDisplay) {//只有在敲击空格键的情况下显示最佳路径g.setColor(Color.red);for(int i=0;i<ToExit.size();i+=2) {//路径横纵坐标依次存储在ToExit中，所以间隔加2g.fill3DRect(30+ToExit.get(i)*unitSize, 30+ToExit.get(i+1)*unitSize, unitSize, unitSize, true);flag=true;}}//白色/*if(!flag) {//只有在敲击空格键的情况下显示最佳路径g.setColor(Color.white);for(int j=0;j<ToExit.size();j+=2) {//路径横纵坐标依次存储在ToExit中，所以间隔加2g.fill3DRect(30+ToExit.get(j)*unitSize, 30+ToExit.get(j+1)*unitSize, unitSize, unitSize,true);}}*///控制格子颜色：绿色g.setColor(Color.green);if(IsEdge(startX, startY)) {g.fill3DRect(30+startX*unitSize, 30+startY*unitSize, unitSize, unitSize, true);}else{g.fill3DRect(30+unitSize,30, unitSize, unitSize, true);}}//本程序中使用的坐标轴为：以左上角顶点为原点，向右为x轴正方向，向下为y轴正方向public void moveUp() {//向上移动startY-=1;//坐标先改变if(IsEdge(startX, startY)) {//如果这个点在迷宫边界或超出迷宫范围，将改变还原if(!b[startX][startY]) {block=false;startY+=1;}if(block)repaint();elseblock=true;Win(startX,startY);}elsestartY+=1;}public void moveDown() {startY+=1;if(IsEdge(startX, startY)) {if(!b[startX][startY]) {block=false;startY-=1;}if(block)repaint();elseblock=true;Win(startX,startY);}elsestartY-=1;}public void moveLeft() {startX-=1;if(IsEdge(startX, startY)) {if(!b[startX][startY]) {block=false;startX+=1;}if(block)repaint();elseblock=true;Win(startX,startY);}elsestartX+=1;}public void moveRight() {startX+=1;if(IsEdge(startX, startY)) {if(!b[startX][startY]) {block=false;startX-=1;}if(block)repaint();elseblock=true;Win(startX,startY);}elsestartX-=1;}public void PressSp() {//点击空格显示路径if(IsDisplay&&flag) {IsDisplay=false;flag=false;}else {IsDisplay=true;flag=true;repaint();}}private boolean IsEdge(int x,int y) {//判断是否在迷宫内，在就返回truereturn (x<width&&y<height&&x>=0&&y>=0) ;}private void Win(int x,int y) {//判断赢没赢游戏if(x==width-1&&y==height-2) {//终点，是固定不变的Object[] options = {"再来一局","退出"};int response=JOptionPane.showOptionDialog ( this, "出来了","Game Over",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE, null,options, options[0] ) ;if (response == 0){//选再来一局的话//b=new PMap().prim(0, 0, (width-1)/2,(height-1)/2, true);/*ToExit=new EMap(b).exitmap();startX=0;startY=1;block=true;IsDisplay=false;repaint();*///dispose();//dispose();/*public void windowClosing() {System.exit(0);}*/new Test();}else /*if (response == 1)*/ //选择退出System.exit(0);}}}

Prim算法生成迷宫：

package maze;import java.util.ArrayList;
import javax.swing.JPanel;/**Prim算法：让迷宫全都是墙。选一个格，作为迷宫的通路，然后把它的邻墙放入列表。当列表里还有墙时:从列表里随机选一个墙，如果它对面的格子不是迷宫的通路:把墙打通，让对面的格子成为迷宫的通路;把那个格子的邻墙加入列表。如果对面的格子已经是通路了，那就从列表里移除这面墙。*///生成随机的迷宫
public class PMap extends JPanel  {public boolean[][] prim(int startX,int startY,int widthLimit,int heightLimit,boolean haveBorder){//0，1，20，19，truefinal boolean block=false,unblock=true;   //block表示是墙，unblock表示是可以走的路//针对异常情况if(widthLimit<1)//宽度最低设置为1widthLimit=1;if(heightLimit<1)//高度最低设置为1heightLimit=1;if(startX<0||startX>=widthLimit)//起点不能超出迷宫startX=(int)Math.round(Math.random()*(widthLimit-1));//超出就在迷宫内随机选择一个作为起点if(startY<0||startY>=heightLimit)startY=(int)Math.round(Math.random()*(heightLimit-1));if(!haveBorder) {--widthLimit;--heightLimit;}//迷宫尺寸换算成带墙尺寸widthLimit*=2;heightLimit*=2;//迷宫起点换算成带墙起点startX*=2;startY*=2;if(haveBorder) {++startX;++startY;}//初始化迷宫boolean[][]mazeMap=new boolean [widthLimit+1][heightLimit+1];//设置全为墙for(int i=0;i<=widthLimit;i++)for(int j=0;j<=heightLimit;j++)mazeMap[i][j]=block;mazeMap[0][1]=unblock;//入口mazeMap[widthLimit][heightLimit-1]=unblock;//出口ArrayList<Integer> blockPos = new ArrayList<Integer>(); //存放邻居墙的列表int targetX=startX,targetY=startY;mazeMap[targetX][targetY]=unblock;//首先针对起点，将起点邻墙加入列表，和起点（0,1）点进行比较//列表在意义上是每三个元素为一组：一个点的x坐标，一个点的y坐标，将要移动的方向if(targetY>1) {blockPos.add(targetX);blockPos.add(targetY-1);blockPos.add(0);//上}if (targetX < widthLimit){blockPos.add(targetX+1);blockPos.add(targetY);blockPos.add(1);//右}if (targetY < heightLimit){blockPos.add(targetX);blockPos.add(targetY+1);blockPos.add(2);//下}if (targetX > 1){blockPos.add(targetX-1);blockPos.add(targetY);blockPos.add(3);//左}//列表不为空时while(!blockPos.isEmpty()) {int blockIndex=(int)Math.round(Math.random()*(blockPos.size()/3-1))*3;//选中三个一组的最开始那个，即x坐标位，+1位表示y坐标位，+2表示方向位if(blockIndex+2<blockPos.size()) {if(blockPos.get(blockIndex+2).equals(0)) {//+2表示方向位，如果向上，那么坐标跟着改变targetX= blockPos.get(blockIndex);targetY= blockPos.get(blockIndex+1)-1;}else if(blockPos.get(blockIndex+2).equals(1)) {targetX= blockPos.get(blockIndex)+1;targetY= blockPos.get(blockIndex+1);}else if(blockPos.get(blockIndex+2).equals(2)) {targetX= blockPos.get(blockIndex);targetY= blockPos.get(blockIndex+1)+1;}else if(blockPos.get(blockIndex+2).equals(3)) {targetX= blockPos.get(blockIndex)-1;targetY= blockPos.get(blockIndex+1);}}//例子：口口口，最左的是起点，中间是它的邻墙，右面的则是上几行得到的,也就是“对面”的格子if(mazeMap[targetX][targetY]==block) {//起点对面格子是墙，打通邻墙//打通墙if(blockIndex+1<blockPos.size())mazeMap[blockPos.get(blockIndex)][blockPos.get(blockIndex+1)]=unblock;elseSystem.out.println("error");mazeMap[targetX][targetY]=unblock;//然后再添加当前目标的邻墙if (targetY > 1 && mazeMap[targetX][targetY - 1] == block && mazeMap[targetX][targetY - 2] == block){blockPos.add(targetX);blockPos.add(targetY-1);blockPos.add(0);//向上情况}if (targetX < widthLimit -1&& mazeMap[targetX + 1][targetY] == block && mazeMap[targetX + 2][targetY] == block){blockPos.add(targetX+1);blockPos.add(targetY);blockPos.add(1);//向右情况}if (targetY < heightLimit-1 && mazeMap[targetX][targetY + 1] == block && mazeMap[targetX][targetY + 2] == block){blockPos.add(targetX);blockPos.add(targetY+1);blockPos.add(2);//向下情况}if (targetX > 1 && mazeMap[targetX - 1][targetY] == block && mazeMap[targetX - 1][targetY] == block){blockPos.add(targetX-1);blockPos.add(targetY);blockPos.add(3);//向左情况}}//对面已经是通路了，就从列表移除这面墙for(int l=blockIndex,k=0;k<3;k++) {blockPos.remove(l);}}return mazeMap;}
}

package maze;
//原始的迷宫是bool值，保存信息太少。A*需要用到更多信息，所以用Point表示一格，里面信息很多public class Point
{private int x;//坐标private int y;private boolean isWall;//是否是墙//private boolean isStart;//private boolean isEnd;private int f;//f值private int g;//g值private int h;//h值private Point parentPoint;Point(int x, int y, boolean type) {//初始化this.x = x;this.y = y;isWall = false;if(type == false){isWall = true;}}public void setParentPoint(Point parentPoint){this.parentPoint = parentPoint;}//设置父节点，方便最后寻路public Point getParentPoint(){return parentPoint;}//查询父节点public int getX() {//查询坐标return x;}public int getY() {return y;}/* public boolean isEnd() {return isEnd;}public boolean isStart() {return isStart;}*/public boolean isWall() {return isWall;}public int getF()//查询F值{return f;}public void setF()//计算F值{f = g + h;}public void setG(int g)//设置G{this.g = g;}public void setH(int h)//设置H{this.h = h;}/* public String toString(){return "Coords: " +x + ","+y+"\n\tisWall"+isWall;} */
}

package maze;import java.util.ArrayList;//solver是AstarSolver的父类public abstract class Solver
{boolean[][] maze;static Point start;//起点终点static Point end;static ArrayList<Point> open;//openliststatic ArrayList<Point> closed;//closeliststatic ArrayList<Point> solution;//完整解决路径static Point[][] points;//以point为元素组成的迷宫static boolean solvable;Solver(boolean[][] maze)//初始化{solution = new ArrayList<>();this.maze = maze;open = new ArrayList<>();closed = new ArrayList<>();points = new Point[maze.length][maze[0].length];setPointsArray();//设置以point为元素组成的迷宫open.add(start);//openlist加入起点}private void setPointsArray(){for (int row = 0; row < points.length; row++) {for (int col = 0; col < points[0].length; col++) {points[row][col] = new Point(row, col, maze[row][col]);}}int row = points.length;int col = points[0].length;start = points[1][0];end = points[row-2][col-1];//start = points[1][0];//end = points[row-2][col-1];}protected abstract void algorithm();//返回完整的解决路径ArrayList<Point> getSolution(){algorithm();//计算路径的算法，在Astarsolver中实现Point current = end;//从终点往回找while(true){if(!current.isWall())solution.add(current);if(current.getParentPoint() == null)break;current = current.getParentPoint();//通过一步一步找父节点，最终到起点}solvable = solution.contains(end) && solution.contains(start);//通路路径既包含起点也包含终点，那么这条路径就是对的return solution;}//查询solvablepublic boolean isSolvable(){return solvable;//判断路径是可行的吗}//列表中插入一个点void addPoint(ArrayList<Point> points, Point p) {if(points.size() == 0){points.add(p);return;}//F代表了该节点的综合预估值，值越小，到达目标的成本就越小，所以访问的时候尽量优先考虑最小的。//这个列表中F值是从大到小排列的for(int i = 0; i < points.size(); i++)if (points.get(i).getF() <= p.getF()) {points.add(i, p);return;}points.add(p);}//获取F值最低的那个元素Point getLowestInList(ArrayList<Point> ps){if(ps.isEmpty())return null;return ps.get(ps.size()-1);}//判断排列是否有序，正常应该是按F值从大到小排public boolean inOrder(ArrayList<Point> ps){for(int i = 1; i < ps.size(); i++){if(ps.get(i-1).getF() < ps.get(i).getF())return false;}return true;}}

package maze;import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;import javax.swing.JFrame;public class Test extends JFrame implements ActionListener,KeyListener{boolean map[][]=new PMap().prim(2, 0, 20, 19, true);PaintMap p=new PaintMap(map,new EMap(map).exitmap());public Test() {//迷宫的窗口信息this.setTitle("迷宫");this.add(p);this.setSize(500,500);this.setVisible(true);this.setLocationRelativeTo(null);addKeyListener(this);//监听键盘}public static void main(String[] args) {EventQueue.invokeLater(new Runnable() {public void run() {new Test().setVisible(true);}});}public void keyPressed(KeyEvent key) {//监听键盘，上下左右空格switch(key.getKeyCode()) {case KeyEvent.VK_UP:p.moveUp();break;case KeyEvent.VK_DOWN:p.moveDown();break;case KeyEvent.VK_LEFT:p.moveLeft();break;case KeyEvent.VK_RIGHT:p.moveRight();break;case KeyEvent.VK_SPACE:p.PressSp();break;}}public void keyReleased(KeyEvent arg0) {}public void keyTyped(KeyEvent arg0) {}public void actionPerformed(ActionEvent arg0) {}
}

运行结果：

心得体会：

首先，在实现代码前，能够分析题目，设计算法，攥写文档，算是自己的一大进步。敢于实现自己的想法，不局限于老师的提供的方法。不足之处在于，刚开始结合题目考虑栈元素的结构时不够清晰，导致一时无从设计算法。编程是一个严谨的过程，写出每行代码都需要深刻的理解，需要对算法和数据灵活运用。迷宫Java实验强化了我们对链表、队列及其操作的理解和运用，帮助我们更好的学习课程。这次的实验花费了我很多时间，每堂课都进展不大。这样不放手反而没有使自己得到更快的进步反而是自己落后了。所以当我们遇到困难时不要只是盯着困难不去环视周围，我们应该通过向各个方向找出路，就像在迷宫中一样，每次的目标是四面八方。如果我们我们只是盯着阻碍我们的那一点，最后我们只能是被堵死。例如：在java学习中，遇到某一个困难我们要去搜集各方面的资料获得解决这个困难的知识，也可以改变一下算法也是可以的。

实验三：基于A*算法的迷宫相关推荐

实验三基于A*算法的迷宫游戏
软件实习项目三 -- Java实现基于A*算法的迷宫游戏一.实验任务 (1)该题要求随机生成一个迷宫,并求解迷宫: (2)要求游戏支持玩家走迷宫,和系统走迷宫路径两种模式.玩家走迷宫,通过键盘方向键 ...
实验三基于A*算法的迷宫游戏开发
实验要求: 1.迷宫随机生成 2.玩家走迷宫,留下足迹: 3.系统用A*算法寻路,输出路径解决问题: 1.如何显示迷宫的图形界面: 2.如何生成随机的迷宫: 3.怎样移动游戏中走迷宫的"玩 ...
【项目三基于A*算法的迷宫游戏开发】
一. 实验要求 1.迷宫随机生成 2.玩家走迷宫,留下足迹 3.系统用A*算法寻路,输出路径二.前期准备解决迷宫问题要用到两个算法,深度优先遍历(DFS)生成迷宫,A*算法寻路.那么首先要对这两种 ...
实验三、prim算法生成迷宫，A*算法解迷宫（实验准备）
目录实验要求: 算法简介: prim算法: A*算法: 实验要求: 该项目的主要要求是:首先生成一个迷宫,要求随机生成.而生成迷宫有深度优先算法.prim算法.递归分割算法等.老师说建议使用prim ...
算法实验三【电子老鼠闯迷宫】分支限界
算法实验三 [电子老鼠闯迷宫]分支限界 1042.电子老鼠闯迷宫时限:1000ms 内存限制:10000K 总时限:3000ms 描述有一只电子老鼠被困在如下图所示的迷宫中.这是一个12*12单元 ...
20172328 蓝墨云实验——三种查找算法练习
20172328 蓝墨云实验--三种查找算法练习课程:<软件结构与数据结构> 班级: 1723 姓名: 李馨雨学号:20172328 实验教师:王志强老师实验日期:2018年10月1 ...
TIT 计算机图形学实验三使用重心坐标算法绘制颜色渐变的正六面体
TIT 计算机图形学实验三使用重心坐标算法绘制颜色渐变的正六面体前言参考视频计算机图形学全套算法讲解和C++编码实现(共23讲配套源码),计算机图形学案例视频讲解以及主页相关算法.孔老师是我的 ...
河北工业大学数据挖掘实验三应用 Apriori 算法挖掘频繁项集
河北工业大学数据挖掘实验三应用 Apriori 算法挖掘频繁项集一.实验目的二.实验原理 1.Apriori 算法 2.提高频繁项集逐层产生的效率三.实验内容和步骤 1.实验内容 2.实验步骤 ...
实验三基于FPGA的数码管动态扫描电路设计 quartus/数码管/电路模块设计
实验三基于FPGA的数码管动态扫描电路设计源文件的链接放在最后啦实验目的: (1) 熟悉7段数码管显示译码电路的设计. (2) 掌握数码管显示原理及静态.动态扫描电路的设计. 实验任务: (1) ...
实验三基于A*迷宫的算法
一实验要求 1.迷宫随机生成 2.玩家走迷宫,留下足迹: 3.系统用A*算法寻路,输出路径解决问题 1.如何显示迷宫的图形界面: 2.如何生成随机的迷宫: 3.怎样移动游戏中走迷宫的"玩 ...

实验三：基于A*算法的迷宫

实验要求：

解决问题：

实验三：基于A*算法的迷宫相关推荐

最新文章

热门文章