综合实验报告——迷宫（maze）

于 2021-06-09 14:24:30 发布
阅读量478 收藏 3
点赞数 1
分类专栏： C++小项目 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52857903/article/details/117741193
版权

综合实验报告——迷宫（maze）

项目简介：

  • 代码量小，注释详细
  • 具有图形化页面，可以自定义色彩
  • 实现了搜索过程的可视化
  • 可以随机生成一定有通路的迷宫，并且可以进行相应的操作，比如移动等
  • 添加了一些额外的操作，比如重新生成迷宫，寻找最短距离的通路

    ……

代码讲解：

注意：这里导进了第三方库easyx图形库，所以必须得先导进去才有效果

  步骤：请下载最新版 EasyX 安装程序，直接运行，并跟随提示安装即可。

  在生成迷宫过程中采用了bfs（广度优先），生成通路时也是采用了bfs，利用bfs的特性就一定可以找到最短距离的通路。

   生成： 利用比较简单的bfs生成简易迷宫，迷宫里面分成了许多的单元格，每个单元格里面记录了五个数据，分别是当前单元格的状态，上下左右单元格的状态（是否能走向这四个方向），利用随机法，每一次只打通一面，且打通的面肯定是联通的，这也保证了一定有路。在生成迷宫中比较精华的是设置了带访问点，且随机去访问这些待访问点且只打通一面，从而产生了迷宫效果。

  **生成通路：**同样也是利用bfs进行搜索，上述已经说过了一定有解，所利用bfs就一定可以生成一条最短的通路。

效果展示：

图片展示

码源：

由于代码量不多就直接发出来了！

#include<easyx.h>
#include<vector>//可以访问的边
#include<stdlib.h>
#include<time.h>
#include<conio.h>
#include<graphics.h>
#include <stdio.h>

#define MAP_ROW 20	/*25*/
#define MAP_COL 25	/*45*/

#define OUT_ROW MAP_ROW - 1
#define OUT_COL MAP_COL - 1

struct Node
{
	int flag;			//表示关键结点是否访问过 0:未访问 1:已访问 2:待访问
									// 3:人物 4:目的地
	bool left, right, top, buttom;	//表示这个节点周围的四堵墙 0:不可通过的墙 1:可通过的空地
};
//搜索中所用来保存节点的
struct node{
	int x ; int y; int pre;
}query[MAP_ROW*MAP_COL*4];

int map_v[MAP_ROW][MAP_COL] = { 0 };//0-没访问过，1-已经访问过，2-最短路

int index_Row, index_Col;			//人所在行，列

void init(Node map[][MAP_COL]);

int bfs(int x, int y);

void drawMap(Node map[][MAP_COL]);

void play(Node map[][MAP_COL]);

void borderThrough(Node map[][MAP_COL], const COORD node);

int judg(Node map[][MAP_COL])//判断是否到达了终点
{
	if (map[OUT_ROW][OUT_COL].flag == 3)
		return 1;
	else
		return 0;
}
int main()
{
	srand((unsigned)time(NULL));
	initgraph(MAP_COL * 45, MAP_ROW * 30);      //设置了整张地图的规格
	Node map[MAP_ROW][MAP_COL] = { 0 };			//每个墙 都没打通的  每个结点 都是没有访问过
	int map_v[MAP_ROW][MAP_COL] = { 0 };

	init(map);							/*初始化地图*/
	drawMap(map);
	while (1)
	{
		play(map);
		drawMap(map);
		if (judg(map))
		{
			MessageBox(GetHWnd(), L"恭喜你赢了", L"Vectory", MB_OK);
			memset(map, 0, sizeof(Node) * MAP_ROW * MAP_COL);
			init(map);
			drawMap(map);
		}
	}
	getchar();
	closegraph();
	return 0;
}
int bfs(int x, int y,const Node map[][MAP_COL])//**存在bug
{
	int first = 1, second = 1;//模拟队列
	map_v[x][y] = 1;
	query[second].pre = -1;
	query[second].x = x;
	query[second].y = y;
	second++;
	while (second > first) {
		int xx = query[first].x, yy = query[first].y;//行，列
		map_v[xx][yy] = 1;
		if (map[xx][yy].top == 1) 
		{//上面可走
			if (xx >= 1 && xx <= MAP_ROW - 1 && yy >= 0 && yy <= MAP_COL-1&&map_v[xx-1][yy]==0) {
				query[second].pre = first;
				query[second].x = xx - 1;
				query[second++].y = yy;
			}
		}
		if (map[xx][yy].buttom == 1)
		{//下面可以走
			if (xx >=0 && xx <= MAP_ROW - 2 && yy >= 0 && yy <= MAP_COL - 1&&map_v[xx + 1][yy] == 0) {
				query[second].pre = first;
				query[second].x = xx+1;
				query[second++].y = yy;
				if (xx == MAP_ROW - 2 && yy == MAP_COL - 1) { return second-1; }//走到了终点,并且返回头指针
			}
		}
		if (map[xx][yy].left == 1)
		{//左面可以走
			if (xx >= 0 && xx <= MAP_ROW - 1 && yy >= 1 && yy <= MAP_COL - 1 && map_v[xx][yy-1] == 0) {
				query[second].pre = first;
				query[second].x = xx;
				query[second++].y = yy-1;
			}
		}
		if (map[xx][yy].right == 1)
		{//右面可以走
			if (xx >= 0 && xx <= MAP_ROW - 1 && yy >= 0 && yy <= MAP_COL - 2 && map_v[xx][yy+1] == 0) {
				query[second].pre = first;
				query[second].x = xx;
				query[second++].y = yy+1;
				if (xx == MAP_ROW - 1 && yy == MAP_COL - 2) { return second-1; }//走到了终点,并且返回头指针
			}
		}
		first++;
	}
	return 1;//一般情况下是不会出现这个结果的
}
void ans(int start) //传入first头指针
{
	int x = query[start].x, y = query[start].y;
	map_v[x][y] = 2;
	if (query[start].pre != -1) {
		ans(query[start].pre);
	}
	return;
}
void play(Node map[][MAP_COL])
{
	/*******玩家操作*******/
	char dir;
	/******找到小人******/
	for (int Row = 0; Row < MAP_ROW; Row++)
	{
		for (int Col = 0; Col < MAP_COL; Col++)
		{
			if (map[Row][Col].flag == 3)
			{
				index_Row = Row;
				index_Col = Col;
			}
		}
	}
	dir = _getch();//从键盘获取值
	switch (dir)
	{
	case 'q':					//寻找通路的方法
		setfillcolor(RGB(255,165,0));//实现按钮闪变
		solidrectangle(25 * 40, 100, 25 * 45, 150);
		settextstyle(18, 0, _T("楷体"));
		settextcolor(RGB(255,106,106));
		outtextxy(25 * 40 + 8, 115, _T("寻找通路"));
		ans(bfs(0, 0,map));
		drawMap(map);
		break;
	case 'r':					// 重新生成迷宫
		setfillcolor(RGB(255, 165, 0));
		solidrectangle(25 * 40, 200, 25 * 45, 250);
		settextstyle(18, 0, _T("楷体"));
		settextcolor(RGB(255, 106, 106));
		outtextxy(25 * 40 + 8, 225, _T("重新生成"));
		Sleep(100);
		memset(map, 0, sizeof(Node) * MAP_ROW * MAP_COL);
		init(map);			/*初始化地图*/
		drawMap(map);
		break;
	
	case 'w':
	case 72:
		//判断人物所在点上 top 是否可以通行
		if (map[index_Row][index_Col].top == 1 && index_Row >= 1)
		{
			map[index_Row][index_Col].flag = 1;
			map[index_Row - 1][index_Col].flag = 3;
		}
		break;
	case 's':
	case 80:
		//判断人物所在点 buttom 是否可以通行
		if (map[index_Row][index_Col].buttom == 1 && index_Row < MAP_ROW - 1)
		{
			map[index_Row][index_Col].flag = 1;
			map[index_Row + 1][index_Col].flag = 3;
		}
		break;
	case 'a':
	case 75:
		//判断人物所在点 left 是否可以通行
		if (map[index_Row][index_Col].left == 1 && index_Col >= 1)
		{
			map[index_Row][index_Col].flag = 1;
			map[index_Row][index_Col - 1].flag = 3;
		}
		break;
	case 'd':
	case 77:
		//判断人物所在点 right 是否可以通行
		if (map[index_Row][index_Col].right == 1)
		{
			map[index_Row][index_Col].flag = 1;
			map[index_Row][index_Col + 1].flag = 3;
		}
		break;
	}
}

void init(Node map[][MAP_COL])
{
	setfillcolor(WHITE);		//填充颜色 白色
	setlinecolor(BLACK);		//线条颜色  红色
	setlinestyle(PS_SOLID, 2);	//线条风格
	//对查询表进行重置
	for (int i = 0; i < MAP_ROW * MAP_COL * 4; i++) {
		query[i].pre = 0;
		query[i].x = 0;
		query[i].y = 0;
	}
	//先选中一个结点  最左上角  arr[0][0]
	map[0][0].flag = 1;			//这个节点已经访问过

	for (int i = 0; i < MAP_ROW; i++) {
		for (int j = 0; j < MAP_COL; j++) {
			map_v[i][j] = { 0 };//对查询访问数组进行初始化
		}
	}

	COORD waitForVisit[MAP_COL * MAP_ROW];	//存放待访问的结点
	int len = 0;					//map里面的坐标的个数

	waitForVisit[len++] = { 1, 0 };		//下方的结点 可以访问
	map[1][0].flag = 2;					//待访问
	waitForVisit[len++] = { 0, 1 };		//右边的结点 可以访问
	map[0][1].flag = 2;					//待访问
	int m;

	while (len > 0)
	{
		//随机选取其中的一个结点  进行访问
		m = rand() % len;	//从可以访问的结点中随机取一个
		/*打通这个节点  把这个节点相邻的结点放到map里面*/
		borderThrough(map, waitForVisit[m]);	//borderThrough作用:打通waitForVisit[m]节点的任意一面（上下左右任意一面）
		map[waitForVisit[m].X][waitForVisit[m].Y].flag = 1;		/*已经访问过这个节点*/

		/*周围的四个节点(如果有) 全部放到map里面*/
		if (waitForVisit[m].X - 1 >= 0 && map[waitForVisit[m].X - 1][waitForVisit[m].Y].flag == 0)
		{
			//如果上方的结点没有访问过   设置为待访问 并且把这个位置放到map里面
			map[waitForVisit[m].X - 1][waitForVisit[m].Y].flag = 2;
			waitForVisit[len++] = { waitForVisit[m].X - 1, waitForVisit[m].Y };
		}
		if (waitForVisit[m].X + 1 < MAP_ROW && map[waitForVisit[m].X + 1][waitForVisit[m].Y].flag == 0)
		{
			//下
			map[waitForVisit[m].X + 1][waitForVisit[m].Y].flag = 2;
			waitForVisit[len++] = { waitForVisit[m].X + 1, waitForVisit[m].Y };
		}
		if (waitForVisit[m].Y - 1 >= 0 && map[waitForVisit[m].X][waitForVisit[m].Y - 1].flag == 0)
		{
			//左
			map[waitForVisit[m].X][waitForVisit[m].Y - 1].flag = 2;
			waitForVisit[len++] = { waitForVisit[m].X, waitForVisit[m].Y - 1 };
		}
		if (waitForVisit[m].Y + 1 < MAP_COL && map[waitForVisit[m].X][waitForVisit[m].Y + 1].flag == 0)
		{
			//右
			map[waitForVisit[m].X][waitForVisit[m].Y + 1].flag = 2;
			waitForVisit[len++] = { waitForVisit[m].X, waitForVisit[m].Y + 1 };
		}
		//map[m]已经访问过  从map里面删掉就可以
		if (m == len - 1)//没有可以添加的待访问点
			len--;
		else
		{ //对已经访问过的节点进行更新
			waitForVisit[m] = waitForVisit[len - 1];
			len--;
		}
		drawMap(map);
	}

	map[0][0].flag = 3;							//初始化人物
	map[MAP_ROW - 1][MAP_COL - 1].flag = 4;		//初始目的地
	
}

void drawMap(Node map[][MAP_COL])
{
	BeginBatchDraw();
	cleardevice();									//清屏操作
	for (int i = 0; i < MAP_ROW; ++i)
	{
		for (int j = 0; j < MAP_COL; ++j)
		{
			if (map[i][j].flag == 0)				//没有访问过这个节点
			{
				setfillcolor(WHITE);
				if (map_v[i][j] == 2) {
					setfillcolor(RGB(255, 48, 48));
				}
			}
			else if (map[i][j].flag == 1)			//访问过
			{
				setfillcolor(RGB(255, 193, 193));
				if (map_v[i][j] == 2) {
					setfillcolor(RGB(255, 48, 48));
				}
			}
			else if (map[i][j].flag == 2)			//待访问
			{
				setfillcolor(BLUE);
				if (map_v[i][j] == 2) {
					setfillcolor(RGB(255, 48, 48));
				}
			}
			else if (map[i][j].flag == 3)			//人物                          
			{
				setfillcolor(RED);
			}
			else if (map[i][j].flag == 4)			//目的地
			{
				setfillcolor(GREEN);
			}
			solidrectangle(j * 40, i * 30, j * 40 + 39, i * 30 +29);	//绘制
			if (map[i][j].top == 0)				//没有打通
			{
				line(j * 40, i * 30, j * 40 + 39, i * 30);
			}
			if (map[i][j].buttom == 0)
			{
				line(j * 40, i * 30 + 29, j * 40 + 39, i * 30 + 29);
			}
			if (map[i][j].left == 0)
			{
				line(j * 40, i * 30, j * 40, i * 30 + 29);
			}
			if (map[i][j].right == 0)
			{
				line(j * 40+39, i * 30, j * 40 + 39, i * 30 + 29);
			}
		}
	}
	setfillcolor(RGB(240,255,255));
	solidrectangle(25 * 40, 0, 25 * 45, 20 * 30-1);
	setbkmode(TRANSPARENT);//设置当前设备图案填充和文字输出时的背景模式
	rectangle(25 * 40, 100, 25 * 45, 150);
	rectangle(25 * 40, 200, 25 * 45, 250);
	RECT r = {25 * 40, 300, 25 * 45, 500};
	setfillcolor(RGB(238,238,209));
	solidrectangle(25 * 40, 100, 25 * 45, 150);
	solidrectangle(25 * 40, 200, 25 * 45, 250);
	settextstyle(18, 0, _T("楷体"));
	settextcolor(RGB(0,0,0));
	outtextxy(25 * 40 + 8, 115, _T("寻找通路(q)"));
	outtextxy(25 * 40 + 8, 225, _T("重新生成(r)"));
	drawtext(_T("* * * * *\n(要在英文输入状态下）\n按压方向箭头进行移动\n\n按压r,q可以进行相应操作"), &r, DT_WORDBREAK);

	EndBatchDraw();//结束绘画，并呈现出来
}

void borderThrough(Node map[][MAP_COL], const COORD node)
{
	int flag = 0;
	int dir;
	do
	{
		//判断周围的结点 有哪些是可以打通的   可以打通就打通
		dir = rand() % 4;
		switch (dir)
		{
		case 0:
			if ((node.X + 1 < MAP_ROW) && map[node.X + 1][node.Y].flag == 1)//下
			{
				map[node.X + 1][node.Y].top = 1;		//打通两堵墙
				map[node.X][node.Y].buttom = 1;
				flag = 1;
				break;
			}
		case 1:
			if ((node.Y - 1 >= 0) && map[node.X][node.Y - 1].flag == 1)//左
			{
				map[node.X][node.Y - 1].right = 1;		//打通两堵墙
				map[node.X][node.Y].left = 1;
				flag = 1;
				break;
			}
		case 2:
			if (node.Y + 1 < MAP_COL && map[node.X][node.Y + 1].flag == 1)//右
			{
				map[node.X][node.Y + 1].left = 1;		//打通两堵墙
				map[node.X][node.Y].right = 1;
				flag = 1;
				break;
			}
		case 3:
			if ((node.X - 1 >= 0) && map[node.X - 1][node.Y].flag == 1)//上
			{
				map[node.X - 1][node.Y].buttom = 1;
				map[node.X][node.Y].top = 1;
				flag = 1;
				break;
			}
		}
	} while (!flag);
}

欢迎大家访问我的个人博客

本文章到此结束！感谢阅读！

watermelonhit
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[设计模式] - 创建型模式
夏菠
08-21 1015
本文按照GOF书中的例子做实验。 创建型模式包含了5种设计模式，书中已创建迷宫的例子讲解了这5个例子，将这5种设计模式都运用到了创建迷宫当中。 这5种创建型模式包含： 　　1. Factory Method（工厂方法） 　　2. Abstract Factory（抽象工厂） 　　3. Builder（建造者） 　　4. Prototype（原型） 　　5. Singleton（单例）
迷宫问题实验报告
04-28
迷宫问题。
迷宫求解实验报告（含代码）
01-14
数据结构关于迷宫求解的课设报告，包含实验代码
数据结构迷宫实验报告
06-03
绝对好用好用好用好用好用好用好用 好用好用好用
迷宫问题实验报告用栈解决迷宫问题
12-06
二． 概要设计 为了实现上述操作，以栈为存储结构。 本程序包含三个模块： （1） 主程序模块:实现人机交互。 （2） 迷宫生产模块：随机产生一个12×12的迷宫。 （3） 路径查找模块：实现通路的查找。 （4） 求解迷宫中一条通路的伪代码：
迷宫求解及实验报告（C语言实现）
06-04
对栈操作实现迷宫求解，从某一位置进入再到某一位置走出，实际上是定位一个特定的坐标，只要移动物刚好到达这个坐标就能顺利走出。
字母A~Z走迷宫maze
10-06
字母A~Z走迷宫maze，如图成功： A B C . . . . . . . . . D . . . . . . . . . E . . . . . . . . . F . . . . . . . . . G H . . . . . . . . . I . . . . . . . . . J . . . X W V . . . K L M Z Y T U ....
maze_Grid.zip_Maze grid_迷宫
09-21
用计算机生成迷宫是一个很有趣的任务。我们可以用 ? 道路网格(Road Grid)? ? 来表示迷宫的道路,那么 3 x 3 的 ? 道路网格? ( ? 图 -1 左?... ——? 图 -1 右? 的方式(迷宫的墙是灰 色的,道路是白色的)
人工智能大作业基于强化学习求解迷宫问题python实现源码+项目说明+实验报告+可执行文件.zip
最新发布
08-09
人工智能大作业-基于强化学习求解迷宫问题python实现源码+项目说明+实验报告+可执行文件 【项目介绍】 该资源内项目代码都是经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 本项目适合计算机相关专业...
maze_迷宫_强化学习_maze.py_mazepython_
10-04
基于python实现的强化学习，用tensorflow实现迷宫程序
mazelib:一个用于创建和解决迷宫的Python库
05-01
迷宫 用于创建和解决迷宫的Python API。 关于如何使用此库的快速介绍。 有关如何生成和解决一些独特的量身定制的迷宫的示例。 此外，还提供了如何绘制结果的示例。 迷宫算法 该库的核心是可用于创建和解决迷宫的大量算法。 您对这些知识了解得越多，您对这个库所做的就越多。
简单迷宫（Maze）java编写
12-18
迷宫生成的 exe 可执行文件，源码纯 java 编写，有 gre 环境便可执行，学习源码可查看链接 https://blog.csdn.net/weixin_48033173/article/details/111353826
迷宫(maze)
orz
01-21 1756
题目描述 最近，小Y在玩一款迷宫游戏，游戏是在一个n*m的网络上进行的，每个格子可能是空地或者障碍物。游戏一开始，玩家控制的角色位于图中的某块空地上。在游戏过程中，玩家可以用上下左右键控制角色向相邻且没有障碍物的格子移动（当然，角色不能移动到地图之外，也不能对角线移动）。游戏的目标是收集地图上出现的星星（每个星星只能收集一次），收集的数量越多分数越高。小Y刚开了一局游戏，假设游戏时间没有限制，他想知道自己最多能收集到多少个星星。 输入格式 第一行包含两个正整数n和m，表示游戏的地图包含n行m列。 接下
迷宫 (maze)
PC_LOGO的博客
08-13 693
迷宫 (maze) 题目背景 相似题目：洛谷P1605 (题面相似) 题目描述 给定一个 N×MN \times MN×M 方格的迷宫，迷宫里有 TTT 处障碍，障碍处不可通过。给定起点坐标和终点坐标，问每个方格最多经过111次。在迷宫中移动有上下左右四种方式。保证起点上没有障碍。问从起点到终点的最短路径长度以及输出一条长度最短的路径经过的点的坐标。 如果不存在起点到终点的路径则就输出−1-1−1。 输入格式 第一行 NNN , MMM 和 TTT , NNN 为行，MMM 为列，TTT 为障碍总数。
A - Maze迷宫问题
chihiro的博客
03-01 244
题目： 东东有一张地图，想通过地图找到妹纸。地图显示，0表示可以走，1表示不可以走，左上角是入口，右下角是妹纸，这两个位置保证为0。既然已经知道了地图，那么东东找到妹纸就不难了，请你编一个程序，写出东东找到妹纸的最短路线。 Input： 　 输入是一个5 × 5的二维数组，仅由0、1两数字组成，表示法阵地图。 Output　　 输出若干行，表示从左上角到右下角的最短路径依次经过的坐标，格式如样...
迷宫（Maze）项目实现
qq_41571459的博客
02-26 1675
项目介绍：  一个网格迷宫由n行m列的单元格组成，每个大院个要么是空地（用0表示），要么是障碍物（用1表示）。你的任务是找一条从起点到终点的移动序列，其中只能上下左右移动到相邻单元格。任何时候都不能在有障碍物的单元格中，也不能走到迷宫之外。起点为左上角和终点右下角。 项目功能： 寻找一条从左上角迷宫入口到右下角迷宫出口的一条有效路径。 0代表可走，1代表不能行走,8代表行走的路径。 找到请输出最终的迷宫和路径信息，找不到请输出不存在有效路径。 项目所用知识点：  采用Java面向对象思想，二维数组以及非
【JZOJ A组】迷宫花园(maze)
Brute♂force
10-22 340
Description 给定一个一定存在从起点到终点的路径的四联通迷宫。已知Tar左右方向移动的时间为1，上下移动的时间为未知实数v。求当Tar从起点到终点的最短移动时间为已知实数L时，未知实数v是多少。 Input 输入数据包含多个测试点。第一行为一个整数T，表示测试点的数目。 对于每一个测试点，第一行包含实数L和两个整数R,C。R为迷宫的上下长度，C为迷宫的左右长度。 之后的R行，每行包含C个...
BFS经典例题：Maze迷宫
_Previous的博客
05-22 1181
You are provided a maze(迷宫), and you need to program to find the least steps to walk from the start to the end.And you can only walk in four directions:up, down,left, right.There will only be 5 kinds o
Maze CodeForces - 377A
yinghui_yht的博客
02-03 505
Pavel loves grid mazes. A grid maze is an n × m rectangle maze where each cell is either empty, or is a wall. You can go from one cell to another only if both cells are empty and have a common side.
设计一个实验利用高架十字迷宫
06-01
高架十字迷宫是一种用于研究动物行为和学习的实验设备，可以用来测试动物的空间记忆和学习能力。以下是一个可能的实验设计： 1. 实验对象：小鼠 2. 实验步骤： 1) 训练阶段：小鼠被放置在高架十字迷宫的起点，迷宫的四个臂分别通向不同的目标位置，每个位置有一个奖励，如食物或水。小鼠需要在规定时间内找到奖励，并在迷宫中学会记忆正确的路径。如果小鼠能够在规定时间内找到奖励，它将被奖励。如果它没有找到奖励，它将无法获得奖励。 2) 测试阶段：在测试阶段，小鼠被放置在起点，但是在迷宫中的目标位置已经被移动或更改。小鼠需要在规定时间内找到新的奖励位置。实验者可以记录小鼠找到目标位置的时间和路径。 3. 实验变量： 1) 训练时间：可以根据需要调整训练时间的长短。 2) 奖励类型：可以使用不同种类的奖励，例如食物或水。 3) 目标位置：可以在测试阶段更改目标位置，以测试小鼠的空间记忆能力。 4. 实验结果： 1) 记录小鼠在训练和测试阶段的表现，包括时间和路径。 2) 通过比较不同实验条件下的表现来确定哪些变量对小鼠的学习和记忆能力产生影响。 这个实验设计可以用于研究小鼠的空间记忆和学习能力，可以帮助我们了解动物的行为和认知过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值