【easyx 入门】基于 easyx 和 C++ 的寻路算法演示图（内含 BFS,双向 BFS,无随机 DFS,有随机 DFS,A* 算法（两种），Version. 2（解决闪烁问题）

最新推荐文章于 2025-06-15 19:20:03 发布
最新推荐文章于 2025-06-15 19:20:03 发布
阅读量397 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： easyx 编程 C/C++ 文章标签： 算法 c++ easyx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ainiyoung/article/details/142675769

介绍

基于 easyx 和 C++ 的寻路算法演示图。Version. 2（解决闪烁问题）

修复的地方

本作者发现了不少可以优化的地方，比如说在进行绘制的时候，只需要对一个地方进行改变，而不是全部，就解决了闪烁的问题

代码

/*
###################################################################################################################################
#                                                                                                                                 #
#            #########               #        #     ##                   ###          ######       ####                 #    #    #
#                #                  # #       #   ##                    #   #        #      #      #   ##               #    #    #
#                #                 #   #      # ##                     #     #       #             #     ##             #    #    #
#                #                #     #     ##                      #               ######       ##   ##              #    #    #
#                #               #########    # ##                    #       #             #      # ###    ########    #    #    #
#                #              #         #   #   ##                   #     #              #      #                    #    #    #
#                #             #           #  #     ##                  #   #        #     #       #               #    #         #
#            #########        #             # #       ##                 ###          #####        #                ####     #    #
#                                                                                                                                 #
###################################################################################################################################
*/
#include<stdio.h>
#include<easyx.h>
#include<conio.h>
#include<stdio.h>
#include<graphics.h>
#include<windows.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
namespace IO{
   
    #define ll long long
    long long fast_pow(long long a,long long b,long long mod){
   
        ll sum=1;
        while(b){
   
            if(b&1) sum=(sum*a)%mod;
            a=(a*a)%mod;
            b>>=1;
        }
        return sum%mod;
    }
    ll fast_times(ll a,ll b,ll p){
   
    	ll ret=0;
    	while(b){
   
    	    if(b&1) ret=(ret+a)%p;
    	    b>>=1;
    	    a=(a+a)%p;
    	}
    	return ret;
    }
    ll very_fast_times(ll a,ll b,ll m){
   
        unsigned long long c=(unsigned long long)a*b-(unsigned long long)((long double)a/m*b+0.5L)*m;
        if(c<m) return c;
        return c+m;
    }
    ll inv(ll a,ll p){
   
    	return fast_pow(a,p-2,p);
	}
    #undef ll
}
using namespace IO;
class BigNum{
   
   #define MAXN 9999
   #define SIZE 10000
   #define DLEN 4
private:
   int a[5000],len;
   bool neg;
public:
   BigNum(){
   len=1;neg=0;memset(a,0,sizeof(a));}
   BigNum(const int b){
   
   	int c,d=b;
   	if(d<0)	neg=1,d=-d;
   	else	neg=0;
   	len=0;
   	memset(a,0,sizeof(a));
   	while(d>MAXN){
   
   		c=d-(d/(MAXN+1))*(MAXN+1);
   		d=d/(MAXN+1);
   		a[len++]=c;
   	}
   	a[len++]=d;
   }
   BigNum(const long long b){
   
   	long long c,d=b;
   	if(d<0)	neg=1,d=-d;
   	else	neg=0;
   	len=0;
   	memset(a,0,sizeof(a));
   	while(d>MAXN){
   
   		c=d-(d/(MAXN+1))*(MAXN+1);
   		d=d/(MAXN+1);
   		a[len++]=c;
   	}
   	a[len++]=d;
   }
   BigNum(char* s){
   
   	memset(a,0,sizeof(a));
   	int l=strlen(s);
   	if(s[0]=='-'){
   
   		neg=1;
   		for(int i=0;i<l;i++)	s[i]=s[i+1];
   		l--;
   	}
   	else	neg=0;
   	len=l/DLEN;
   	if(l%DLEN)	len++;
   	int idx=0;
   	for(int i=l-1;i>=0;i-=DLEN){
   
   		int t=0,k=i-DLEN+1;
   		if(k<0)	k=0;
   		for(int j=k;j<=i;j++)	t=t*10+s[j]-'0';
   		a[idx++]=t;
   	}
   }
   BigNum(string s){
   
   	memset(a,0,sizeof(a));
   	if(s[0]=='-'){
   
   		neg=1;
   		s=s.substr(1);
   	}
   	else neg=0;
   	int l=s.size();
   	len=l/DLEN;
   	if(l%DLEN)	len++;
   	int idx=0;
   	for(int i=l-1;i>=0;i-=DLEN){
   
   		int t=0,k=i-DLEN+1;
   		if(k<0)	k=0;
   		for(int j=k;j<=i;j++)	t=t*10+s[j]-'0';
   		a[idx++]=t;
   	}
   }
   BigNum(const char c){
   
   	memset(a,0,sizeof(a));
   	neg=0;
   	len=1;
   	a[0]=c-'0';
   }
   BigNum(const BigNum &T):len(T.len){
   
   	neg=T.neg;
   	memset(a,0,sizeof(a));
   	for(int i=0;i<len;i++)	a[i]=T.a[i];
   }
   
   friend istream& operator>>(istream& in,BigNum &b){
   
   	string ch;
   	in>>ch;
   	b=BigNum(ch);
   	return in;
   }
   friend ostream& operator<<(ostream& out,BigNum b){
   
   	if(b.neg)	out<<"-";
   	out<<b.a[b.len-1];
   	for(int i=b.len-2;i>=0;i--){
   
   		out.width(DLEN);
   		out.fill('0');
   		out<<b.a[i];
   	}
   	return out;
   }
   
   BigNum& operator=(const BigNum& T){
   
   	len=T.len;
   	neg=T.neg;
   	memset(a,0,sizeof(a));
   	for(int i=0;i<len;i++)	a[i]=T.a[i];
   	return *this; 
   }
   template<typename T1>
   BigNum& operator=(const T1& T){
   
   	BigNum tmp=BigNum(T);
   	len=tmp.len;
   	neg=tmp.neg;
   	memset(a,0,sizeof(a));
   	for(int i=0;i<len;i++)	a[i]=tmp.a[i];
   	return *this;
   }
   
   bool operator>(const BigNum& T)const{
   
   	if(len>T.len)	return true;
   	if(len==T.len){
   
   		int l=len-1;
   		while(a[l]==T.a[l]&&l>=0)	l--;
   		if(l>=0&&a[l]>T.a[l])	return true;
   		return false;
   	}
   	return false;
   }
   template<typename T1>
   bool operator>(const T1& T)const{
   
   	BigNum t2(T);
   	return *this>t2;
   }
   
   bool operator<(const BigNum& T)const{
   
   	if(len<T.len)	return true;
   	if(len==T.len){
   
   		int l=len-1;
   		while(a[l]==T.a[l]&&l>=0)	l--;
   		if(l>=0&&a[l]<T.a[l])	return true;
   		return false;
   	}
   	return false;
   }
   template<typename T1>
   bool operator<(const T1& T)const{
   
   	BigNum t2(T);
   	return *this<t2;
   }
   
   bool operator>=(const BigNum T)const{
   
   	if(len>T.len)	return true;
   	if(len==T.len){
   
   		int l=len-1;
   		while(a[l]==T.a[l]&&l>=0)	l--;
   		if(l<0)	return true;
   		if(a[l]>=T.a[l])	return true;
   		return false;
   	}
   	return false;
   }
   template<typename T1>
   bool operator>=(const T1 T)const{
   
   	BigNum t2(T);
   	return *this>=t2;
   }
   
   bool operator<=(const BigNum T)const{
   
   	if(len<T.len)	return true;
   	if(len==T.len){
   
   		int l=len-1;
   		while(a[l]==T.a[l]&&l>=0)	l--;
   		if(l<0)	return true;
   		if(a[l]<=T.a[l])	return true;
   		return false;
   	}
   	return false;
   }
   template<typename T1>
   bool operator<=(const T1 T)const{
   
   	BigNum t2(T);
   	return *this<=t2;
   }
   
   bool operator==(const BigNum T)const{
   
   	if(len!=T.len)	return false;
   	for(int i=0;i<len;i++){
   
   		if(a[i]!=T.a[i])	return false;
   	}
   	return true;
   }
   template<typename T1>
   bool operator==(const T1 T)const{
   
   	BigNum t(T);
   	return t==(*this);
   }
   
   BigNum operator+(const BigNum T){
   
   	BigNum t(*this);
   	int big=T.len>len?T.len:len;
   	for(int i=0;i<big;i++){
   
   		t.a[i]+=T.a[i];
   		if(t.a[i]>MAXN){
   
   			t.a[i+1]++;
   			t.a[i]-=MAXN+1;
   		}
   	}
   	if(t.a[big]!=0)	t.len=big+1;
   	else	t.len=big;
   	return t;
   }
   template<typename T1>
   BigNum operator+(const T1 T){
   
   	BigNum t1(*this),t2(T);
   	return t1+t2;
   }
   
   BigNum operator-(const BigNum T){
   
   	BigNum t1,t2;
   	bool flag;
   	if(*this>T){
   
   		t1=*this,t2=T;
   		flag=0;
   	}
   	else{
   
   		t1=T,t2=*this;
   		flag=1;
   	}
   	int big=t1.len;
   	for(int i=0;i<big;i++){
   
   		if(t1.a[i]<t2.a[i]){
   
   			int j=i+1;
   			while(t1.a[j]==0)	j++;
   			t1.a[j]--;
   			j--;
   			while(j>i)	t1.a[j--]+=MAXN;
   			t1.a[i]+=MAXN+1-t2.a[i]; 
   		}
   		else	t1.a[i]-=t2.a[i];
   	}
   	t1.len=big;
   	while(t1.a[t1.len-1]==0&&t1.len>1){
   
   		t1.len--;
   		big--;
   	}
   	if(flag)	t1.neg^=1;
   	return t1;
   }
   template<typename T1>
   BigNum operator-(const T1 T){
   
   	BigNum t1(*this),t2(T);
   	return t1-t2;
   }
   
   BigNum operator*(const BigNum &T)const{
   
   	BigNum ret;
   	int i,j;
   	for(i=0;i<len;i++){
   
   		int up=0;
   		for(j=0;j<T.len;j++){
   
   			int tmp=a[i]*T.a[j]+ret.a[i+j]+up;
   			if(tmp>MAXN){
   
   				int tmp1=tmp-tmp/(MAXN+1)*(MAXN+1);
   				up=tmp/(MAXN+1);
   				ret.a[i+j]=tmp1;
   			}
   			else{
   
   				up=0;
   				ret.a[i+j]=tmp;
   			}
   		}
   		if(up!=0)	ret.a[i+j]+=up;
   	}
   	ret.len=i+j;
   	while(ret.a[ret.len-1]==0&&ret.len>1)	ret.len--;
   	return ret;
   }
   template<typename T1>
   BigNum operator*(const T1 T)const{
   
   	BigNum t1(*this),t2(T);
   	BigNum ans=t1*t2;
   	return ans;
   }
   
   BigNum operator/(
最低0.47元/天 解锁文章
八皇后（内含动态演示）
thoven_fish的博客
09-12 3173
// 只用C++完成的一个八皇后问题，以图形的形式展示92种结果，以及算法的具体动态演示 几个需要提前注意的问题： 1.由于需要利用C++画图，所以我使用EasyX图形函数库。可以在 EasyX下载 处直接下载，然后识别安装自己的编程软件即可使用。    在使用此图形库时，需包含 #include "graphics.h" 头文件，依次打开后可以查看到EasyX里面函数的使用（或是安装在
Easyx图形库输出
xxxx7463的博客
07-20 3441
1.输出字 2.输出数字变量
EasyX图形界面 输出数据
m0_46943867的博客
06-18 3264
没错！就是把数据转成字符型再输出！ setbkmode(TRANSPARENT);//设置背景为透明 settextcolor(COLORREF(RGB(0, 0, 0)));//黑色字体 settextstyle(20, 0, _T("楷体"));//20号字体，楷体 swprintf_s(str, _T("%lf"), price);//转化为字符 outtextxy(490, 150, str);//输出 ...
EasyX在画布上输出整形数字
mkabaka的博客
07-03 6560
将int转换为char*并输出，代码如图。 如果你的sprintf函数报错的话，就需要设置SDL检查。 如果没有，请直接看第 6 步 设置具体步骤是：首先点击项目-->属性 选择C/C++ -->常规 将SDL检查设置为“否” 如果是outtextxy()或者是其他输出字符串的函数报图示错误的话，需要设置项目的字符集。 设置具体步骤是：首先点击项目-->属性 点击配置属...
[Easyx]一个以图像模式输出数字的函数
白浅星
04-14 3368
注释版： void PutNumber( long x, //输出位置 long y, long number,//数字 int TextSize=10, //文字的尺寸 int TextProportion=2, //文字的高宽比 int TextInterval=0, //文字之间的间隔 COLORREF tc = 0x00...
计算机图形学画花瓣曲线
11-24
利用VC，划出花瓣曲线。用户可以通过交互，控制四个变量来改变花瓣形状：半径大小，旋转角度，花瓣数目，花瓣厚度。
【easyx 入门】基于 easyx 和 C++ 的寻路算法演示图（内含多种寻路算法）
08-26
【easyx 入门】基于 easyx 和 C++ 的寻路算法演示图（内含 BFS,双向 BFS,无随机 DFS,有随机 DFS,A* 算法（两种），还有 Dijkstra（会在二维中退化成 BFS）） 推广一下这篇博文：...
C++实现的多种寻路算法演示与分析
文章中提到的寻路算法包括广度优先搜索（BFS）、双向广度优先搜索（双向BFS）、有随机性的深度优先搜索（有随机DFS）、无随机性的深度优先搜索（无随机DFS）以及A*算法（包含两种实现方式）和Dijkstra算法。...
(源码)基于C++和EasyX图形库的迷宫探索者之路系统.zip
03-27
# 基于C++和EasyX图形库的迷宫探索者之路系统 ## 项目简介 "迷宫探索者之路系统" 是一款基于C++和EasyX图形库开发的迷宫寻路游戏。该游戏利用深度优先搜索（DFS）和广度优先搜索（BFS）算法，在虚拟迷宫中提供有趣...
机器人寻路算法双向A*（Bidirectional A*）算法的实现C++、Python、Matlab语言
weixin_44584198的博客
03-27 3114
最近好久没更新，在搞华为的软件挑战赛（软挑），好卷只能说。去年还能混进32强，今年就比较迷糊了，这东西对我来说主要还是看运气，毕竟没有实力哈哈哈。但是，好歹自己吭哧吭哧搞了两周，也和大家分享一下自己的收获吧，希望能为后来有需要的同学提供一些帮助。我其实不太了解寻路算法的，很多代码也是找的demo自己改的，非常感谢这些大佬的帮助，有些引用可能现在也找不太到了，列不出来，非常感谢万能网友的代码，在此一起感谢啦！部分参考如下： A*算法路径规划之Matlab实现 A算法路径规划博文附件1.zip 基于matlab
easyx可视化 以及回溯算法
jjjjiiiaa的博客
01-09 497
【代码】easyx可视化 以及回溯算法。
基于EasyX实现的字符统计器（条形统计图）
08-26
最近闲来无事，在家里用EasyX写了一个简(jian)洁(lou)的字母统计程序，刚好锻炼一下自己的实战能力，程序代码很简单，只有100多行，支持统计字母（小写），数字，中文暂不支持。输出为条形统计图形式 注：编译环境为VC2022，编译需要用到EasyX库，下载地址：https://easyx.cn/download/EasyX_20220610.exe 本人承诺：所有资源全部免费！！！
EasyX实现的变换曲线
12-07
计算机图形学EasyX实现的变换曲线，用C++写的，计算机图形学的综合实验
关于用EasyX的outtextxy()输出int类型的问题
qq_44000076的博客
04-16 8570
我就只是想要在图形界面里输出个数字，没想到折腾了一上午，记录一下。 在网上查的方法是这样的： char num[20]; int n=123 sprintf(num, "%d", n); outtextxy(100,100,num) 但是，outtextxy（）会报错：没有与参数列表相匹配的重载函数。 解决方法是： 打开项目属性 点击配置属性下的高级 将字符集设置为使用Un...
通过EasyX实现中点画线
游戏开发、游戏引擎开发、逆向破解爱好者
04-20 2258
作为数值微分法（DDA）的改进算法，中点画线法【采用了直线的一般式方程、增量思想,实现整数加法】 中点画线法 每次在最大位移方向上走一步，而另一个方向是走步还是不走步要取决于中点误差项的判断。 假定：0<=|k|<=1,每次在x方向上加1，y方向上加或不变需要判断。 d是x,y的线性函数采用增量计算是可行的，所以可以用增量计算的方法导出d的增量表达式，且增量计算提高运...
EasyX接收并显示从控制台输入的数字和英文
热门推荐
丶虎子oc
12-11 1万+
vs使用EasyX接收并显示从控制台输入的数字和英文
easyx输出整数
m0_49952522的博客
04-03 3287
easyx输出整数 经常会用到的功能，写个博客下次忘了找起来方便 char demo[20] = ""; string st = "货物剩余量：" + to_string(number); strcpy_s(demo, st.c_str()); outtextxy(30, 500 - 20 * number - 60, demo); 就是用to_string把整数变成字符串 再用strcpy_s把字符串存到字符数组里 然后就可以在outtextxy里面把字符数组传进去 ...
用easyx画超级好看的动态图
资资的博客
11-26 6535
这几天接触了easyx，就想用来画图试试 由于上传不了视频，大家可以跑代码试一试 其实没多难的，主要就是 动态用到Sleep（）函数 画各种图案参考easyx官方文档的函数（circle、、、） 用到了鼠标事件 最重要的是结合PS，确定每个图形的绝对坐标 祝大家编程开心 源码如下： #include <stdio.h> #include <stdlib.h> ...
华为OD机试_2025 B卷_运维日志排序（Python，100分）（附详细解题思路）
最新发布
测试工程师的成长之路
06-15 590
时间格式处理：分割字符串和类型转换单位转换：时间单位间的换算关系稳定排序：保持相等元素的原始顺序边界处理：毫秒补零规则。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Programming_Konjac

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值