【数据结构】迷宫问题DFS非递归(c语言实现)

这篇具有很好参考价值的文章主要介绍了【数据结构】迷宫问题DFS非递归(c语言实现)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

本来之前写过一个推箱子,就想着写个迷宫游戏,因为想着推箱子游戏里面也有墙,也有玩家的移动,比推箱子简单的是还不用判断前面是否有箱子的情况,但是自己写的迷宫游戏如果自己随机生成的迷宫地图的话,不一定会有通路,他要学一个什么随机迷宫的生成,刚看完懒猫老师的那个迷宫问题使用的是非递归DFS寻找迷宫是否有通路,用的是非递归DFS实现,然后随机迷宫生成用的是DFS递归写的,我真的要成两半了,今天分享给大家的是DFS算法找迷宫是否有出路,这个好像有的会作为数据结构的大作业还是啥的,用c语言实现,参考b站懒猫老师的课迷宫问题

1.问题展示

【数据结构】迷宫问题DFS非递归(c语言实现),数据结构,深度优先,数据结构,c语言,算法

2.栈的所有有用的函数

因为要用栈实现,所以我们必须将有关栈的函数全部写出来,我们已经之前写过栈的初始化,等等,栈的实现,我们将他拷贝过来,或者你们直接去看我那一篇。

//栈的实现
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef struct Stack//定义一个栈的结构体变量	
{
	int * a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
void StackInit(Stack* ps)
{
	assert(ps);//断言,防止为空指针
	ps->a = NULL;//所指向的地址为空
	ps->capacity = ps->top = 0;//容量和栈中元素个数均为0
}
void StackPush(Stack* ps, int data)
{
	assert(ps);
	if (ps->capacity == ps->top)//如果栈中的元素个数等于栈的容量时考虑扩容,
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果刚开始时都等于0,就先给4个空间大小,后面如果满的话,容量扩大1倍
		 int* newnode = (int*)realloc(ps->a,sizeof(int)* newcapcity);//申请空间,将申请好的空间首地址传给newnode指针
		 assert(newnode);//断言,防止malloc失败
		 ps->a = newnode;//将newnode保存的申请空间的首地址传给ps->a,让ps->a指向创建好的空间
		ps->capacity = newcapcity;//容量大小更新为新容量大小



	}
	ps->a[ps->top] = data;//像存数组一样存数据
	ps->top++;//指向下一个
}
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top ==0;//ps->top为栈中元素个数.==0栈中无元素,无元素要返回1, 无元素ps->t0p==0,这个表达式结果是1,返回1;





}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//防止栈内无元素,继续出栈
	ps->top--;
}
// 获取栈顶元素
int StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];//ps->top为栈中元素个数,由于数组下标是从0开始,所以栈顶元素下标为ps->top-1;

}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;

}
// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);//free掉动态申请的内存
	ps->a = NULL;//防止野指针
	ps->capacity = ps->top = 0;//容量和栈中元素个数置为0



}


但是不能直接用,所以我们必须加以修改,我们会将从入口到出口正确的路径坐标,以及每个坐标对应走向下一个坐标的方向保存在栈里面,由我之前实现的栈中一个元素变为三个元素,栈的实现做出以下改变,int * a,a指针不在指向一个int ,将inta改为proa;pro为结构体类型存放三个元素

typedef struct pro
{
	int x;
	int y;
	int di;




}pro;
typedef struct Stack
{
	pro* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;

由于一次压进三个数据,我们要修改入栈函数

void StackPush(Stack* ps, int data1, int data2, int data3)//入栈
{
	assert(ps);
	
	if (ps->capacity == ps->top)
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		pro* tmp = (pro*)realloc(ps->a, sizeof(pro) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapcity;



		}






	}
	ps->a[ps->top].x = data1;
	ps->a[ps->top].y = data2;
	ps->a[ps->top].di = data3;
	ps->top++;







}

由于每层由之前一个元素变为三个元素,所以要修改获取栈顶元素函数,返回栈顶地址,然后通过地址来访问三个元素中的每一个

// 获取栈顶元素
pro* StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a+ps->top-1;

}

3.修改后的栈的实现

typedef struct pro
{
	int x;
	int y;
	int di;




}pro;
typedef struct Stack
{
	pro* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
void StackInit(Stack* ps)//初始化栈
{
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(Stack* ps, int data1, int data2, int data3)//入栈
{
	assert(ps);
	//assert(ps->a);
	if (ps->capacity == ps->top)
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		pro* tmp = (pro*)realloc(ps->a, sizeof(pro) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapcity;



		}






	}
	ps->a[ps->top].x = data1;
	ps->a[ps->top].y = data2;
	ps->a[ps->top].di = data3;
	ps->top++;







}
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;



}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;

}
// 获取栈顶元素
pro* StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a+ps->top-1;

}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;





}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;

}

4. 定义二维数组作为迷宫的地图

我们这里将1看做墙,0看做空地可以走的地方,然后迷宫入口坐标为(1,1),我们定义二维数组为M*N的

#define N 10
#define M 10

迷宫出口坐标为(M-2,N-2);
定义全局变量,方便使用

int map[M][N] = {
	{1,1,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,0,0,0,0,0,0,0,1},
	{1,1,1,1,1,1,1,1,1,1},
};

【数据结构】迷宫问题DFS非递归(c语言实现),数据结构,深度优先,数据结构,c语言,算法
黑框标注的分别为入口和出口.
在定义一个结构体,表示要走的方向

typedef struct direct 
{
	int conx;
	int cony;

}direct;

在主函数里面定义一个direct类型的数组,数组大小为四,存放上下左右走,坐标的变化,并且将他们赋值

   direct des[4];
	des[0].conx = 1;//向右走
	des[0].cony = 0;
	des[1].conx = -1;//向左走
	des[1].cony = 0;
	des[2].conx = 0;//向下走
	des[2].cony = 1;
	des[3].conx = 0;//向上走
	des[3].cony = -1;

【数据结构】迷宫问题DFS非递归(c语言实现),数据结构,深度优先,数据结构,c语言,算法
向哪走就给对应坐标+上什么的,比如说我向右走,x+des[0].conx ,y+des[0].cony;

5.定义一个栈,将其初始化,当用完时候将其销毁

int main()
{
	
	direct des[4];
	des[0].conx = 1;//向右走
	des[0].cony = 0;
	des[1].conx = -1;//向左走
	des[1].cony = 0;
	des[2].conx = 0;//向下走
	des[2].cony = 1;
	des[3].conx = 0;//向上走
	des[3].cony = -1;
	Stack st;
	
	StackInit(&st);
	
  
		StackDestroy(&st);
		StackDestroy(&scpy);
	return 0;

}

6. DFS算法寻找迷宫是否有通路

【数据结构】迷宫问题DFS非递归(c语言实现),数据结构,深度优先,数据结构,c语言,算法

bool  findpath(int map[][N], direct des[], Stack* ps)
{
	int line, col;//表示当前位置能走的下一个位置的坐标
	int x, y, di;//表示当前位置的坐标,以及当前位置准备向下一个方向走的方向
	int mapcon[M][N] = { 0 };//为了不修改原有的地图,重新创建一个二维数组
	for (int i = 0; i < M; i++)//遍历地图,将原地图的二维数组的值拷贝到mapcon中
	{
		for (int j = 0; j < N; j++)
		{  
			mapcon[i][j] = map[i][j];
			
		


		}
		
	}
	

	mapcon[1][1] = -1;//走过的地方用-1标记
	pro tmp;//保存当前位置的坐标,以及方向
	tmp.x = 1;
	tmp.y = 1;
	tmp.di = -1;//刚开始在(1,1),将tmp.x,tmp.y赋值为1,刚开始还没有方向tmp.di = -1;
	StackPush(ps, tmp.x, tmp.y, tmp.di);//将当前位置信息压入st栈中

	while (!StackEmpty(ps))//栈中不为空,开始循环
	{
		tmp.x = StackTop(ps)->x;
		tmp.y = StackTop(ps)->y;
		tmp.di = StackTop(ps)->di;//获取栈顶元素到tmp中去,以便于回退
		StackPop(ps);//出栈操作
		x = tmp.x;//当前坐标改为回退之后的坐标
		y = tmp.y;//当前坐标改为回退之后的坐标
		di = tmp.di + 1;//开始di=0,方向向右
		while (di < 4)//遍历当前位置的四个方向
		{
			line = x + des[di].conx;//记录下一个位置的坐标
			col = y + des[di].cony;//记录下一个位置的坐标
			if (mapcon[line][col] == 0)//如果下一个坐标时0,为空地的话,就可以前进
			{
				tmp.x = x;//保存当前位置坐标,以便于回退
				tmp.y = y;//保存当前位置坐标,以便于回退
				tmp.di = di;//保存当前位置坐标,以便于回退
				StackPush(ps, tmp.x, tmp.y, tmp.di);//当前位置目前确定是通往出口路上的一个坐标,先入栈
				x = line;//当前位置更新为下一个位置的坐标
				y = col;//当前位置更新为下一个位置的坐标
				mapcon[line][col] = -1;//留下足迹,标记为-1;
				if (x == M - 2 && y == N - 2)//是否到出口
				
					

					return true;//有通路,跳出
				
				
				else di = 0;//没到的话,将方向更新为向右
			}
			else di++;//如果当前位置的方向不是空地的话,就换另一个方向判断


		}



	}

	return false;//循环结束,无通路

}

7. 逆序打印坐标

如果有通路的话, findpath()函数返回1,由于栈是先入后出,所以栈顶元素是出口的坐标,怎么逆序打印从入口到出口的坐标呢?我们可以在创建一个栈,使用栈判空函数循环将st中的元素入栈到另一个栈中,就做到了在原先栈底元素,跑到了新栈的栈顶,实现了逆序打印
【数据结构】迷宫问题DFS非递归(c语言实现),数据结构,深度优先,数据结构,c语言,算法

	Stack st;
	Stack scpy;//定义一个栈用于倒翻数据
	StackInit(&st);
	StackInit(&scpy);//新栈初始话
    bool ret = findpath(map, des, &st);//返回1,地图有通路
		if (ret == 1)
		{
			printf("该地图有通路\n");
			while (!StackEmpty(&st))//原栈不为空的话
			{
				int num1=StackTop(&st)->x;
				int num2 = StackTop(&st)->y;
				int num3= StackTop(&st)->di;//获取旧栈栈顶元素
				/*printf("%d-%d ",num1,num2);*/
				StackPop(&st);//栈顶元素出st栈
				StackPush(&scpy, num1, num2, num3);//栈顶元素入新栈scpy


			}
			
			
			while (!StackEmpty(&scpy))//新栈scpy不为空,
			{
				int num1 = StackTop(&scpy)->x;
				int num2 = StackTop(&scpy)->y;
				int num3 = StackTop(&scpy)->di;//获取栈顶元素
				printf("(%d,%d)\n", num1, num2);//打印栈顶元素
				StackPop(&scpy);//新栈栈顶元素出栈
			

			}
			
		}
		else
		{

			printf("该地图无通路\n");
		}
		StackDestroy(&st);//销毁旧栈
		StackDestroy(&scpy);//销毁新栈

只打印坐标,不要求方向,我就在栈中没画方向.

8.整体代码

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>


#include <stdbool.h>
#define N 10
#define M 10
int map[M][N] = {
	{1,1,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,0,0,0,0,0,0,0,1},
	{1,1,1,1,1,1,1,1,1,1},
};
typedef struct pro
{
	int x;
	int y;
	int di;




}pro;
typedef struct direct 
{
	int conx;
	int cony;

}direct;






typedef struct Stack
{
	pro* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
void StackInit(Stack* ps)//初始化栈
{
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(Stack* ps, int data1, int data2, int data3)//入栈
{
	assert(ps);
	//assert(ps->a);
	if (ps->capacity == ps->top)
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		pro* tmp = (pro*)realloc(ps->a, sizeof(pro) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapcity;



		}






	}
	ps->a[ps->top].x = data1;
	ps->a[ps->top].y = data2;
	ps->a[ps->top].di = data3;
	ps->top++;







}
// 检测栈是否为空,如果为空返回非零结果,如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;



}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;

}
// 获取栈顶元素
pro* StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a+ps->top-1;

}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;





}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;

}
enum  Mine
{
	SPACE,  //空地
	WALL,//墙
	DEST,  //目的地
	PLAYER//玩家





};
bool  findpath(int map[][N], direct des[], Stack* ps)
{
	int line, col;
	int x, y, di;
	int mapcon[M][N] = { 0 };
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{  
			mapcon[i][j] = map[i][j];
			
		


		}
		
	}
	mapcon[M - 2][N - 2] = 0;

	mapcon[1][1] = -1;
	pro tmp;
	tmp.x = 1;
	tmp.y = 1;
	tmp.di = -1;
	StackPush(ps, tmp.x, tmp.y, tmp.di);

	while (!StackEmpty(ps))
	{
		tmp.x = StackTop(ps)->x;
		tmp.y = StackTop(ps)->y;
		tmp.di = StackTop(ps)->di;
		StackPop(ps);
		x = tmp.x;
		y = tmp.y;
		di = tmp.di + 1;
		while (di < 4)
		{
			line = x + des[di].conx;
			col = y + des[di].cony;
			if (mapcon[line][col] == 0)
			{
				tmp.x = x;
				tmp.y = y;
				tmp.di = di;
				StackPush(ps, tmp.x, tmp.y, tmp.di);
				x = line;
				y = col;
				mapcon[line][col] = -1;
				if (x == M - 2 && y == N - 2)
				
					

					return true;
				
				
				else di = 0;
			}
			else di++;


		}



	}

	return false;

}





int main()
{
	srand((unsigned int)time(NULL));
	direct des[4];
	des[0].conx = 1;//向右走
	des[0].cony = 0;
	des[1].conx = -1;//向左走
	des[1].cony = 0;
	des[2].conx = 0;//向下走
	des[2].cony = 1;
	des[3].conx = 0;//向上走
	des[3].cony = -1;
	Stack st;
	Stack scpy;
	StackInit(&st);
	StackInit(&scpy);
    bool ret = findpath(map, des, &st);
		if (ret == 1)
		{
			printf("该地图有通路\n");
			while (!StackEmpty(&st))
			{
				int num1=StackTop(&st)->x;
				int num2 = StackTop(&st)->y;
				int num3= StackTop(&st)->di;
				/*printf("%d-%d ",num1,num2);*/
				StackPop(&st);
				StackPush(&scpy, num1, num2, num3);


			}
			
			
			while (!StackEmpty(&scpy))
			{
				int num1 = StackTop(&scpy)->x;
				int num2 = StackTop(&scpy)->y;
				int num3 = StackTop(&scpy)->di;
				printf("(%d,%d)\n", num1, num2);
				StackPop(&scpy);
			

			}
			
		}
		else
		{

			printf("该地图无通路\n");
		}
		StackDestroy(&st);
		StackDestroy(&scpy);
	return 0;

}

9.编译运行

【数据结构】迷宫问题DFS非递归(c语言实现),数据结构,深度优先,数据结构,c语言,算法文章来源地址https://www.toymoban.com/news/detail-714233.html

到了这里,关于【数据结构】迷宫问题DFS非递归(c语言实现)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Python数据结构与算法】--- 递归算法的应用 ---[乌龟走迷宫] |人工智能|探索扫地机器人工作原理

    🌈个人主页: Aileen_0v0 🔥系列专栏:PYTHON数据结构与算法学习系列专栏 💫\\\"没有罗马,那就自己创造罗马~\\\"  目录 导言  解决过程  1.建立数据结构 2.探索迷宫: 算法思路 递归调用的“基本结束条件” 3.乌龟走迷宫的实现代码: 运行过程: 拓展: 📝全文总结:  乌龟探索迷宫这个问

    2024年02月05日
    浏览(38)
  • 二叉树BFS/DFS及重要递归接口--拿下二叉树--拿下数据结构--拿到好offer

     堆是一种特殊的二叉树(完全二叉树),由于有堆排序等实际的需求,堆是由类似顺序表的结构实现的,这是为了方便堆能够通过下标找到parent和child,进行比较大小以及交换等操作。 这里我们建立二叉树的每个结点,包含左右孩子指针left和right,还有存储的数据data。 然后

    2023年04月08日
    浏览(39)
  • 迷宫求解(包含随机迷宫、求解动画演示)——C语言 数据结构

    该程序是一项 “迷宫求解” 类问题,主要功能包含:         ①25 X 25迷宫的随机生成         ②迷宫求解的动画演示(DFS) 完整代码附最后 : ) 功能演示: 界面展示:  迷宫展示: 结果展示:   首先是随机迷宫部分: 大概思路就是先初始化一个矩阵,外圈为“通

    2024年02月07日
    浏览(53)
  • 数据结构-迷宫问题

    题目链接:迷宫问题 、 注意不能斜着走! (1)0为可以走,1不能走且只有唯一一条通路 (2)我们可以通过判断上下左右来确定路是否能通过,再设置如果走过的路就用 2 来标记,这样就不会走回头路了,如果有多条能通过,只选择一条路来走 (3)当我们遇到死胡同时,应

    2024年02月04日
    浏览(28)
  • 【C数据结构】迷宫问题

    前言: 本章记录作者学习中,遇到的两个比较有趣的问题,一个简单和一个较复杂的迷宫问题。     让我们先来看简单的:迷宫问题 它的具体要求: 输入描述: 输入两个整数,分别表示二维数组的行数,列数。再输入相应的数组,其中的 1表示墙壁 , 0表示可以走的路 。

    2024年02月02日
    浏览(33)
  • 【数据结构初阶】十、快速排序(比较排序)讲解和实现(三种递归快排版本 + 非递归快排版本 -- C语言实现)

    ========================================================================= 相关代码gitee自取 : C语言学习日记: 加油努力 (gitee.com)  ========================================================================= 接上期 : 【数据结构初阶】九、排序的讲解和实现(直接插入 希尔 直接选择 堆 冒泡 -- C语言)

    2024年02月08日
    浏览(35)
  • 数据结构——迷宫问题(顺序栈、C++)

     讲解: 一、采用二维数组和srand函数随机生成只有0和1的迷宫。 二、求解迷宫大概思路:先将入口处的坐标即方向d入栈,然后当栈不为空时,取出栈顶(即当前节点)的数据。遍历当前节点的四个方向,找到可行的下一个节点,并将其入栈;如没有可行的下一个节点,则将

    2024年02月13日
    浏览(23)
  • 《数据结构与算法分析》课程设计——迷宫问题

    中国矿业大学信控学院   补一下我之前在博客园发布的内容  懒得调了, 想复制完整代码直接复制最下面的 ,想复制分布代码去看我博客园链接吧 《数据结构与算法分析》课程设计——迷宫问题 - 刷子zz - 博客园 一、  问题描述 问题中迷宫可用方阵[m,n]表示,0表示能通过

    2024年02月10日
    浏览(37)
  • C数据结构与算法——队列 应用(C语言纯享版 迷宫)

    实验任务 (1) 掌握顺序循环队列及其C语言的表示; (2) 掌握入队、出队等基本算法的实现; (3) 掌握顺序循环队列的基本应用(求解迷宫通路)。 实验内容 使用C语言实现顺序循环队列的类型定义与算法函数; 编写main()函数并根据需要修改、补充相关的类型定义与函数,以实

    2024年02月15日
    浏览(36)
  • 『初阶数据结构 • C语言』⑰ - 快速排序(hoare法、挖坑法、前后指针法与非递归实现)

    目录 1. hoare法 方法与步骤 代码实现 2. 挖坑法 方法与步骤 代码实现 3. 前后指针法 方法与步骤 代码实现  4. 快速排序的缺点与优化 1.快速排序的缺点 2.快速排序的优化 ① 三数取中法选 key 代码实现 ② 小区间优化 代码实现 5. 快速排序的非递归实现 附录﹡完整源码 快速排序

    2024年02月13日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包