机试题——小明踢足球

题目描述

小明在一个足球场上踢球，需要绕过障碍物把球踢到球门里。足球场用大小为 ( M * M ) 的正方形网格表示，其中每个元素可以是以下几种类型：

• 'X'：小明的初始位置，球场上只有一个。
• '0'：空地，可以在上面自由行走。
• '1'：障碍物，不能通行。
• 'B'：足球，球场上只有一个。
• 'G'：球门，球场上只有一个。

小明的移动规则如下：

1. 初始时，小明和球可能不相邻。小明需要先走到球的位置才能开始踢球。
2. 当小明移动到球的相邻格子后，继续向球的方向移动，会将球踢到同方向相邻的格子。
3. 如果球移动前方会碰到障碍物或边界，踢球无效，小明和球的位置保持不变。

目标是计算小明把球踢到球门里需要踢球的最少次数。如果无法踢到球门，返回 -1。

输入描述

输入第一行是一个正整数 ( M )（( 5 \leq M \leq 20 )）。

接下来是一个 ( M \times M ) 的矩阵，每行包含 ( M ) 个字符，字符可以是 '0'、'1'、'B'、'G' 或 'X'。

输出描述

返回小明把球踢到球门里需要踢球的最少次数。如果无法踢到球门，返回 -1。

用例输入

输入：

5
0 0 0 0 0
0 0 0 0 G
0 0 B 0 0
X 1 0 0 0
0 0 0 0 0

输出：

3

说明：
小明把球踢到球门里最少需要踢 3 次球。

解题思路

问题分析

1. 目标：计算小明把球踢到球门里需要踢球的最少次数。
2. 关键点：
   • 小明需要先走到球的位置才能开始踢球。
   • 踢球时，球的移动方向必须与小明的移动方向相同。
   • 如果球移动前方会碰到障碍物或边界，踢球无效。
   • 使用广度优先搜索（BFS）来寻找最短路径。

算法设计

1. 数据结构：

   • 使用二维数组 mp 存储足球场的布局。
   • 使用四维数组 dis 存储从初始状态到当前状态的最少踢球次数。
   • 使用队列 q 存储当前状态，每个状态包含小明的位置和球的位置。

2. 初始化：

   • 读取输入，找到小明、球和球门的位置。
   • 初始化 dis 数组，所有值设为 -1，表示未访问。

3. 广度优先搜索（BFS）：

   • 从初始状态开始，将小明和球的位置加入队列。
   • 每次从队列中取出一个状态，尝试向四个方向移动。
   • 如果移动到球的相邻位置，尝试踢球，更新球的位置。
   • 如果球移动到球门位置，记录踢球次数并返回。
   • 如果移动到非障碍物位置，更新小明的位置，但球的位置不变。
   • 将新状态加入队列，继续搜索。

4. 结果计算：

   • 如果找到球门，返回最少踢球次数。
   • 如果队列为空且未找到球门，返回 -1。

代码实现

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<map>
#include<algorithm>
#include<string>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<queue>
#include<set>
#include<list>
#include<sstream>
#include<bitset>
#include<stack>
#include<climits>
#include<iomanip>
#include<cstdint>
using namespace std;
int n;
int fe, fd;// 起始位置
int se, sd;// 足球位置
int ee, ed;// 结束位置
int dx[] = { 0, 0, 1, -1 };
int dy[] = { 1, -1, 0, 0 };
char mp[30][30];
int dis[50][50][50][50];// 人物位置和球的位置
int bfs() {
    queue<vector<int>> q;
    q.push({ fe,fd,se,sd });
    dis[fe][fd][se][sd] = 0;
    int res = -1;
    while (!q.empty()) {
        // 当前人物状态
        int cx = q.front()[0];
        int cy = q.front()[1];
        // 当前足球状态
        int fx = q.front()[2];
        int fy = q.front()[3];
        q.pop();
        for (int i = 0; i < 4; i++) {
            int nx = cx + dx[i], ny = cy + dy[i]; // 计算新的位置
            if (nx < 0 || nx >= n || ny < 0 || ny >= n || mp[nx][ny] == '1') continue;
            if (nx == fx && ny == fy) {
                // 尝试踢球
                int nfx = fx + dx[i], nfy = fy + dy[i]; // 计算踢球后新的球位置
                if (nfx < 0 || nfx >= n || nfy < 0 || nfy >= n || mp[nfx][nfy] == '1') continue;
                if (dis[nx][ny][nfx][nfy] == -1) {
                    dis[nx][ny][nfx][nfy] = dis[cx][cy][fx][fy] + 1; // 更新距离
                    q.push({ nx, ny, nfx, nfy }); // 将新状态入队
                    if (nfx == ee && nfy == ed) { // 如果球已经进了球门
                        if (res== -1 || res > dis[nx][ny][nfx][nfy]) {
                            res = dis[nx][ny][nfx][nfy]; // 更新最短路径
                        }
                    }
                }
            }
            else {// 球没动
                if (dis[nx][ny][fx][fy] == -1) { 
                    dis[nx][ny][fx][fy] = dis[cx][cy][fx][fy]; // 保持距离不变
                    q.push({ nx, ny, fx, fy });
                }
            }
        }
    }
    return res;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> n;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> mp[i][j];
            if (mp[i][j] == 'B') {
                se = i, sd = j;
            }
            if (mp[i][j] == 'G') {
                ee = i, ed = j;
            }
            if (mp[i][j] == 'X') {
                fe = i, fd = j;
            }
        }
    }
    memset(dis, -1, sizeof(dis));
    cout<<bfs();
}