semaine 2 devoirs 1 labyrinthe

Le titre

Dongdong a une carte et veut trouver le papier sœur à travers la carte. La carte montre que 0 signifie que vous pouvez marcher, 1 signifie que vous ne pouvez pas marcher, le coin supérieur gauche est l'entrée et le coin inférieur droit est le papier sœur. Ces deux positions sont garanties à 0. Maintenant que vous connaissez la carte, il n'est pas difficile pour Dongdong de trouver du papier sœur. Veuillez écrire un programme pour écrire l'itinéraire le plus court pour Dongdong pour trouver du papier sœur. L'entrée est un tableau bidimensionnel 5 × 5, composé de seulement 0 et 1 chiffres, représentant une carte de tableau normale. Plusieurs lignes sont sorties, représentant les coordonnées du chemin le plus court du coin supérieur gauche au coin inférieur droit, au format indiqué dans l'exemple. Les données sont garanties d'avoir une solution unique.

Des idées

J'ai utilisé la méthode dfs pour trouver le chemin, en utilisant deux tableaux constants pour représenter les quatre directions de mouvement vers le haut, le bas, la gauche et la droite, et en utilisant un vecteur et une variable de pile pour stocker le chemin.
Dans la fonction dfs, déterminez si l'élément tail est le point final, sinon continuez à regarder vers le bas selon l'ordre d'index du tableau constant. Si le point suivant peut être atteint, c'est-à-dire que tong () renvoie true, puis marquez le point et ajoutez La pile continue de récurer. Lorsque vous atteignez une impasse, c'est-à-dire qu'il n'y a aucun moyen d'atteindre dans les quatre directions, vous libérerez le point de la pile et continuerez la récursivité.

Résumé

Cette question a pris beaucoup de détours. Le chemin de stockage est également intelligent. J'utilise un tableau pour stocker l'index de tableau constant de chaque opération. Je suis assez stupide pour oublier que le vecteur a été enregistré et j'ai oublié la connaissance du graphique. Je l'ai inventé.

Code

#include<stdio.h>
#include<iostream>
using namespace std;

int sx=1,sy=1,ex=5,ey=5,step=0;
const int dx[4]={1,0,-1,0};	//表示移动方向
const int dy[4]={0,1,0,-1};
int mp[7][7]=
{
    {1,1,1,1,1,1,1},
    {1,0,0,0,0,0,1},
    {1,0,0,0,0,0,1},
    {1,0,0,0,0,0,1},
    {1,0,0,0,0,0,1},
    {1,0,0,0,0,0,1},
    {1,1,1,1,1,1,1}
};
int arrive[7][7]=
{
    {0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0},
    {0,0,0,0,0,0,0}
};
struct point
{
	int x,y;
	point(int _x=1,int _y=1):x(_x),y(_y){};
};
vector<point> lu;
int pos[25];//存储路径 
static int count=0;

bool tong(int i,int nx,int ny)
{
	nx += dx[i];
    ny += dy[i];
    return (nx >= 1 && nx <= 5 && ny >= 1 && ny <= 5 && mp[nx][ny] != 1 && !arrive[nx][ny]);
}
void dfs()
{
	point t=lu.back();

	if(t.x==ex&&t.y==ey)return; //到达终点
	int nx=t.x,ny=t.y;

    if (tong(0,nx,ny)) {
    	nx += dx[0];
        ny += dy[0];
    	arrive[nx][ny]=1;
    	pos[step++]=0;
    	point t(nx,ny);
        lu.push_back(t);
        dfs();
    }
    else  if (tong(1,nx,ny)) {
   		nx += dx[1];
        ny += dy[1];
    	arrive[nx][ny]=1;
    	pos[step++]=1;
    	point t(nx,ny);
        lu.push_back(t);
        dfs();
    }
    else  if (tong(2,nx,ny)) {
    	nx += dx[2];
        ny += dy[2];
    	arrive[nx][ny]=1;
    	pos[step++]=2;
    	point t(nx,ny);
        lu.push_back(t);
        dfs();
    }
    else if (tong(3,nx,ny)) {
    	nx += dx[3];
        ny += dy[3];
    	arrive[nx][ny]=1;
    	pos[step++]=3;
    	point t(nx,ny);
        lu.push_back(t);
        dfs();
    }
    else 
	{
		if(step) //返回上一层 
		step--;
		lu.pop_back();
		if(lu.size()){
			point t=lu.back();
			dfs();
		}
	   else {
		cout<<"no way"<<endl;
		}
	}   
}
void showPath()
{
	int xx=0,yy=0;
	cout << "(" << xx << ", " << yy << ")" << endl;	
	for(int i=0;i<step;i++)
	{
		xx = xx + dx[pos[i]];
    	yy = yy + dy[pos[i]];
        cout << "(" << xx << ", " << yy << ")" << endl;
	}
}
int main()
{
	point beg(1,1);
	lu.push_back(beg);
	for(int i=1;i<=5;i++)
		for(int j=1;j<=5;j++)
			cin>>mp[i][j];				
	dfs();
	showPath();
	return 0;
}