POJ - 3984 迷宫问题 （搜索）

Problem Description

定义一个二维数组：

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)

也是kuangbin搜索专题里面的，说起这道题，也是满满的恶意，先看图吧

整整花了一个小时去找到底哪里PE了。

题目思路很明确，BFS或者DFS都可以，但其实这个题目没必要DFS，简单BFS标记一下前驱就行了，何为前驱，就是说你走到了下一步你上一步 是从哪里走来的，然后用优先队列保证每次优先走距离右下角最近的路。那么问题来了，如何输出，因为我们存的是前驱，所以可以先把所有前驱 入栈，再依次出栈输出就行了，但最开始我想到了另一种更好的方法，因为我发现

ostringstream outt;
outt <<  <<  << ;

string s = outt.str();
reverse(s.begin(), s.end());
cout << s << endl;

利用ostringstream流，最后倒过来就可以实现直接顺序输出了，提交PE。找了半天发现是<<endl;倒序后变成先输出了，那么我第一个不加endl，再次提交PE、PE、PE、PE。到这里我觉得可能是ostringstream影响缓冲区，不能这样，改成栈模拟，还是PE =7=，直到最后我发现，（a, b）中间 逗号后面 有个空格 /微笑/微笑。然后改了两种方法都AC了；

AC代码

 #include <iostream>
 #include <string>
 #include <cstdio>
 #include <cstdlib>
 #include <sstream>
 #include <iomanip>
 #include <map>
 #include <stack>
 #include <deque>
 #include <queue>
 #include <vector>
 #include <set>
 #include <list>
 #include <cstring>
 #include <cctype>
 #include <algorithm>
 #include <iterator>
 #include <cmath>
 #include <bitset>
 #include <ctime>
 #include <fstream>
 #include <limits.h>
 #include <numeric>

 using namespace std;

 #define F first
 #define S second
 #define mian main
 #define ture true

 #define MAXN 1000000+5
 #define MOD 1000000007
 #define PI (acos(-1.0))
 #define EPS 1e-6
 #define MMT(s) memset(s, 0, sizeof s)
 typedef unsigned long long ull;
 typedef long long ll;
 typedef double db;
 typedef long double ldb;
 typedef stringstream sstm;
 const int INF = 0x3f3f3f3f;

 int mp[][],vis[][];
 int fx[][] = {,,-,,,-,,};
 vector< pair< int, pair<int,int> > >bj(); //记录前驱和位置
 ostringstream outt;
 class cmp{  //优先队列使得曼哈顿距离小的优先出队
 public:
     bool operator() (const pair<int,int>a,const pair<int,int>b) const{
         int ax =  - a.F +  - a.S;
         int bx =  - b.F +  - b.S;
         return ax > bx;
     }
 };

 void bfs(){
     priority_queue< pair<int,int>,vector< pair<int,int> >, cmp >q;
     //queue< pair<int,int> >q;
     q.push(make_pair(,));
     vis[][] = ;
     while(!q.empty()){
         pair<int,int>nx = q.top();
         q.pop();
         //cout << nx.F << " " << nx.S << endl;
         if( - (nx.F + nx.S) == ){
             bj[].F = nx.F*+nx.S;
             bj[].S.F = , bj[].S.S = ;
             break;
         }

         for(int i = ; i < ; i++){
             int nxx = nx.F + fx[i][];
             int nxy = nx.S + fx[i][];
             if(nxx <  || nxx >  || nxy <  || nxy >  || mp[nxx][nxy] ==  || vis[nxx][nxy])
                 continue;
             vis[nxx][nxy] = ;
             q.push(make_pair(nxx,nxy));
             bj[nxx*+nxy].F = nx.F*+nx.S;
             bj[nxx*+nxy].S.F = nxx, bj[nxx*+nxy].S.S = nxy;
         }
     }
     int nex = ;
     /* //这是用栈模拟的方式
     stack<int>p;
     while(nex){
         p.push(nex);
         nex = bj[nex].F;
     }
     p.push(0);
     while(!p.empty()){
         nex = p.top();
         p.pop();
         cout << "(" << bj[nex].S.F << ", " << bj[nex].S.S << ")"<< endl;
     }
     */
     while(){  //反向输出到ostringstream中
         //cout << nex << endl;
         if(nex == ){
             outt << ")" << bj[nex].S.S << " ," << bj[nex].S.F << "(";
             break;
         }
         outt << ")" << bj[nex].S.S << " ," << bj[nex].S.F << "(" << "\n";
         nex = bj[nex].F;
     }

 }

 int main(){
     ios_base::sync_with_stdio(false);
     cout.tie();
     cin.tie();
     fill(vis[],vis[]+*,);
     for(int i = ; i < ; i++){
         for(int j = ; j < ; j++){
             cin>>mp[i][j];
         }
     }
     bfs();
     string s = outt.str();
     reverse(s.begin(),s.end());  //再次逆序
     cout << s << endl;

     return ;
 }

其他就是一个简单的BFS，值得注意就是优先队列的使用，当然用DFS也行 ，而且DFS就不需要这么多繁杂的逆序了，直接记录从起点到终点的路径输出就好了。