走迷宫sdut1269（附带dfs求所有路径与bfs求最佳路径）

记录这道题的原因是这个题的解法是一个很好的模板，特别是用数组表示方向，然后用循环进行操作，节省了不少代码量，比我之前的方法不知道高到哪里去了（噗噗噗），迷宫的问题好多可以在这基础上进行更改，值得记录。

Problem Description

有一个m*n格的迷宫（表示有m行、n列），其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，输入这m*n个数据和起始点、结束点（起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号）。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息（用-1表示无路）。

Input

第一行是两个数m，n（1< m, n< 15)，接下来是m行n列由1和0组成的数据，最后两行是起始点和结束点。

Output

所有可行的路径，输出时按照左上右下的顺序(画重点)。描述一个点时用（x，y）的形式，除开始点外，其他的都要用“->”表示。如果没有一条可行的路则输出-1。

Example Input

5 4

1 1 0 0

1 1 1 1

0 1 1 0

1 1 0 1

1 1 1 1

1 1

5 4

Example Output

(1,1)->(1,2)->(2,2)->(2,3)->(3,3)->(3,2)->(4,2)->(4,1)->(5,1)->(5,2)->(5,3)->(5,4)

(1,1)->(1,2)->(2,2)->(2,3)->(3,3)->(3,2)->(4,2)->(5,2)->(5,3)->(5,4)

(1,1)->(1,2)->(2,2)->(3,2)->(4,2)->(4,1)->(5,1)->(5,2)->(5,3)->(5,4)

(1,1)->(1,2)->(2,2)->(3,2)->(4,2)->(5,2)->(5,3)->(5,4)

(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,2)->(4,2)->(4,1)->(5,1)->(5,2)->(5,3)->(5,4)

(1,1)->(2,1)->(2,2)->(2,3)->(3,3)->(3,2)->(4,2)->(5,2)->(5,3)->(5,4)

(1,1)->(2,1)->(2,2)->(3,2)->(4,2)->(4,1)->(5,1)->(5,2)->(5,3)->(5,4)

(1,1)->(2,1)->(2,2)->(3,2)->(4,2)->(5,2)->(5,3)->(5,4)

#include<iostream>
#include<vector>
#include<string.h>
using namespace std;
int map[1024][1024];
int arr[1024][1024];
int lx[] = { 0,-1,0,1 };
int ly[] = { -1,0,1,0 };
struct node {
int x; int y;
node() {}
node (int a,int b):x(a),y(b){}
}a,b;
vector<node>vec;
int m, n,sum=0;
void dfs(int x,int y) {
if (x == b.x&&y == b.y) {
int i = 0;
for (auto iter : vec) {
i < vec.size()-1 ?
cout << "(" << iter.x << "," << iter.y << ")" << "->" :
cout << "(" << iter.x << "," << iter.y << ")" << endl;
i++;
sum++;
}
return;
}
else {
for (int i = 0; i < 4; i++) {
if (x + lx[i] <= m&&x + lx[i] >= 0 && y + ly[i] <= n&&y + ly[i] >= 0
&& map[x + lx[i]][y + ly[i]] == 1 && arr[x + lx[i]][y + ly[i]] == 0) {
arr[x + lx[i]][y + ly[i]] = 1;
vec.push_back(node(x + lx[i], y + ly[i]));
dfs(x + lx[i], y + ly[i]);
vec.pop_back();
arr[x + lx[i]][y + ly[i]] = 0;
}
}
}
}
int main(void) {
memset(arr, 0, sizeof(arr));
memset(map, 0, sizeof(map));
cin >> m >> n;
for(int i=1;i<=m;i++)
for (int j = 1; j <= n; j++) {
cin >> map[i][j];
}
cin >> a.x >> a.y >> b.x >> b.y;
vec.push_back(node(a.x, a.y));
arr[a.x][a.y] = 1;
dfs(a.x, a.y);if(!sum)cout << -1;
//system("pause");
return 0;
}

/***************************************************
User name:
Result: Accepted
Take time: 0ms
Take Memory: 2260KB
Submit time:
****************************************************/

/[b]*******************[/b]我是分割线[b]**************[/b]/

在这再写一个关于bfs求最佳路径的方法并记录路径。方法是在结构体里加入一个指向指针。

#include<iostream>
#include<queue>
#include<stack>
using namespace std;
struct node {
int x, y;
node *pre;
};
int flag[1024][1024];
int ma[1024][1024];
int _move[4][2] = { {0,1},{1,0} ,{0,-1}, {-1,0} };
int m,n;
void bfs() {
queue<node*>Q;
stack<node>vec;
node *t=new node;
t->x = 0, t->y = 0,t->pre=nullptr;
Q.push(t);
while (!Q.empty()) {
t = Q.front(); Q.pop();
if (t->x == m - 1 && t->y == n - 1) {
node *h = t;
cout << "get" << endl;
while (h) {
vec.push(*h);
cout << h->x << " " << h->y << endl;
h = h->pre;
}
cout << endl;
while (!vec.empty()) {
auto iter = vec.top();
vec.pop();
cout << iter.x << " " << iter.y << endl;
}
return;
}
for (int i = 0; i < 4; i++) {
node *v=new node;
v->x = t->x + _move[i][0];
v->y = t->y + _move[i][1];
if (v->x < m&&v->x >= 0 && v->y < n&&v->y >= 0
&& !flag[v->x][v->y] && ma[v->x][v->y] == 1) {
flag[v->x][v->y] = 1;
Q.push(v);
v->pre = t;
}
}
}
cout << "wrong";
}
int main(void) {
cin >> m >> n;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
cin >> ma[i][j];
bfs();
system("pause");
return 0;
}

附上两个关于bfs的博客：

http://blog.csdn.net/raphealguo/article/details/7523411

http://blog.csdn.net/acmman/article/details/38342115