2. 程式人生 > >C語言-老鼠走迷宮(廣度尋路演算法)

C語言-老鼠走迷宮(廣度尋路演算法)

阿新 • • 發佈：2018-11-19

老鼠走迷宮-c語言（基於廣度優先的尋路演算法）

深讀優先尋路演算法原文：https://blog.csdn.net/qq_42476927/article/details/81868068 

本文是基於之前的深度優先尋路演算法改進而來，參考了許多廣度遍歷的程式碼結合自己程式碼改進成為現在的樣子，基本上優化了之前的所有缺點，相較於之前尋路的速度快了N倍，當然深度優先本來就不是用於遍歷出最短路徑，廣度優先的尋路演算法才是真正適合用於尋找最短路徑，剛開始思路沒那麼清晰所以才有了深度遍歷最短路徑。

  • 以下是全部的函式和部分變數：

  1. void game()  //走迷宮遊戲，包含時間統計，以及對老鼠的移動控制，遊戲模組

  2. void create_plat()   //新建地圖，並存入檔案的模組   地圖檔案是plat.txt

  3. void show_plat()   //地圖展示模組

  4. void alter_plat()    //修改地圖模組

  5. void read_plat()  //讀取檔案裡的地圖模組

  6. //廣度優先尋路演算法 

    int NextPos(int *i,int *j,int count)  //i行 j列,count為遍歷上下左右的條件
    void En_stack(int i,int j,int k)        //將通路的i，j計入棧中
    void De_stack(int *i,int *j,int *k)   //讀取棧中的元素
    void Path_BFS()                         //廣度演算法遍歷，尋找最短路徑核心
    void path_best()                          //標記最短路徑模組並顯示

  7. void path_find(int p,int q)  //尋找通關路徑的模組，深度演算法

  8. 新增元素：

    typedef struct
    {
        int x;
        int y;
    }Axis;
    //用於存放路徑結構體
    typedef struct
    {
        int parent;
        int child;
        Axis childpos;
    }Stack;

    Stack S[M*N];   //用於儲存的棧
    int top=0,bottom=0;        //標記棧的兩個定位元素

經過n次除錯，改程式碼，才調試出來，去掉了原先深度尋找最短路徑的部分程式碼，新增的visit陣列是用來廣度遍歷標記的，然後配合S棧找出返回的路徑，返回路徑是由parent和child標記定位棧中元素返回的，並不是一個一個出棧，然後標記出路徑再輸出，當然這個程式還是有一點小瑕疵，就是一旦使用20x20空地圖，再用尋找全部路徑這個功能，就會出現bug，因為尋找全部路徑使用的是深度遍歷，空地圖如果大了，就需要更多的運算，花費很多時間，但是9x9地圖是沒有問題的，有興趣的話可以自己改著試一下。

以下是原始碼：

大家可以改一下試試，程式設計軟體vc6.0

#include <stdio.h>
#include <stdlib.h>
#include<conio.h>
#include<time.h>

#define M 9
#define N 9
 
int maze[M][N] = {2,2,2,2,2,2,2,2,2,
				  2,0,0,0,2,0,0,0,2,
				  2,0,2,0,0,0,2,2,2,
				  2,0,0,2,2,0,0,0,2,
				  2,0,2,0,1,2,2,0,2,
				  2,0,2,0,2,0,0,0,2,
				  2,0,2,0,2,2,0,2,2,
				  2,0,0,0,0,2,0,3,2,
				  2,2,2,2,2,2,2,2,2};         //初始預設地圖

int visit[M][N]={ 2,2,2,2,2,2,2,2,2,
				  2,0,0,0,2,0,0,0,2,
				  2,0,2,0,0,0,2,2,2,
				  2,0,0,2,2,0,0,0,2,
				  2,0,2,0,1,2,2,0,2,
				  2,0,2,0,2,0,0,0,2,
				  2,0,2,0,2,2,0,2,2,
				  2,0,0,0,0,2,0,3,2,
				  2,2,2,2,2,2,2,2,2};           //用於廣度遍歷的陣列

typedef struct
{
	int x;
	int y;
}Axis;

//用於存放路徑結構體
typedef struct
{
	int parent;
	int child;
	Axis childpos;
}Stack;

Stack S[M*N];   //用於儲存的棧

//全域性定義的變數
int m=4,n=4;               //老鼠的初始位置
int p=4,q=4;               //老鼠位置二次定位
int x=7,y=7;               //糧倉初始位置
int g;		               //g:統計有效路徑，防止路徑過多，造成迴圈過度；
int top=0,bottom=0;        //標記棧的兩個定位元素

void game()  //走迷宮遊戲，包含時間統計，以及對老鼠的移動控制，遊戲模組
{
	int i,j,v,t=0;          //t為初始時間
	char str;
	time_t start,end;
	start=time(NULL);

	maze[x][y]=3;

	m=p;
	n=q;
	maze[m][n]=1;    //重新定位老鼠位置

	printf("顯示迷宮：\n"); //地圖初始化
	for (i = 0 ; i < M ; i++)
	{
		for (j = 0 ; j < N ; j++)
		{
			if(maze[i][j] == 2){
				printf("▉");
			}
		
			else if(maze[i][j]==1)
			{
				printf("鼠");
			}
			else if(maze[i][j]==3)
			{
				printf("糧");
			}
			else
			{
				printf("  ");
			}
		}
		printf("\n");
	}
 	printf("（按w↑s↓a← d→移動）\n請在15秒內通關☆(－ｏ⌒)\n"); //初始化地圖

	while(1)
	{
		printf("時間：%d\r",t);
		if(kbhit())				//輸入控制
		{
			str=getch();
			if(str=='w') //上
			{
				if(maze[m-1][n]==0)
				{
					maze[m-1][n]=1;
					maze[m][n]=0;
					m=m-1;
				}
				else if(maze[m-1][n]==3)
				{
					maze[m][n]=0;
					v=1;
				}
			}
			else if(str=='s')   //下
			{
				if(maze[m+1][n]==0)
				{
					maze[m+1][n]=1;
					maze[m][n]=0;
					m=m+1;
				}
				else if(maze[m+1][n]==3)
				{
					maze[m][n]=0;
					v=1;
				}
			}
			else if(str=='a')   //左
			{
				if(maze[m][n-1]==0)
				{
					maze[m][n-1]=1;
					maze[m][n]=0;
					n=n-1;
				}
				else if(maze[m][n-1]==3)
				{
					maze[m][n]=0;
					v=1;
				}
			}
			else if(str=='d')  //右
			{
				if(maze[m][n+1]==0)
				{
					maze[m][n+1]=1;
					maze[m][n]=0;
					n=n+1;
				}
				else if(maze[m][n+1]==3)
				{
					maze[m][n]=0;
					v=1;
				}
			}
			else;
	
			system("cls");
			printf("顯示迷宮：\n");  //顯示遊戲地圖
			for (i = 0 ; i < M ; i++)
			{
				for (j = 0 ; j < N ; j++)
				{
					if(maze[i][j] == 2)
					{
						printf("▉");
					}
			
					else if(maze[i][j]==1)
					{
					printf("鼠");
					}
					else if(maze[i][j]==3)
					{
						printf("糧");
					}
					else
					{
						printf("  ");
					}
				}
				printf("\n");
			}
 			printf("（按w↑s↓a← d→移動）\n請在15秒內通關☆(－ｏ⌒) \n");
		}
		else;

		if(v==1)  //判斷是否通關
		{
			printf("\n恭喜通關！(￣▽￣)~*\n");
			system("pause");
			break;
		}

		if(t>15)   //規定時間到後結束遊戲
		{
			printf("\n未在規定時間內通關，遊戲失敗。(╯︵╰)\n");
			maze[m][n]=0;   //清除最後所在位置
			system("pause");
			break;
		}

		end=time(NULL);
		t=difftime(end,start);
	}

}

void create_plat()   //新建地圖，並存入檔案的模組
{
	int i,j,s;
	cc:	printf("請輸入0和2,0代表通路，2代表牆體(數字用空格隔開)，輸入規格是%dx%d，有邊緣牆體無需再次輸入(￣▽￣)／\n",M-2,M-2);
		for(i=1;i<=M-2;i++)
		{
			printf("第%d行:",i);
			for(j=1;j<=N-2;j++)
			{
				scanf("%d",&s);
				if(s==0||s==2)
					maze[i][j]=s;
				else
				{
					system("cls");
					printf("輸入錯誤請重新輸入╮(╯﹏╰）╭\n");
					goto cc;
				}
			}
		}

	aa: printf("請設定老鼠的初始位置x,y即行列（1~%d,1~%d）:\n",M-2,N-2);
		p=q=NULL;
		m=n=NULL;

	//清除來自鍵盤的30多個快取字元，防止死迴圈bug
	for(i=0;i<30;i++)
	fflush(stdin);

	scanf("%d,%d",&p,&q);
	if(p<=(M-2)&&q<=(M-2)&&p>0&&q>0)
		maze[p][q]=1;
	else
	{
		system("cls");
		printf("輸入錯誤，請重新輸入,在%dx%d的範圍內。(；′⌒`)\n",M-2,N-2);
		goto aa;
	}

	bb: printf("請設定糧倉的位置x,y:\n");

	//清除來自鍵盤的30多個快取字元，防止死迴圈bug
	for(i=0;i<30;i++)
	fflush(stdin);

	scanf("%d,%d",&x,&y);
	if(x<=(M-2)&&y<=(N-2)&&x>0&&y>0&&(x!=p||y!=q))
		maze[x][y]=3;
	else
	{
		system("cls");
		printf("輸入錯誤，請重新輸入,在%dx%d的範圍內。(；′⌒`)\n",M-2,N-2);
		goto bb;
	}

	//檔案儲存地圖
	FILE *fp;
	fp=fopen("plat.txt","w");
	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
		fprintf(fp,"%d\t",maze[i][j]);
		fprintf(fp,"%c",'\n');
	}
	fprintf(fp,"%d\t",p);
	fprintf(fp,"%d\t",q);
	fprintf(fp,"%d\t",x);
	fprintf(fp,"%d\t",y);
	fclose(fp);

	printf("地圖新建完成,並儲存成功！！！ヾ(^Д^*)/\n");
	system("pause");
}

void show_plat()   //地圖展示模組
{
	int i,j;
	system("cls");

	maze[x][y]=3;

	m=p;
	n=q;
	maze[m][n]=1;

	printf("顯示迷宮：\n");  //顯示遊戲地圖
	for (i = 0 ; i < M ; i++)
	{
		for (j = 0 ; j < N ; j++)
		{
			if(maze[i][j] == 2)
			{
				printf("▉");
			}
	
			else if(maze[i][j]==1)
			{
				printf("鼠");
			}
			else if(maze[i][j]==3)
			{
				printf("糧");
			}
			else
			{
				printf("  ");
			}
		}
		printf("\n");
	}
	printf("已顯示地圖☆(－ｏ⌒)\n");
	system("pause");
}

void alter_plat()    //修改地圖模組
{
	int i,j,select,a,b;
	FILE *fp;
	while(1)
	{
		system("cls");

		m=p;
		n=q;
		maze[m][n]=1;

		printf("顯示迷宮：\n");  //顯示遊戲地圖
			for (i = 0 ; i < M ; i++)
			{
				for (j = 0 ; j < N ; j++)
				{
					if(maze[i][j] == 2)
					{
						printf("▉");
					}
			
					else if(maze[i][j]==1)
					{
						printf("鼠");
					}
					else if(maze[i][j]==3)
					{
						printf("糧");
					}
					else
					{
						printf("  ");
					}
				}
				printf("\n");
			}
			printf("  =============----修改地圖------===================\n");
			printf(" |請選擇：                                          |\n");
			printf(" |              1.修改為牆體；                      |\n");
			printf(" |              2.修改為通路；                      |\n");
			printf(" |              3.儲存修改地圖；                    |\n");
			printf(" |              0.退出修改功能；                    |\n");
			printf("  ===========（請輸入相應數字執行其功能）===========\n");
			fflush(stdin);  //清除鍵入的快取
			scanf("%d",&select);

			if(select<4 && select>=0)
			{
				switch(select)
				{
				case 1:	printf("圍牆內為修改範圍，範圍是%dx%d\n",M-2,N-2);
						printf("請輸入座標x,y(行,列)修改地圖:\n");

						//清除來自鍵盤的30多個快取字元，防止死迴圈bug
						for(i=0;i<30;i++)
						fflush(stdin);

						scanf("%d,%d",&a,&b);
						if(a<=(M-2)&&b<=(N-2)&&a>0&&b>0&&maze[a][b]!=1&&maze[a][b]!=3)
								maze[a][b]=2;
						else
							{
								printf("輸入錯誤請重新輸入，不能在圍牆、糧倉和老鼠的位置修改哦(*/ω＼*)\n");
								system("pause");
							}
						break;
				case 2:	printf("圍牆內為修改範圍，範圍是%dx%d\n",M-2,N-2);
						printf("請輸入座標x,y(行,列)修改地圖:\n");
						//清除來自鍵盤的30多個快取字元，防止死迴圈bug
						for(i=0;i<30;i++)
						fflush(stdin);

						scanf("%d,%d",&a,&b);
						if(a<=(M-2)&&b<=(N-2)&&a>0&&b>0&&maze[a][b]!=1&&maze[a][b]!=3) 
								maze[a][b]=0;
						else
							{
								printf("輸入錯誤請重新輸入，不能在圍牆、糧倉和老鼠的位置修改哦(*/ω＼*)\n");
								system("pause");
							}
						break;
				case 3: 
					{			//檔案形式儲存修改後地圖
							fp=fopen("plat.txt","w");
							for(i=0;i<M;i++)
							{
								for(j=0;j<N;j++)
								fprintf(fp,"%d\t",maze[i][j]);
								fprintf(fp,"%c",'\n');
							}
							fprintf(fp,"%d\t",p);
							fprintf(fp,"%d\t",q);
							fprintf(fp,"%d\t",x);
							fprintf(fp,"%d\t",y);
							fclose(fp);

							printf("地圖修改完成,並儲存成功！！！(*￣︶￣)\n");
							system("pause");
					}
					break;
				case 0: break;
				} 
				//同步陣列maze到visit
				for(i=0;i<M;i++)
					for(j=0;j<N;j++)
					visit[i][j]=maze[i][j];
			}
			else
			{
				printf("請按規定輸入哦￣ω￣=\n");
				system("pause");
			}

			if(select==0)
				break;
	}
}

void read_plat()  //讀取檔案裡的地圖模組
{
	int i,j;
	FILE *fp;
	fp=fopen("plat.txt","r");
	if(!fp)
	{
		printf("檔案不存在，請重新開啟(╥╯^╰╥)\n");
		system("pause");
		return;
	}
	else
	{
		for(i=0;i<M;i++)    //讀取到maze陣列
		{
			for(j=0;j<N;j++)
			fscanf(fp,"%d\t",&maze[i][j]);
			fscanf(fp,"\n");
		}
		fscanf(fp,"%d\t",&p);
		fscanf(fp,"%d\t",&q);    //讀取老鼠的位置
		fscanf(fp,"%d\t",&x);
		fscanf(fp,"%d\t",&y);   //讀取糧倉的位置
		printf("讀取成功，請檢視新地圖！(￣▽￣)~*\n");
		//將maze拷貝到visit
		for(i=0;i<M;i++)
			for(j=0;j<N;j++)
				visit[i][j]=maze[i][j];
	
		system("pause");
	}
	fclose(fp);
}


//廣度優先尋路演算法 

int NextPos(int *i,int *j,int count)   //i行 j列,count為遍歷上下左右的條件
{
	switch(count)
	{
	case 1: (*j)++;     //右
			return 1;
	case 2: (*i)++;		//下
			return 1;	
	case 3: (*j)--;		//左
			return 1;
	case 4: (*i)--;		//上
			return 1;
	default:
			return 0;
	}
}

void En_stack(int i,int j,int k) //將通路的i，j計入棧中
{
	S[top].childpos.x=i;
	S[top].childpos.y=j;
	S[top].parent=k;
	S[top].child=top;
	top++;
}

void De_stack(int *i,int *j,int *k)  //讀取棧中的元素
{
	*i=S[bottom].childpos.x;
	*j=S[bottom].childpos.y;
	*k=S[bottom].child;
	bottom++;
}

void Path_BFS()        //廣度演算法遍歷，尋找最短路徑核心
{
	int i,j,k,count,store_i,store_j;;

	En_stack(p,q,-1);
	visit[p][q]=1;
	while(1)
	{
		count=1;
		De_stack(&i,&j,&k);
		store_i=i;store_j=j;   //儲存當前位置
		while(NextPos(&i,&j,count))
		{
			count++;
			if(visit[i][j]==3||!visit[i][j])
			{
				En_stack(i,j,k);
				visit[i][j]=1;
				if(i==x&&j ==y)
					return;
			}
			i=store_i;j=store_j;
		}
	}
}


void path_best()     //標記最短路徑模組並顯示
{
	int i,j,k;
	
	//最短路徑標記
	k=top-1;
	while(k!=-1)
	{
		i=S[k].childpos.x;
		j=S[k].childpos.y;
		maze[i][j]=5;
		k=S[k].parent;
	}

	//輸出最短路徑
	printf("最短路徑：\n");
	for(i=0;i<M;i++)
	{
		for(j=0;j<N;j++)
			if(maze[i][j] == 2)
				printf("█");
			else if(maze[i][j]==0)
				printf("  ");
			else
				printf("の");
		printf("\n");
	}

	//地圖恢復
	k=top-1;
	while(k!=-1)
	{
		i=S[k].childpos.x;
		j=S[k].childpos.y;
		maze[i][j]=0;
		k=S[k].parent;
	}
	top=0;
	bottom=0;
	for(i=0;i<M;i++)
		for(j=0;j<N;j++)
			visit[i][j]=maze[i][j];
	maze[p][q]=1;
	maze[x][y]=3;
}

//廣度搜索over

void path_find(int p,int q)  //尋找通關路徑的模組，深度演算法
{
	int i,j,c;	
	maze[p][q]=1;

	c=g;

	if(c==15)               //防止過度迴圈，暫時只能顯示15條路徑，可調節。
	{
		printf("已列舉10種可行方案！！方案太多可能列舉不完，所以最多列舉15個（￣︶￣）↗\r");
		maze[p][q]=0;
		return;
	//	exit(0);
	}

	if (maze[p][q+1]==3||maze[p][q-1]==3||maze[p+1][q]==3||maze[p-1][q]==3)   //判斷當前位置上下左右是否有糧倉
	{
		printf("顯示路徑: \n");
		for (i = 0 ; i < M ; i++)
		{
			for (j = 0 ; j< N ; j++)
			{
				if(maze[i][j] == 2)
				{
					printf("█");
				}
				else if(maze[i][j] == 1)
					printf("の");
				else if(maze[i][j]==3)
					printf("糧");
				else
					printf("  ");
			}
			printf("\n");
		}
		printf("已顯示方案，如上！請稍等。。。\n");
		g++;
	}
	
	if(g!=15)
	{
		if(maze[p][q+1] == 0) path_find(p, q+1);  //右
		if(maze[p+1][q] == 0) path_find(p+1, q);  //下
		if(maze[p][q-1] == 0) path_find(p, q-1);  //左
		if(maze[p-1][q] == 0) path_find(p-1, q);  //上
	}
	maze[p][q]=0;
}

void main()   //主函式，選單控制介面
{             
			   /*全域性變數：m,n老鼠位置,p,q老鼠初始位置,x,y糧倉的初始位置，top,bottom用於指向棧中元素，標記位置；
			   g統計所有有效路徑的次數，最多十五次，防止因為路徑過多而死迴圈；結構體：Axis;Stack;  
			   區域性變數:l,a,b,str,i,j,k,v,s,t,select	時間變數time_t start,end 指標fp 巨集定義 M N  */

	int select,k;
	while(1)
	{
		system("cls");
		printf("  =============老鼠走迷宮遊戲 n.0===================\n");
		printf(" |請選擇：                                          |\n");
		printf(" |              1.開始遊戲；                        |\n");
		printf(" |              2.新建地圖；                        |\n");
		printf(" |              3.檢視地圖；                        |\n");
		printf(" |              4.修改地圖；                        |\n");
		printf(" |              5.讀取地圖；                        |\n");
		printf(" |              6.顯示最短路徑；                    |\n");
		printf(" |              7.顯示通關所有路徑；                |\n");
		printf(" |              0.退出系統；                        |\n");
		printf("  ===========（請輸入相應數字執行其功能）===========\n");
		printf(" 注意事項:\n 採用廣度優先搜尋演算法，尋找最短路徑，經過測試應該沒有bug了(;≧Д≦)y\n");
		for(k=0;k<30;k++)
		fflush(stdin);  //清除鍵盤輸入的scanf快取，防止死迴圈

		scanf("%d",&select);
		if(select>=0 && select<8)    //鍵盤輸入檢錯
		{
			switch(select)
			{
				case 0:  exit(0);
				case 1:	 system("cls");  //清除選單 
						 game();        //開始遊戲
						 break;
				case 2:  create_plat();  //新建地圖
						 break;
				case 3:  show_plat();   //顯示地圖
						 break;
				case 4:  alter_plat();  //修改地圖
						 break;
				case 5:  read_plat();   //在檔案裡讀取地圖
						 break;
				case 6:  Path_BFS();     //廣度優先尋路演算法核心
						 path_best();     //顯示及恢復地圖
						 system("pause");
						 break;
				case 7:  g=0;
						 path_find(p,q);   //尋找所有通關路徑
						 printf("已顯示所有路徑!(～￣▽￣)～ \n");
						 system("pause");
						 break;
				default:
						break;
			}
		}
		else
		{
			printf("請按規定輸入哦￣ω￣=\n");
			system("pause");
		}
	}
}
/*2018.8.22 14:33   作者:zero丶0   廣度尋路演算法的最後一個版本,n次除錯，應該沒什麼問題了*/

 

相關推薦

C語言-老鼠走迷宮(廣度尋路演算法)

老鼠走迷宮-c語言（基於廣度優先的尋路演算法） 深讀優先尋路演算法原文：https://blog.csdn.net/qq_42476927/article/details/81868068  本文是基於之前的深度優先尋路演算法改進而來，參考了許多廣度遍歷的程式碼結合自己程

C語言-老鼠走迷宮(深度尋路演算法)

老鼠走迷宮-c語言（基於深度優先的尋路演算法） 這個是學校的課設，剛開始有點頭疼，但是感覺越做越有意思了，於是就有如下程式碼，可能相較於大佬還有差距，但是這是我目前所能做的最優的程式了吧！    話不多說，說一下程式碼的核心內容吧！   &nb

遞迴演算法求老鼠走迷宮（C語言）

  /*說明老鼠走迷宮是遞迴求解的基本題型，我們在二維陣列中使用2表示迷宮牆壁， 使用1來表示老鼠的行走路徑，試以程式求出由入口至出口的路徑。 解法老鼠的走法有上、左、下、右四個方向，在每前進一格之後就選一個方向前進， 無法前進時退回選擇下一個可前進方向，如此在陣列中依序測

c#實現迷宮尋路演算法

一、解決問題：在Unity3d的一些2d遊戲製作上，有時需要敵人在眾多箱子（障礙物）中向主角移動，如果是簡單的移動ai程式碼實現，敵人有可能陷入死衚衕然後左右移動，卡死在衚衕上，為了一個智慧的ai實現，比較常用的是A*演算法，但這裡為了簡便，我們使用了深度搜索的方式進行判斷。

Java與算法之(5) - 老鼠走迷宮(深度優先算法)

tail 數字化 boa pop ase lis ext oar tar 小老鼠走進了格子迷宮，如何能繞過貓並以最短的路線吃到奶酪呢？ 註意只能上下左右移動，不能斜著移動。 在解決迷宮問題上，深度優先算法的思路是沿著一條路一直走，遇到障礙或走出邊界再返回嘗試別的路徑。 首

Go語言實現走迷宮

package main import ( "fmt" "os/exec" "os" "time" ) //定義全域性變數 var( //定義變數儲存R當前位置 currentRow = 1 currentCol = 1 //定義變數儲存迷宮出口位置(索引) endRow =

noj電子老鼠走迷宮（深搜dfs）超時錯誤

1042.電子老鼠闖迷宮 時限：1000ms 記憶體限制：10000K  總時限：3000ms 描述 有一隻電子老鼠被困在如下圖所示的迷宮中。這是一個12*12單元的正方形迷宮，黑色部分表示建築物，白色部分是路。電子老鼠可以在路上向上、下、左、右行走，每一步走一個格子。現給

C＃中的尋路演算法

目錄 介紹 問題 Dijkstra演算法 A *演算法 結果 結論 挑戰 Dijkstra和Astar的比較 Download source - 571.3 KB 在Visual Studio 2017中解壓縮並開啟解決方案 介紹 你有沒

【NOJ1042】【分支限界法】電子老鼠走迷宮

1042.電子老鼠闖迷宮 時限：1000ms 記憶體限制：10000K  總時限：3000ms 描述 有一隻電子老鼠被困在如下圖所示的迷宮中。這是一個12*12單元的正方形迷宮，黑色部分表示建築物，白色部分是路。電子老鼠可以在路上向上、下、左、右行走，每一步走一個格子。

資料結構經典演算法學習之老鼠走迷宮02

老鼠走迷宮 基於上一遍博文的基礎上，稍作修改，顯示所有可達到的最近路線（這裡指的最近就是不存在到達出口處還在別的出口來回走，額。。。可能沒表達清楚，讀者可以自己跑一下程式看看就明白了）程式碼實現： p

人工智慧: 自動尋路演算法實現(一、廣度優先搜尋)

前言 隨著人工智慧技術的日益發達，我們的生活中也出現了越來越多的智慧產品。我們今天要關注的是智慧家居中的一員：掃地機器人。智慧掃地機器人可以在主人不在家的情況下自動檢測到地面上的灰塵，並且進行清掃。有些更為對路線進行規劃，找到可以清理灰塵的最短路徑，達到省電的

小老鼠走迷宮

程式用C語言編寫，在Visual Studio中除錯。要求在規定時間內完成遊戲小鼠走迷宮，找到糧食，小鼠形象可辨認，可以在迷宮中上下左右移動，可以手動生成迷宮，編輯迷宮，並實現牆變路、路變牆、顯示所有路徑、顯示最短路徑。 輸入的形式：通過輸入字元“w 、s 、 a、 d”來控制小鼠的上下左右移動，“

深搜演算法例項：老鼠走迷宮（一）

這個是簡單的深搜，應該輸入深搜中拋磚型的，聯絡下程式碼，回顧一下深搜的思想。 本題的要求是，在開始點(1,1)和終點(5,5)放一隻老鼠，讓老鼠找到一條路徑走出去（暫時不考慮最短路徑），找到後輸出路徑。 最簡單的想法就是對於上下左右四個進行刨根型的搜尋，找到

c++實現的A* 靜態尋路演算法 程式碼

在此僅提供程式碼，不對原理進行解釋。 如果想知道原理請自行百度，已經有很多前輩寫過了。 這裡用到了簡單的圖形庫 easyX #include<iostream> #include<math.h> #include<graphics.h> using n

A星演算法(遊戲尋路演算法)的C++實現

      先吐槽一句：CODE功能太不給力了，怎麼弄怎麼崩潰，難道是CSDN也被掃黃打非了？？？ ---------------------------------------------     A星演算法的實現原理看這裡：http://www.cnblogs.com

A*尋路演算法基於C#實現

 玩過即時戰略，RPG等型別的遊戲的朋友一定會知道，當我們用滑鼠選取某些單位並命令其到達地圖上確定的位置時，這些單位總是可以自動的選擇最短的路徑到達。這個時候我們就會聯想到大名鼎鼎的A*尋路演算法，下文簡略介紹演算法實現原理，並附上C#實現方法。using System; u

A*尋路演算法的C++簡單實現

2007/8/13 17:26:59 #include <iostream> #include <ctime> #include <list> #include <algorithm> #include <cassert&

C語言實現簡單迷宮 --- 回溯法（遞迴）

首先我們瞭解一下回溯法。 回溯法：對於一個包括有很多個節點，每個節點由若干個搜尋分支的問題，把原問題分解為若干個子問題求解的演算法；當搜尋到某個節點發現無法再繼續搜尋下去時，就讓搜尋過程回溯（回退）到該節點的前一個結點，繼續搜尋該節點外的其他尚未搜尋的分支；如

A*尋路演算法C++簡單實現

參考文章： A*尋路演算法是遊戲中常用的AI演算法，這裡用C++簡單實現了一下演算法，便於理解。 搜尋區域 如圖所示簡易地圖, 其中綠色方塊的是起點 (用 A 表示), 中間藍色的是障礙物, 紅色的方塊 (用 B 表示) 是目的地. 為了可以用一個二

C++小遊戲——走迷宮

大家想不想成名，那就一步步來吧，先寫一些小遊戲熱熱身。 下載地址 主程式程式碼： #include<conio.h> #include<stdlib.h> #inclu