算法与数据结构：BFS-学霸的迷宫

bfs概念

• 常常用来处理最短路径等问题
• 逻辑代码实现

#include <queue>

int main() {
    // bfs必须得有一个队列来实现
    queue<int> nums;
    // 首先将根节点入队
    nums.push(a);
    // 依次遍历每一层
    while (!nums.empty()){
        // 这里要记录，每次要依次记录每一层得情况，这是为了为层与层之间的处理留下处理接口
        int cur_level_nums = nums.size();
        while(cur_level_nums--) {
            // 将队首的元素取出来
            int num = nums.front();
            nums.pop();
            // 相应的处理
            ······
            //如果这个元素找得到下一层的元素，直接将下一层的元素添加在这一层之后
            nums.push(next_level_members)
        }
    }
}

学霸的迷宫

问题描述

学霸抢走了大家的作业，班长为了帮同学们找回作业，决定去找学霸决斗。但学霸为了不要别人打扰，住在一个城堡里，城堡外面是一个二维的格子迷宫，要进城堡必须得先通过迷宫。因为班长还有妹子要陪，磨刀不误砍柴功，他为了节约时间，从线人那里搞到了迷宫的地图，准备提前计算最短的路线。可是他现在正向妹子解释这件事情，于是就委托你帮他找一条最短的路线。

输入格式

1. 第一行两个整数n， m，为迷宫的长宽。
   
2. 接下来n行，每行m个数，数之间没有间隔，为0或1中的一个。0表示这个格子可以通过，1表示不可以。假设你现在已经在迷宫坐标(1,1)的地方，即左上角，迷宫的出口在(n,m)。每次移动时只能向上下左右4个方向移动到另外一个可以通过的格子里，每次移动算一步。数据保证(1,1)，(n,m)可以通过。

输出格式

1. 第一行一个数为需要的最少步数K。
   
2. 第二行K个字符，每个字符∈{U,D,L,R},分别表示上下左右。如果有多条长度相同的最短路径，选择在此表示方法下字典序最小的一个。

解题理解

• 最短路径首先就提示了基本一次BFS，或者多次DFS比较。
• 这里还有一个要求在相同最短路径下选择字典序最小的，似乎要靠多次DFS加路径记录，再进行字典序比较才可以，但是，我们可以试想一下，如果每次我路径选择的时候就按字典序从小大的排序的选：{D,L,R,U}, 那么找到的第一个最短路不就是答案所需要的吗？
• 对于路径的存储：如果采用BFS的方式，存储路径的话，不太好存储的，因为很多条路径可能最开始有一段是相同过程，如果我们不对它进行记录就会出问题，这里我是这么思考的：每次走到一个点的时候，都要记录到当前点的这条路径，因为我已经走到这个点了，所以其他可以到这个点的路径已经不重要了，而且按上一条的想法，我根本不需要再记录其他路径了呀（当前路径绝对是字典序最小的路径），所以只要每次用一个字典了保存更新就好啦。

代码实现：

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;

int xfang[4] = {1, 0, 0, -1};
int yfang[4] = {0, -1, 1, 0};
// 和上面个x,y对应的方向数组 
char fangxiang[4] = {'D','L','R','U'};
	
// 路径保存 
map<pair<int, int>, vector<char> > alltrace;

int main() {
	int n, m;
	cin >> n >> m;

	// 迷宫地图 
	vector<vector<int> > migong(n, vector<int>(m));
	// 开始装迷宫 
	for(int i = 0; i < n; ++i) {
		for(int j = 0; j < m; ++j) {
			char x;
			cin >> x;
			migong[i][j] = x - '0';
			//cout <<  migong[i][j] << endl;
		}
	}
	
	// bfs队列 
	queue<pair<int, int> > points;
	// 从（1，1）开始 
	points.push({0, 0}); 

	int count = 0; 
	// 只要没有遍历结束 
	while(!points.empty()) {
		int points_nums = points.size();
		count++;
		while(points_nums--) {
			// 拿出队首的点 
			int x = points.front().first;
			int y = points.front().second;
			points.pop();
			// 取出路径
			vector<char> trace;
			if (alltrace.count({x, y})){
				trace = alltrace[{x, y}];	
			} 			 
			// 开始四个方向进行遍历，由于题意优先向下走 
			for (int f = 0; f < 4; ++f) {
				if(x + xfang[f] >= 0 && x + xfang[f] < n && y + yfang[f] >= 0 && y + yfang[f] < m && migong[x + xfang[f]][y + yfang[f]] != 1) {
					// 记录路径 
					trace.push_back(fangxiang[f]);
					// 如果已经到 n,m了
					if(x + xfang[f] == n - 1 && y + yfang[f] == m - 1) {
						cout << count << endl;
						// 输出路径
						for(int s = 0; s < trace.size(); ++s) {
							cout << trace[s];
						}
						return 0;
					}
					// 进行标记 
					migong[x + xfang[f]][y + yfang[f]] = 1;
					// 入队 
					points.push({x + xfang[f], y + yfang[f]});
					// 记下这条路 
					alltrace[{x + xfang[f], y + yfang[f]}] = trace; 
					// 状态回溯，还原给其他方向 
					trace.pop_back();
				}			
			} 
		}
	}
	
	cout << 0 << endl;	
	return 0;
}

特别说明

• 做题时候命名比较随便，不要喷我。
• 注意记录迷宫的那点的处理，蓝桥杯有时候连着输入是挺坑的。