K - 迷宫问题 POJ - 3984

K - 迷宫问题

POJ - 3984

定义一个二维数组：

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)

AC代码

#include <cstdio>
#include <map>
#include <vector>
#include <queue>
#include <cstring>
#include <iostream>

#define ll long long
using namespace std;
const int maxn = 10;
const int INF = 0x3f3f3f3f;
/*
fill(1) 1
drop(1) 2
pour12 3
pour21 4
fill2 5
drop2 6
*/
int a, b, c, d;
vector<int> ans;
vector<int> arr;
vector<int> brr;
char mp[maxn][maxn];
bool vis[maxn][maxn];
int flag = false;
int mv[4][2] = {1,0,0,1,-1,0,0,-1};
struct Node
{
	int x, y;
	int num;
 	Node(int _x, int _y, int _num) {x=_x;y=_y;num=_num;}
};
void bfs()
{
	queue<Node> que;
	que.push(Node(0,0,-1));
	int cnt = 0;
	while (que.size())
	{
		Node nn = que.front(); que.pop();
		int i = nn.x, j = nn.y;
		vis[i][j] =true;
		//printf("%d %d %d %d\n", nn.num,nn.x,nn.y,nn.z);
		if(i == 4 && j == 4)
		{
			for(int i = nn.num; i != -1; i = arr[i])
            {
                brr.push_back(ans[i]);
            }
            int x = 0, y = 0;
            puts("(0, 0)");
			for(int i = brr.size()-1; i >=0; --i)
            {
                printf("(%d, %d)\n", x+=mv[brr[i]][0], y+=mv[brr[i]][1]);
            }
			return;
		}
		//
		for(int i = 0; i < 4; ++i)
        {
            int nx = mv[i][0] + nn.x, ny = mv[i][1] + nn.y;
            if(0<=nx&&nx<5&&0<=ny&&ny<5&&!vis[nx][ny]&&mp[nx][ny]=='0')
            {
                ans.push_back(i);
                arr.push_back(nn.num);
                que.push(Node(nx,ny,cnt++));
            }
        }
	}
}
int main() {
	for(int i = 0; i < 5; ++i)
    {
        for(int j = 0; j < 5; ++j)
        {
            mp[i][j] = getchar();
            getchar();
        }
    }
    bfs();

	return 0;
}