A*算法走迷宫

最新推荐文章于 2023-12-23 21:04:26 发布
最新推荐文章于 2023-12-23 21:04:26 发布
阅读量586 收藏 5
点赞数
分类专栏： 算法 文章标签： 算法 自然语言处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45172417/article/details/109558689
版权

不多说了先上代码

hpp

#include <stdio.h>
#include<string.h>
#include<math.h>
#include<iostream>
#include<opencv2/highgui.hpp>
#include<opencv2/opencv.hpp>
using namespace cv;
using namespace std;
//池化，用于图像降维
Mat pool_max(Mat image_source, int size);
Mat pool_min(Mat image_source, int size);
int f(int x1,int x2,int z1,int z2);

class A
{
    private:
    int rate=6;
    int map[300][300];
    Mat m;
    //open，close表的栈顶
    int tag_open=0,tag_close=0;
    //用来存每一点的父节点
    int map_root[300][300][2];
    //入口
    int x1;
    int x2;
    //出口
    int z1;
    int z2;
    //路径
    int way[1000][2];
    //表的第三个参数是代价
    //倒放，从大到小，tag_close是最小close[x][2]的x,3,4,父节点坐标
    int close[24400][3];
    //倒放，从大到小，tag_open是最小open[x][2]的x
    int open[24400][4];
    public:
    //用于存放读入原图
    Mat image_source;
    //图片降维
    void deal_image();
    //找到出入口
    void find_ori();
    //a*算法核心
    void deal_A();
    //输出路径
    void draw_road();

};
void A::draw_road()
{
    Mat rgb;
    rgb=imread("3.png",1);
    VideoWriter witer = VideoWriter("m3.avi",CV_FOURCC('M','P','4','2'),40,Size(image_source.cols,image_source.cols),1);//保存视频
    int mm=0;
    //每次循环画一个点
    while(1)
    {
        mm++;
        //为了画大点，所以下面写了九个像素
        for(int tag_a=4;tag_a<7;tag_a++)
        for(int tag_b=4;tag_b<7;tag_b++)
        for(int tag_c=0;tag_c<2;tag_c++)
        rgb.at<Vec3b>((map_root[z1][z2][0]*rate+tag_a),(map_root[z1][z2][1]*rate+tag_b))[tag_c%3]=0;
        imshow("a",rgb);
        waitKey(1);
    z1=map_root[z1][z2][0];
    z2=map_root[z1][z2][1];
    //输出位置坐标
    witer<<rgb;
    printf("%d %d \n",z1,z2);
    //如果点数超过1000或者到达终点结束画路径
    if(((z1==x1)&&(z2==x2))||mm>1000)break;
    }
    //最后一帧停止，按键继续
    imshow("a",rgb);

    witer.release();
}
void A::find_ori()
{
    Mat image_b;
        GaussianBlur(image_source,image_b,Size(3,3),5);
    //图片二值化
    for(int tag_a=0;tag_a<image_b.rows;tag_a++)
    {
    for(int tag_b=0;tag_b<image_b.cols;tag_b++)
    if(image_b.at<uchar>(tag_a,tag_b)>100)image_b.at<uchar>(tag_a,tag_b)=255;
    else image_b.at<uchar>(tag_a,tag_b)=0;
    }
    //最左侧和最右侧的白像素为出入口
    for(int tag_b=0;tag_b<image_b.cols;tag_b++)
    if(image_b.at<uchar>(tag_b,0)==255)
    {
        x1=tag_b/rate-1;
        x2=0;
    }

    for(int tag_b=0;tag_b<image_b.cols;tag_b++)
    if(image_b.at<uchar>(tag_b,image_b.rows-1)==255)
    {
        z1=tag_b/rate-1;
        z2=(image_b.rows)/rate-1;
    }

}
void A::deal_image()
{   //读图
    image_source = imread("3.png",0);
    //初始化图片b
    Mat b;
    //图片高斯降噪
    GaussianBlur(image_source,b,Size(3,3),5);
    //图片二值化
    for(int tag_a=0;tag_a<b.rows;tag_a++)
    {
    for(int tag_b=0;tag_b<b.cols;tag_b++)
    if(b.at<uchar>(tag_a,tag_b)>100)b.at<uchar>(tag_a,tag_b)=255;
    else b.at<uchar>(tag_a,tag_b)=0;
    }
    //图片池化3*3（缩小三倍）（处理两次，九倍）
    //m=pool_min(pool_max(b,3),3);
    m=pool_min(b,6);
    //再次二值化
    for(int tag_a=0;tag_a<m.rows;tag_a++)
    {
    for(int tag_b=0;tag_b<m.cols;tag_b++)
    if(m.at<uchar>(tag_a,tag_b)>100)m.at<uchar>(tag_a,tag_b)=255;
    else m.at<uchar>(tag_a,tag_b)=0;
    }
    //展示图片
    imshow("c",m);
    //将图片信息载入数组map
    for(int tag_a=0;tag_a<m.rows;tag_a++)
    for(int tag_b=0;tag_b<m.cols;tag_b++)
    map[tag_a][tag_b]=m.at<uchar>(tag_a,tag_b);
}
void A::deal_A()
{
    int keyy1=0,keyy2=0,keyy3=0,keyy4=0;
    map_root[z1][z2][0]=5;
    //入口放入close表
    close[0][0]=x1;
    close[0][1]=x2;
    tag_close++;
    //com用来对比找出open表代价最小的
    int com[2]={10000,0};
while(1)
{
//上下左右寻找合法，而且是白色的像素
if(map[close[tag_close-1][0]][close[tag_close-1][1]+1]==255&&close[tag_close-1][0]>=0&&(close[tag_close-1][1]+1)>=0)
{   //close栈顶充当新点（open表内）的父节点

        for(int tag_a=0;tag_a<tag_open;tag_a++)
    {
        //如果open表里已经有这个点了
        if((close[tag_close-1][0])==open[tag_a][0]&&(close[tag_close-1][1]+1)==open[tag_a][1])
    {   //更新代价
        //open[tag_a][2]=close[tag_close-1][2]+1;
        keyy1=1;
        break;
    }
        if(keyy1==0)
    {
        map_root[close[tag_close-1][0]][close[tag_close-1][1]+1][0]=close[tag_close-1][0];
        map_root[close[tag_close-1][0]][close[tag_close-1][1]+1][1]=close[tag_close-1][1];
    }
    keyy1=0;
    
    }
    //com记录了open表最小的序号，而且这个已经进入close了，所以这里可以放个新的open点
    if(open[com[1]][3]==100000)
    {
        open[com[1]][0]=close[tag_close-1][0];
        open[com[1]][1]=close[tag_close-1][1]+1;
        open[com[1]][2]=close[tag_close-1][2]+1;
        open[com[1]][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);

    }
    else
    {
    //只能放在open顶了
        open[tag_open][0]=close[tag_close-1][0];
        open[tag_open][1]=close[tag_close-1][1]+1;
        open[tag_open][2]=close[tag_close-1][2]+1;
        open[tag_open][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);
        tag_open++;
    }
    

}
if(map[close[tag_close-1][0]][close[tag_close-1][1]-1]==255&&close[tag_close-1][0]>=0&&(close[tag_close-1][1]-1)>=0)
{

        for(int tag_a=0;tag_a<tag_open;tag_a++)
    {
        if((close[tag_close-1][0])==open[tag_a][0]&&(close[tag_close-1][1]-1)==open[tag_a][1])
    {
        //open[tag_a][2]=close[tag_close-1][2]+1;
        keyy2=1;
        break;
    }
        if(keyy2==0)
    {
        map_root[close[tag_close-1][0]][close[tag_close-1][1]-1][0]=close[tag_close-1][0];
        map_root[close[tag_close-1][0]][close[tag_close-1][1]-1][1]=close[tag_close-1][1];
    }
    keyy2=0;
    
    }
        if(open[com[1]][3]==100000)
    {
        open[com[1]][0]=close[tag_close-1][0];
        open[com[1]][1]=close[tag_close-1][1]-1;
        open[com[1]][2]=close[tag_close-1][2]+1;
        open[com[1]][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);

    }
    else
    {
        open[tag_open][0]=close[tag_close-1][0];
        open[tag_open][1]=close[tag_close-1][1]-1;
        open[tag_open][2]=close[tag_close-1][2]+1;
        open[tag_open][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);
        tag_open++;
        

    }
    

}
if(map[close[tag_close-1][0]+1][close[tag_close-1][1]]==255&&(close[tag_close-1][0]+1)>=0&&(close[tag_close-1][1])>=0)
{

    for(int tag_a=0;tag_a<tag_open;tag_a++)
    {
        if((close[tag_close-1][0]+1)==open[tag_a][0]&&(close[tag_close-1][1])==open[tag_a][1])
    {
        //open[tag_a][2]=close[tag_close-1][2]+1;
        keyy3=1;
        break;
    }
        if(keyy3==0)
        {
        map_root[close[tag_close-1][0]+1][close[tag_close-1][1]][0]=close[tag_close-1][0];
        map_root[close[tag_close-1][0]+1][close[tag_close-1][1]][1]=close[tag_close-1][1];
        }
    keyy3=0;
    
    }
            if(open[com[1]][3]==100000)
    {
        open[com[1]][0]=close[tag_close-1][0]+1;
        open[com[1]][1]=close[tag_close-1][1];
        open[com[1]][2]=close[tag_close-1][2]+1;
        open[com[1]][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);

    }
    else
    {
            open[tag_open][0]=close[tag_close-1][0]+1;
            open[tag_open][1]=close[tag_close-1][1];
            open[tag_open][2]=close[tag_close-1][2]+1;
            open[tag_open][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);
            tag_open++;
        

    }
    

}
if(map[close[tag_close-1][0]-1][close[tag_close-1][1]]==255&&(close[tag_close-1][0]-1)>=0&&(close[tag_close-1][1])>=0)
{

    
    for(int tag_a=0;tag_a<tag_open;tag_a++)
    {
        if((close[tag_close-1][0]-1)==open[tag_a][0]&&(close[tag_close-1][1])==open[tag_a][1])
    {
        //open[tag_a][2]=close[tag_close-1][2]+1;
        keyy4=1;
        break;
    }
        if(keyy4==0)
        {
        map_root[close[tag_close-1][0]-1][close[tag_close-1][1]][0]=close[tag_close-1][0];
        map_root[close[tag_close-1][0]-1][close[tag_close-1][1]][1]=close[tag_close-1][1];
        }
    keyy4=0;
    }

            if(open[com[1]][3]==100000)
    {
        open[com[1]][0]=close[tag_close-1][0]-1;
        open[com[1]][1]=close[tag_close-1][1];
        open[com[1]][2]=close[tag_close-1][2]+1;
        open[com[1]][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);

    }
    else
    {
    open[tag_open][0]=close[tag_close-1][0]-1;
    open[tag_open][1]=close[tag_close-1][1];
    open[tag_open][2]=close[tag_close-1][2]+1;
    open[tag_open][3]=f(open[tag_open][0],open[tag_open][1],z1,z2);
    tag_open++;

    }

}
com[0]=10000;
com[1]=0;
//找出代价最小的open点
for(int tag_a=0;tag_a<tag_open;tag_a++)
{
if((open[tag_a][2]+open[tag_a][3])<com[0])
{
    com[1]=tag_a;
    com[0]=open[tag_a][2]+open[tag_a][3];
}

}
//放到close表
close[tag_close][0]=open[com[1]][0];
close[tag_close][1]=open[com[1]][1];
//map_root[close[tag_close][0]][close[tag_close][1]][0]=close[tag_close-1][0];
//map_root[close[tag_close][0]][close[tag_close][1]][1]=close[tag_close-1][1];
//close走过的点涂黑
map[close[tag_close-1][0]][close[tag_close-1][1]]=0;
//重置比较位
open[com[1]][3]=100000;
tag_close++;
    //printf("\n %d %d\n",close[tag_close-1][0],close[tag_close-1][1]);
//waitKey(5);
if(map[z1][z2]==0)break;
}


}


int f(int x1,int x2,int z1,int z2)
{

return abs(x1-z1)+abs(x2-z2);
}
Mat pool_max(Mat image_source, int size)
{
    int rows = image_source.rows;
    int cols = image_source.cols;
    int tag_x=0,tag_y=0,tag1=0,tag2=0;
    int tag3[3]={0,0,0};
    Mat image_new(image_source.rows/size,image_source.cols/size,CV_8UC1);
    while(tag_x>=0&&tag_x<=rows-size)//欠调
    {
        while(tag_y>=0&&tag_y<=cols-size)
        {
            while(tag1>=0&&tag1<=size)
            {
                while(tag2>=0&&tag2<=size)
                {
                    if(image_source.at<uchar>(tag_x+tag1,tag_y+tag2)>tag3[1])(tag3[1]=image_source.at<uchar>(tag_x+tag1,tag_y+tag2));
                    tag2++;
                }
                tag1++;
                tag2=0; 
            }
            image_new.at<uchar>(tag_x/size,tag_y/size)=tag3[1];
            tag3[1]=0;
            tag_y+=size;tag1=0;tag2=0;
        }
        tag_x+=size;
        tag_y=0;tag1=0;tag2=0;
    }
    return image_new;

}
Mat pool_min(Mat image_source, int size)
{
    int rows = image_source.rows;
    int cols = image_source.cols;
    int tag_x=0,tag_y=0,tag1=0,tag2=0;
    int tag3[3]={0,0,0};
    Mat image_new(image_source.rows/size,image_source.cols/size,CV_8UC1);
    while(tag_x>=0&&tag_x<=rows-size)//欠调
    {
        while(tag_y>=0&&tag_y<=cols-size-1)
        {
            while(tag1>=0&&tag1<=size)
            {
                while(tag2>=0&&tag2<=size)
                {
                    if(image_source.at<uchar>(tag_x+tag1,tag_y+tag2)<tag3[1])(tag3[1]=image_source.at<uchar>(tag_x+tag1,tag_y+tag2));
                    tag2++;
                }
                tag1++;
                tag2=0; 
            }
            image_new.at<uchar>(tag_x/size,tag_y/size)=tag3[1];
            tag3[1]=255;
            tag_y+=size;tag1=0;tag2=0;
        }
        tag_x+=size;
        tag_y=0;tag1=0;tag2=0;
    }
    return image_new;

}

cpp

#include"map.hpp"


int main()
{
    A a;
    a.deal_image();
    a.find_ori();
    a.deal_A();
    a.draw_road();


}

备注

本文旨在展示A*效果，所以在鲁棒性方面没有做太多研究，图片数据来源http://mazegenerator.net/
参数如下
在这里插入图片描述
效果：
在这里插入图片描述
代码中可以自动保存视频，这里放了一张最后的截图
这边opencv出现越界情况不报错，其他设备运行可能会碰到越界之类的问题，欢迎评论指正

〆、怀烈
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
障碍寻路算法c语言,C++ DFS算法实现走迷宫自动寻路
weixin_31163527的博客
05-25 984
C++ DFS算法实现走迷宫自动寻路，供大家参考，具体内容如下深度优先搜索百度百科解释：事实上，深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次.运行效果：说明：深度优先搜索算法是在我在图的部分接触到的，后来才发现它也可以不用在图的遍历上，它是一个独立的算法，它也可以直接用在一...
a*算法迷宫 c++_迷宫中的老鼠
weixin_35370061的博客
01-29 305
本课程是从少年编程网转载的课程，目标是向中学生详细介绍计算机比赛涉及的编程语言，数据结构和算法。编程学习最好使用计算机，请登陆www.3dian14.org(免费注册，免费学习)。之前我们已经讨论了采用回溯(Backtracking)方法来解决国际象棋中马的遍历问题。为了让大家更加熟悉回溯方法，我们将在后面的课程中再分析几个例子。今天先看一个使用回溯方法解决老鼠走迷宫的问题。下图是一...
a*寻路 c++实现
11-02
a*寻路算法, 八方向 ,c++ 二叉堆 实现，vs2010下可直接编译运行 可用于游戏寻路等 注：这是某开源代码的修正版，原版有错误和无意义代码，不能发就算了
计算机软件实习 项目三：A*算法迷宫自动寻路
m0_67531703的博客
09-27 406
1.A*算法。
#include＜math.h＞头文件内容总结
weixin_74399729的博客
11-15 4931
C语言提供了可供使用的一系列数学函数存储在math.h头文件中供给使用，下列是常用的数学函数。如果直接使用log则是以e为底数的对数运算。向下取整： floor（变量名）向上取整： ceil（变量名）所有的三角函数必须使用弧度制。用于计算变量1的变量2次方。pow（变量1，变量2）正弦函数sin（变量名）round（变量名）
迷宫问题的A*算法(python实现)
07-05
附件中A_star.py为算法实现，有两个txt文件作为测试样例，mediumMaze是一个封闭的迷宫，openmaze是一个开放的迷宫
A*算法实现迷宫问题
12-13
用人工智能中的A*算法解决迷宫的路径寻找问题
基于A*算法的迷宫搜索向心法法则
01-13
针对IEEE标准的电脑鼠走迷宫中向心搜索算法在某些情况下搜索效率不高的问题，采用了一种基于A*算法的改进型向心法法则对传统向心法进行了改进。通过两种算法的对比试验验证，改进型算法转弯46次共74步，传统算法转弯...
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
07-05
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
基于A*算法的走迷宫程序
10-25
这是我在网络上看到的一个用A*算法写的走迷宫程序，拿出来跟大家一块分享作者的作品。
C++ math.h
qq_27960411的博客
08-09 1754
1、三角函数 Trigonometric functions 1.1、 cos() 函数 /* cos example / #include <stdio.h> / printf / #include <math.h> / cos */ #define PI 3.14159265 int main () { double param, result; ...
C语言数学函数库＜math.h＞及常用函数
weixin_73070469的博客
04-16 1万+
C语言中常用的一个数学函数库，里面涵盖了常用的数学运算，如求对数、指数、绝对值、三角函数、两数中最大数等。库中的函数用法都很简单，传入的参数一般都是实数或虚数，包括整型、double、long double、float型等。
软件实习项目三：基于A*搜索算法迷宫游戏开发——代码
qq_50944418的博客
12-27 450
文章目录PMap.javaEMap.javaPaintMap.javaTest.javaAStarSolver.javaPoint.javaSolver.java PMap.java package gyt; import java.util.ArrayList; import javax.swing.JPanel; /**Prim算法： 让迷宫全都是墙。 选一个格，作为迷宫的通路，然后把它的邻墙放入列表。 当列表里还有墙时: 从列表里随机选一个墙，如果它对面的格子不
A*算法求解迷宫寻路问题（启发式算法）
lazyn的博客
10-24 2万+
A*算法求解迷宫寻路问题 设置两种地图，两种启发式函数，分析不同起点终点，分析不同启发式函数，分析不同地图。
A*算法求解迷宫寻路问题实验
power_function的博客
09-05 2006
A* 搜索算法是一种启发式搜索算法。所谓启发式搜索算法，就是在盲目搜索算法中加入一个启发函数，在当前节点搜索完毕后，通过这个启发函数来进行计算，选择代价最少的节点作为下一步搜索的节点。通过这样的方式就能够找到最优解。DFSBFS这两种搜索方式都属于盲目的搜索方式，它不会在选择下一个节点的时候进行代价计算，而是按照一个固定的方式选择，这样在运气不好的情况，会对所有节点进行遍历。A* 搜索算法的核心就在于如何设计一个好的启发函数，启发函数的表达形式为：f(n)=g(n)+h(n)。
＜math.h＞ 头文件：C语言数学库函数
最新发布
PengXing_Huang的博客
12-23 1248
头文件包含常用函数的详细讲解。
math.h
明天，争取的博客
11-19 2506
#include <math.h>
#include「math.h」
西红柿炒鸡蛋
07-04 5154
#include<stdio.h> #include<stdlib.h> #include<math.h> #define Π 3.14159265 /* @注意 1:math.h所有函数的返回值与传参都是double 2:Π的标准值:3.14159265 //多一位少一位都不行 3:一度=Π/180 4:e = 2.718282 5:log() //默认e为对数 6:函数传递单个地址用&就能ok ; 传递系列地址用指针; 7:pow(x,y) --
C语言中#include的介绍——及常见的头文件（库函数）
热门推荐
刘鑫磊
04-19 3万+
目录： 一：#include作用 二：#include 的处理过程 三：#include 的用法有两种，如下所示 四：使用尖括号< >和双引号" "的区别在于头文件的搜索路径不同 五：尖括号< >和双引号" "的适用情况 六：常见的头文件（库函数）如下 include是一个计算机专业术语 一指C/C++中包含头文件命令，用于将指定头文件嵌入源文件中 二...
a*算法走迷宫 matlab实现
06-06
在Matlab中，我们可以按照以下步骤实现A*算法走迷宫： 1. 定义地图矩阵：用0表示可行的区域，用1表示障碍物或不可行区域。 2. 根据实际情况选择起点和终点，将它们的位置在地图矩阵中标记为2和3。 3. 定义open表...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值