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

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

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

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

這個是學校的課設，剛開始有點頭疼，但是感覺越做越有意思了，於是就有如下程式碼，可能相較於大佬還有差距，但是這是我目前所能做的最優的程式了吧！

   話不多說，說一下程式碼的核心內容吧！

   迷宮是通過二維陣列構造的，二維組中的數字2代表牆體，0是通路，1是老鼠，3代表糧；

  •    以下是所有函式及全域性變數：
  1. void game()  //走迷宮遊戲，包含時間統計，以及對老鼠的移動控制，遊戲模組；
  2. void create_plat()   //新建地圖，並存入檔案的模組；檔案會儲存在程式同目錄下，地圖檔名是plat.txt；
  3. void show_plat()   //地圖展示模組；
  4. void alter_plat()    //修改地圖模組；
  5. void read_plat()  //讀取檔案裡的地圖模組；在讀取地圖之前必須先含有該檔案（plat.txt）；
  6. void path_result(int p,int q)  //統計地圖的所有可能出現的路徑結果，並把次數賦給全域性變數answer，並在path_result函式中引用變數，作為遞迴終止和顯示最優解的條件；
  7. void path_best(int p,int q,int l)     //顯示最優路徑的模組；
  8. void path_find(int p,int q)  //尋找通關路徑的模組；
  9. //全域性定義的變數
    int m=4,n=4;            //老鼠的初始位置
    int p=4,q=4;           //老鼠位置二次定位
    int x=7,y=7;            //糧倉初始位置
    int g,answer;            //g:統計有效路徑，防止路徑過多，造成迴圈過度；answer:統計該地圖的所有可能性；

這個程式碼有一定的缺陷，因為自動尋路演算法是用深度遍歷，所以必須要統計全部結果，而且隨著地圖越來越空，得到的結果越來越多，運算的複雜度提升將會浪費許多時間，我的是9x9的地圖，內部7x7如果全為空，則需要計算不止5億次，5億次是得到的結果這麼多，而且要引用變數，所以翻倍10億次運算的結果；本人親測花了6個小時的時間。所以該部分尋路演算法，是很大的缺陷，目前已找到解決辦法，深度優先是必須找到路最長的，而廣度優先是找到最短的就可以停止，所以不久之後我會再更新一篇部落格，用廣度優先實現自動尋路，相較於深度優先，會更加快速的找出最短路徑。

以下是原始碼：

大家可以自己試試，程式設計軟體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}
};


struct best                  //用於記錄最短路徑的結構體
{
	int min;
	int b[M][N];
}Best;

int m=4,n=4;            //老鼠的初始位置
int p=4,q=4;           //老鼠位置二次定位
int x=7,y=7;            //糧倉初始位置
int g,answer;		    //g:統計有效路徑，防止路徑過多，造成迴圈過度；answer:統計該地圖的所有可能性；

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);

	//清除來自鍵盤的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;
				}
			}
			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");
	}
	else
	{
		for(i=0;i<M;i++)
		{
			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");
		system("pause");
	}
	fclose(fp);
}

void path_result(int p,int q)  //統計地圖的所有可能出現的路徑結果，並把次數賦給全域性變數answer，並在path_result函式中引用變數，作為遞迴終止和顯示最優解的條件
{	
	int i,j;	
	maze[p][q]=1;

	if (maze[p][q+1]==3||maze[p][q-1]==3||maze[p+1][q]==3||maze[p-1][q]==3)   //判斷當前位置上下左右是否有糧倉
	{
		++answer;    //統計一個地圖的所有可能性的次數
		printf("已計算%d次,若超過1 h,請重啟(～￣▽￣)～\r",answer);
	}
// 遞迴部分，即尋找路徑的部分
	if(maze[p][q+1] == 0) path_result(p, q+1);  //右
	if(maze[p+1][q] == 0) path_result(p+1, q);  //下
	if(maze[p][q-1] == 0) path_result(p, q-1);  //左
	if(maze[p-1][q] == 0) path_result(p-1, q);  //上
	maze[p][q]=0;

}


void path_best(int p,int q,int l)     //顯示最優路徑的模組
{
	int i,j,c,k;	

	maze[p][q]=1;

	if (maze[p][q+1]==3||maze[p][q-1]==3||maze[p+1][q]==3||maze[p-1][q]==3)   //判斷當前位置上下左右是否有糧倉
	{
		if(Best.min>l)
		{
			Best.min=l;
			for (i = 0 ; i < M ; i++)
				for (j = 0 ; j< N ; j++)	
						Best.b[i][j]=maze[i][j];
		}
		g++;
		k=((double)g/answer)/2*100+50;  //計算後面一半完成的百分比情況

		printf("已完成%d%%，請繼續等待(￣▽￣)／\r",k);

		c=g;

		if(c==answer)               //防止過度迴圈，比較answer條路徑。   191844是檢測了我自己建的地圖的全部可能路徑次數 檔案是plat.txt
		{
			printf("已列舉最優解！！！比較了前%d個方案中的最優解（￣︶￣）↗\n",answer);
			for (i = 0 ; i < M ; i++)
				{
					for (j = 0 ; j< N ; j++)
								if(Best.b[i][j] == 2)
								{
									printf("█");
								}
								else if(Best.b[i][j] == 1)
									printf("の");
								else if(Best.b[i][j]==3)
									printf("糧");
								else
									printf("  ");
							printf("\n");
				}
			printf("已顯示最優解，方案如上！(〃'▽'〃)\n");
			maze[p][q]=0;
			return;
		//	exit(0);
		}

	}

	++l;

	if(g!=answer)
	{
		if(maze[p][q+1] == 0) path_best(p, q+1,l);  //右
		if(maze[p+1][q] == 0) path_best(p+1, q,l);  //下
		if(maze[p][q-1] == 0) path_best(p, q-1,l);  //左
		if(maze[p-1][q] == 0) path_best(p-1, q,l);  //上
	}
	maze[p][q]=0;
}

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糧倉的初始位置，g統計所有有效路徑的次數，最多十次，防止因為路徑過多而死迴圈；結構體：best Best儲存最優解  區域性變數:l,a,b,str,i,j,k,v,s,t,select	時間變數time_t start,end 指標fp 巨集定義 M N
	int select,k;
	time_t start,end;
	int hour,minute,second,t;   //時間變數

	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 地圖不要全空哦,否則不要執行6,7選項,會運算十億次花費6個小時(本人親測),一般\n 沒耐性就別等了重啟吧！然後儘量把通關所有路徑設定在一億種以內！(;≧Д≦)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:  g=0; Best.min=999;answer=0;
						 start=time(NULL);
						 path_result(p,q);    //統計地圖所有解的個數
						 path_best(p,q,1);   //尋找最短的路徑
						 end=time(NULL);
						 t=difftime(end,start);
						 second=t%60;     //求出秒
						 minute=t/60;        //總分數
						 hour=minute/60;      //求出小時
						 minute=minute%60;   //求出分
						 printf("花費時間：%dh %dm %ds",hour,minute,second);   //顯示尋找最短路徑所花費的時間
						 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.20   作者:zero丶0   深度尋路演算法的最後一個版本,n次除錯，應該沒什麼問題了*/

                                                                                                                                               ————2018年8月20日

                                                                                                                                                               作者：zero丶0

相關推薦

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

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

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

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

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

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

《演算法七》（深度尋路演算法）

深度尋路演算法： 　　二維地圖：二維陣列 　　二維陣列上標識特定數值作為地圖上物件 　　應用於RGB遊戲中比較廣泛 　　缺點：1.二維地圖，只可以走直線 　　　　　2.不一定能找到最佳路徑 怎麼尋路： 　　1.一個方向只能試探一次 　　順時針： 上 右 下 左 　　逆時針：

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

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

c#實現迷宮尋路演算法

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

資料結構之深度尋路---地圖尋路(棧實現)

注：深度尋路用到的棧標頭檔案以及.cpp檔案 在我的資源中可下載或者Q：1286550014(免費) 深度尋路 原理：在地圖中從一個點開始，從規定方向開始走，無障礙就繼續走，資料壓棧，如果有障礙就退一步，資料出棧，直至找到終點或無終點時，尋路結束。 一、標頭檔案匯入 #i

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 表示) 是目的地. 為了可以用一個二