深刻体验DFS与BFS之----HJ43 迷宫问题

#HJ43 迷宫问题

描述
定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示：

int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
};

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


本题含有多组数据。

输入描述：
输入两个整数，分别表示二维数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。

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

示例1
输入：
5 5
0 1 0 0 0
0 1 1 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

输出：
(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

示例2
输入：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 1
0 1 1 1 0
0 0 0 0 0

输出：

(0,0)
(1,0)
(2,0)
(3,0)
(4,0)
(4,1)
(4,2)
(4,3)
(4,4)

说明：
注意：不能斜着走！！

// 这是一道典型的dfs 和 bfs的题目，这里我们用两种方法都写一下

#include <iostream>
#include<queue>
#include <vector>


using namespace std;
int row[4]={1,-1,0,0};
int col[4]={0,0,1,-1};

class Slove {
    public:
        Slove(){}
        ~Slove(){}
    void dfs(vector<vector<int>>& data,vector<vector<bool>>& used,vector<pair<int,int>>& path) {
         if(!path.empty()) {
             auto val = path.back();
             if(val.first==data.size()-1 && val.second==data[0].size()-1) {
                 if(maxlength>path.size()) {
                     res=path;
                     maxlength=path.size();
                     return;
                 }
             }
         }
        
        // 开始寻找
        auto val=path.back();
        for(int i=0;i<4;i++) {
            int new_i = val.first+row[i];
            int new_j = val.second+col[i];
            if(new_i<0 || new_j<0 || new_i>=data.size() || new_j>=data[0].size()) {
                continue;
            }
            if(used[new_i][new_j] || data[new_i][new_j]==1) {
                continue;
            }
            
            used[new_i][new_j]=true;
            path.push_back({new_i,new_j});
            dfs(data,used,path);
            used[new_i][new_j]=false;
            path.pop_back();
        }
        
        
        
    }
    
    // 这里写一个bfs
    
    void bfs(vector<vector<int>>& data,vector<vector<bool>>& used,queue<vector<pair<int,int>>>& que) { // used的作用是为了防止回头路
        while(!que.empty()) {
            int size = que.size();
            for(int i=0;i<size;i++) {
                auto path = que.front();
                que.pop();
                auto val = path.back();
                for(int i=0;i<4;i++){
                    int new_i = val.first+row[i];
                    int new_j = val.second+col[i];
                    if(new_i<0 || new_j<0 || new_i>=data.size() || new_j>=data[0].size()) {
                    continue;
                    }
                    if(used[new_i][new_j] || data[new_i][new_j]==1) {
                        continue;
                    }
                    used[new_i][new_j]=true;
                    path.push_back({new_i,new_j});
                    if(new_i==data.size()-1 && new_j==data[0].size()-1) {
                        res=path;
                        Show();
                        return;
                    }
                    que.push(path);
                    path.pop_back(); // 不能影响其他人，que里面存放的就是路径
                }
                
            }
        }
        
    }
    
    
    void Show() {
        for(auto a: res) {
            cout<<"("<<a.first<<","<<a.second<<")"<<endl;
        }
    }
    
    vector<pair<int,int>> res;
    int maxlength=1000;
};


int main() {
    int row, col;
    while(cin>>row && cin>>col) {
        if(row==0 && col==0) {
            continue;
        }
        vector<vector<int>> data(row,vector<int>(col,0));
        for(int i=0;i<row;i++) {
            for(int j=0;j<col;j++) {
                int val ;
                cin>>val;
                data[i][j]=val;
            }
        }
//         for(auto a:data) {
//             for(auto b:a) {
//                 cout<<b<<" ";
//             }
//             cout<<endl;
//         }
        Slove s;
        vector<vector<bool>> used(row,vector<bool>(col,false));
        vector<pair<int, int>> path;
        path.push_back({0,0});
        
//        dfs解法
//         s.dfs(data,used, path);
//         s.Show();
        // bfs解法
        queue<vector<pair<int,int>>> que;
        que.push(path);
        s.bfs(data, used, que);
        
        
    }
}