I - 迷宫问题

定义一个二维数组：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 1 1 0

0 0 0 1 0

Sample Output

(0, 0)

(1, 0)

(2, 0)

(2, 1)

(2, 2)

(2, 3)

(2, 4)

(3, 4)

(4, 4)

搜索路径的dfs就可以了，需要输出走过的路，用一个结构体和一个vector储存，如果接下来的路更短就更新，如果这次的路径长是9就直接可以输出了；

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include <iomanip>
#include<cmath>
#include<float.h>
#include<string.h>
#include<algorithm>
#define sf(a) scanf("%d",&a)
#define pf printf
#define pb push_back
#define mm(x,b) memset((x),(b),sizeof(x))
#include<vector>
#include<map>
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=a;i>=n;i--)
typedef long long ll;
typedef long double ld;
typedef double db;
const ll mod=1e9+100;
const db e=exp(1);
using namespace std;
const double pi=acos(-1.0);
int a[5][5];
int flag=0;
int dir[4][2]={0,-1,0,1,-1,0,1,0};
struct node
{
	int x,y;
	node(int a,int b)
	{
		x=a;y=b;
	}
};
vector<node>v;
vector<node>ans;
void dfs(int x,int y)
{
	if(flag==1) return ;
	if(x==4&&y==4)
	{
	//	cout<<"3";
		if(ans.size()==0)
		{
		//	cout<<"3";
			rep(i,0,v.size() )
			ans.pb(v[i]);
		}else
		{
			if(v.size()<ans.size())
			{
				ans.clear();
				rep(i,0,v.size())
				ans[i]=v[i];
			}
		}
		if(ans.size() ==9)
		flag=1;
		return;
	}
//	cout<<"2";
	rep(i,0,4)
	{
	//	cout<<"1";
		int q,w;
		q=x+dir[i][0];
		w=y+dir[i][1];
		if(q>=0&&q<=4&&w>=0&&w<=4&&a[q][w]==0)
		{
			v.pb(node(q,w));
			a[q][w]=1;//走过改变值，不能让他在走回来
			dfs(q,w);
			a[q][w]=0;//走完退回
			v.pop_back();
		}
	}
}
int main()
{
	rep(i,0,5)
	rep(j,0,5)
	sf(a[i][j]);
	a[0][0]=1;
	v.pb(node(0,0));
	dfs(0,0);
	rep(i,0,ans.size())
	pf("(%d, %d)\n",ans[i].x,ans[i].y);
	return 0;
}