洛谷P1443马的遍历

题目描述

有一个 n×m 的棋盘，在某个点 (x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式

输入只有一行四个整数，分别为 n,m,x,y。

输出格式

一个 n×m 的矩阵，代表马到达某个点最少要走几步（不能到达则输出 −1−1）。

输入输出样例

输入 #1

3 3 1 1

输出 #1

0    3    2    
3    -1   1    
2    1    4    

数据规模与约定

对于全部的测试点，保证 1≤x≤n≤400，1≤y≤m≤400。

题解思路

        首先补充一点：象棋中马走日，也就是说每次走一个“日”字，如图所示，马如果初始在（x, y）处，则他有八个点可以走

好了，理解了马是怎么走的之后，我们可以开始搜索了，最好想到的其实是深搜dfs去遍历马到每个地方选取最小值，然后输出结果即可，在深搜的过程中一个关键就是如何表示马即将去的地方呢？就是一个技巧：方向数组

const int dir[8][2] = {
	{1, 2}, {1, -2}, {-1, 2}, {-1, -2},
	{2, 1}, {2, -1}, {-2, 1}, {-2, -1}
};

 这样这个二维数组中就存储了马当前位置能到达的所有位移偏移量，因此我们只需要用一个循环去表示每一个偏移量dx和dy即可。

还有一个问题需要解决，就是我们如何输出结果呢？我们可以用一个n * m的矩阵来记录所有的结果，由于有些点可能到不了，题目要求到不了的都输出-1，我们就可以把这个矩阵先全部初始化为-1，这样没标记过的自然就是-1啦~。

        好的，接下来我们就是开始深搜的过程了，直接来看代码即可：

 题解代码：

        超时代码：

#include<bits/stdc++.h>
using namespace std;

//定义方向数组
const int dir[8][2] = {
    {1, 2}, {-1, 2}, {1, -2}, {-1, -2},
    {2, -1}, {-2, 1}, {2, 1}, {-2, -1}
};
const int MAXN = 4e2 + 50;
//记录结果的矩阵
int board[MAXN][MAXN];
//判断此位置是否来过的vis数组
bool vis[MAXN][MAXN];
int n, m, x, y;

//开始深搜
void dfs(int step, int i, int j) {
    //这个点来过而且之前的步长不大于当前步长，直接返回即可（不需要继续搜索了）
    if (vis[i][j] && board[i][j] <= step) return ;
    //标记两个数组
    vis[i][j] = true, board[i][j] = step;
    //遍历枚举所有在当前点能扩展到的点
    for (int k = 0; k < 8; k++) {
        int dx = i + dir[k][0], dy = j + dir[k][1];
        //除去越界情况
        if (dx < 1 || dy < 1 || dx > n || dy > m) continue;
        //继续深搜，步长 + 1
        dfs(step + 1, dx, dy);
    }
    return ;
}

int main(){
    cin >> n >> m >> x >> y;
    //结果数组初始化成-1
    memset(board, -1, sizeof board);
    dfs(0, x, y);//开始深搜，初始步长为0，位置为(x, y)
    //遍历输出结果
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (j - 1) cout << " ";
            cout << board[i][j];
        }
        cout << endl;
    }
    return 0;
}

这样我们直接提交：

超时啦（玩毛，白讲），深搜不行怎么办，明明已经剪枝优化了呀，难道是时空发生了扭曲，洛谷开始了偏心？（说出来我都不信┭┮﹏┭┮），哦哦哦哦哦，这个题是求最短步长，那么我们直接用bfs即可啊，

类似的思路，我们改成广搜去确定最短步长：

#include<iostream>
#include<bits/stdc++.h>
using namespace std;

//定义一个Node结构体，里面包含当前点的横坐标x，纵坐标y，以及最短步长step 
struct Node { 
	//初始化函数 
	Node(int s, int x, int y) : step(s), x(x), y(y) {}
	int step, x, y;
}; 
const int dir[8][2] = {
	{1, 2}, {1, -2}, {-1, 2}, {-1, -2},
	{2, 1}, {2, -1}, {-2, 1}, {-2, -1}
};
const int MAXN = 4e2 + 10;
int board[MAXN][MAXN];
int n, m, x, y;

void bfs(int step, int i, int j) {
	//用一个队列去模拟广搜 
	queue<Node> q;
	q.push(Node(step, i, j));
	board[i][j] = step;
	//只要队列不空，我们就一直搜索扩展 
	while (!q.empty()) {
		//取出队首元素，然后弹出 
		Node node = q.front(); q.pop();
		//列出前一个队首元素node的数据 
		int a = node.x, b = node.y, s = node.step;
		//遍历扩展节点 
		for (int k = 0; k < 8; k++) {
			int dx = a + dir[k][0], dy = b + dir[k][1];
			//越界情况需要丢掉 
			if (dx < 1 || dy < 1 || dx > n || dy > m) continue;
			//之前来过的也不再考虑 
			if (board[dx][dy] != -1) continue;
			//符合条件直接入队 
			q.push(Node(s + 1, dx, dy));
			//标记结果数组 
			board[dx][dy] = s + 1;
		}
	}
	return ;
}

int main() {
	cin >> n >> m >> x >> y;
	memset(board, -1, sizeof board);
	bfs(0, x, y);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= m; j++) {
			if (j > 1) cout << " ";
			cout << board[i][j];
		}
		cout << endl;
	}
	return 0;
}

可以看到用广搜的方法就直接过啦。

总结 

        由这个题我们也可以知道，一般求最短步长这样的问题还是交给广搜吧，这样方便又安全~