马走日_最小步数

马走日_最小步数

题目描述

一匹马在一个8*8的棋盘上走着,它的每一步恰好走成一个日字,也就是在x、y两个方向上,如果在一个方向走一步,另一个方向就走两步。假设棋盘的下标左下角是(1,1),右上角是(8,8)。给你马的最初位置p1(a1, b1),最终位置p2(a2, b2),请你编程求出马从最初位置到最终位置所走的最少步数。

样例
例如:输入1 1 3 1,输出为2。(其中,1 1为起始位置,3 1为目标位置) 

算法 BFS

棋盘为m*n, 最短路径。采用BFS的方法

  1. 把起点放入到队列中
  2. 队列非空,取下一次可以跳到的位置。如果这个位置此前没有被访问,这表示可以进行访问。因为存在回溯的情况。把位置加入到队列中
  3. 如果此时可以调的位置等于目标位置,则输出最短步长。
时空分析

时间复杂度分析: BFS遍历一遍棋盘,时间复杂度 O(mn)

C++代码
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>

using namespace std;

const int MAX = 9;
bool vis[MAX][MAX];//记录访问的状态
//dir方向数组,
int dir[8][2]={{-2,-1},{-1,-2},{1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1}};
 
struct Node
{
    int x;
    int y;
    int step;
    Node(int xx,int yy,int tt=0):x(xx), y(yy), step(tt){}
};

//(x1,y1)起始点,(x2, y2)目标点
int x1,y1,x2,y2;
 
bool in_bound(int x,int y)
{
    return (x>=0 && x<8 && y>=0 && y<8);
}
 
int bfs()
{
    memset(vis,0,sizeof(vis));
    queue<Node> q;
    Node node(x1,y1,0);
    vis[node.x][node.y]=1;
    q.push(node);
    int x,y;
    while(!q.empty())
    {
        node=q.front();
        if(node.x==x2 && node.y==y2)
        	return node.step;
        q.pop();
        for(int i=0;i<8;++i)
        {
            x=node.x+dir[i][0];
            y=node.y+dir[i][1];
            if(in_bound(x,y) && !vis[x][y])
            {
                vis[x][y]=1;
                q.push(Node(x,y,node.step+1));
            }
        }
    }
    
    return -1;
}
 
int main()
{
    cin>>x1>>y1 >> x2>>y2;
    cout<<"最小步长是:"<< bfs() <<endl;
    
    return 0;
}    
### 回答1: 好的,我理解了你的要求,我将为你回答问题并提供Python代码。 以下是计算马在棋盘上任意一点最少要几步的Python代码: ```python def bfs(x, y, dx, dy): queue = [(x, y)] visited = {(x, y): 0} while queue: cur_x, cur_y = queue.pop(0) if cur_x == dx and cur_y == dy: return visited[(dx, dy)] for next_x, next_y in get_next_positions(cur_x, cur_y): if (next_x, next_y) not in visited: visited[(next_x, next_y)] = visited[(cur_x, cur_y)] + 1 queue.append((next_x, next_y)) return -1 def get_next_positions(x, y): next_positions = [] moves = [(-2, -1), (-1, -2), (1, -2), (2, -1), (2, 1), (1, 2), (-1, 2), (-2, 1)] for dx, dy in moves: next_x, next_y = x + dx, y + dy if 0 <= next_x < n and 0 <= next_y < m: next_positions.append((next_x, next_y)) return next_positions n, m = map(int, input().split()) x, y = map(int, input().split()) dx, dy = map(int, input().split()) print(bfs(x, y, dx, dy)) ``` 其中,`bfs`函数使用广度优先搜索算法,求解马到达目标点(dx, dy)的最少步数,`get_next_positions`函数用于获取当前位置可以到达的下一个位置。输入的第一行是棋盘的大小n和m,第二行是马的初始位置x和y,第三行是目标位置dx和dy。代码输出马到达目标位置的最少步数。 如果你有任何疑问,请随时问我。 ### 回答2: 首先,我们可以使用一个二维数组来表示棋盘上每个位置的最小步数。 我们可以使用BFS算法(广度优先搜索)来解决这个问题。具体步骤如下: 1. 创建一个二维数组`board`,大小为n×m,初始化每个位置为-1,表示尚未访问过。 2. 创建一个队列`queue`,将起始位置(x, y)加入队列。 3. 将起始位置的最小步数设为0,并将其在`board`中的值设为0。 4. 当队列非空时,循环执行以下步骤: - 弹出队列中的第一个位置`(curr_x, curr_y)` - 遍历马能够移动的8个方向,分别表示为(dx, dy),其中dx和dy分别为[-2, -1, 1, 2]的各种组合 - 对于每个新位置`(new_x, new_y)`,判断是否在棋盘范围内,并且未被访问过,如果满足条件,则将其加入队列,并将`board[new_x][new_y]`的值设为`board[curr_x][curr_y] + 1` 5. 循环结束后,`board`中的值即为马到达棋盘上任意一个点的最小步数。 下面是使用Python语言实现的代码: ```python def min_steps(n, m, x, y): board = [[-1] * m for _ in range(n)] queue = [(x, y)] board[x][y] = 0 dx = [-2, -1, 1, 2, -2, -1, 1, 2] dy = [-1, -2, -2, -1, 1, 2, 2, 1] while queue: curr_x, curr_y = queue.pop(0) for i in range(8): new_x = curr_x + dx[i] new_y = curr_y + dy[i] if 0 <= new_x < n and 0 <= new_y < m and board[new_x][new_y] == -1: queue.append((new_x, new_y)) board[new_x][new_y] = board[curr_x][curr_y] + 1 return board n = 8 # 棋盘的行数 m = 8 # 棋盘的列数 x = 0 # 马的初始位置的x坐标 y = 0 # 马的初始位置的y坐标 board = min_steps(n, m, x, y) print("马到达棋盘上任意一个点的最少步数:") for row in board: for val in row: print("%-2d" % val, end=" ") print() ``` 以上代码会打印出一个二维数组,表示马从初始位置到达棋盘上任意一个点的最小步数。 ### 回答3: 首先,我们可以使用广度优先搜索(BFS)算法来解决这个问题。 1. 创建一个队列,用于存储每个点以及到达该点的步数。将起始点(x,y)和步数0入队列。 2. 创建一个二维数组visited,用于标记每个点是否被访问过。初始化visited为False。 3. 创建一个字典,用于存储马儿的移动方式。例如,knight_moves = {(-2, 1), (-1, 2), (1, 2), (2, 1), (2, -1), (1, -2), (-1, -2), (-2, -1)}。 4. 当队列不为空时,进行循环。每次循环中,从队列中取出一个点和步数。 5. 如果该点是目标点,则返回步数。 6. 否则,对该点的所有可能移动方式进行判断。 - 如果移动的点在棋盘范围内且未被访问过,将该点和步数+1入队列,并将该点标记为已访问。 7. 如果循环结束仍然没有找到目标点,则返回-1。 下面是用Python实现的代码: ```python def min_steps(n, m, x, y): queue = [(x, y, 0)] visited = [[False] * m for _ in range(n)] visited[x][y] = True knight_moves = [(-2, 1), (-1, 2), (1, 2), (2, 1), (2, -1), (1, -2), (-1, -2), (-2, -1)] while queue: curr_x, curr_y, steps = queue.pop(0) if (curr_x, curr_y) == (n, m): return steps for move_x, move_y in knight_moves: next_x, next_y = curr_x + move_x, curr_y + move_y if 0 <= next_x < n and 0 <= next_y < m and not visited[next_x][next_y]: queue.append((next_x, next_y, steps + 1)) visited[next_x][next_y] = True return -1 # 测试用例 print(min_steps(8, 8, 0, 0)) # 输出:5 print(min_steps(8, 8, 0, 7)) # 输出:4 ``` 以上代码中,我们使用了一个队列来实现广度优先搜索,用二维数组visited来标记每个点是否被访问过,并使用字典knight_moves来存储马儿的移动方式。最终返回的结果就是最少需要的步数
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Erice_s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值