1. 题目背景与需求分析
"P12235 [蓝桥杯 2023 国 Java A] 躲炮弹"是2023年蓝桥杯全国总决赛Java大学A组的一道编程题目。作为国内最具影响力的计算机赛事之一，蓝桥杯的国赛题目往往需要选手综合运用数据结构和算法知识解决复杂场景问题。
从题目名称可以推测，这是一道模拟类题目，可能涉及：
- 二维平面上的物体运动模拟
- 碰撞检测与路径规划
- 时间步进或事件驱动的处理逻辑
- 最优策略的数学建模
这类题目通常会给出一组运动物体的初始状态和运动规律，要求参赛者编写程序模拟整个过程，并计算出特定条件下的最优解或统计结果。对于"躲炮弹"场景，核心考察点可能包括：
- 炮弹运动轨迹的数学建模（直线/曲线运动）
- 角色移动策略的算法设计（如A*寻路、动态规划）
- 碰撞检测的优化实现（避免O(n²)暴力检测）
- 时间/空间复杂度的控制（大数据量下的性能）
2. 典型输入输出格式解析
根据蓝桥杯历年出题风格，这类题目通常会给出：
输入格式：
code复制N M T
x1 y1 vx1 vy1
...
xn yn vxn vyn
px py
其中：
- N：炮弹数量
- M：地图边界（假设为M×M的正方形区域）
- T：模拟总时长
- (xi,yi)：第i个炮弹的初始位置
- (vxi,vyi)：第i个炮弹的速度向量
- (px,py)：玩家初始位置
输出要求：
code复制k
x1 y1
...
xk yk
表示玩家在时间[0,T]内采取的移动路径，要求：
- 不被任何炮弹击中
- 路径点尽可能少（或满足其他优化条件）
3. 核心算法设计与实现
3.1 运动模型建立
炮弹的运动可采用离散时间步进模型：
java复制class Projectile {
double x, y; // 当前位置
double vx, vy; // 速度分量
void move(double dt) {
x += vx * dt;
y += vy * dt;
// 边界反弹处理
if (x <= 0 || x >= M) vx = -vx;
if (y <= 0 || y >= M) vy = -vy;
}
}
玩家移动需要考虑离散化网格（假设每秒移动1单位）：
java复制int[][] directions = {{0,1},{1,0},{0,-1},{-1,0}}; // 上下左右移动
3.2 碰撞检测优化
暴力检测O(NT)复杂度在N较大时不可行，可采用：
空间分区法：
java复制// 将地图划分为K×K的单元格
Map<Integer, List<Projectile>> spatialMap = new HashMap<>();
void updateSpatialMap() {
spatialMap.clear();
for (Projectile p : projectiles) {
int cellX = (int)(p.x / cellSize);
int cellY = (int)(p.y / cellSize);
int key = cellX * K + cellY;
spatialMap.computeIfAbsent(key, k -> new ArrayList<>()).add(p);
}
}
检测时只需检查玩家所在单元格及相邻8格的炮弹：
java复制boolean checkCollision(int x, int y) {
int cellX = x / cellSize;
int cellY = y / cellSize;
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
int key = (cellX + dx) * K + (cellY + dy);
for (Projectile p : spatialMap.getOrDefault(key, Collections.emptyList())) {
if (distance(x, y, p.x, p.y) < collisionRadius) {
return true;
}
}
}
}
return false;
}
3.3 路径搜索算法
采用改进的A*算法，启发式函数需考虑：
- 距离终点的曼哈顿距离
- 周围炮弹的密度
java复制class State implements Comparable<State> {
int x, y, time;
double cost;
// 优先队列比较规则
public int compareTo(State o) {
return Double.compare(this.cost, o.cost);
}
}
List<Point> findPath() {
PriorityQueue<State> pq = new PriorityQueue<>();
pq.add(new State(startX, startY, 0, heuristic(startX, startY)));
while (!pq.isEmpty()) {
State curr = pq.poll();
if (isGoal(curr)) return buildPath(curr);
for (int[] dir : directions) {
int nx = curr.x + dir[0];
int ny = curr.y + dir[1];
if (isValid(nx, ny) && !checkCollision(nx, ny)) {
State next = new State(nx, ny, curr.time+1,
curr.time + 1 + heuristic(nx, ny));
pq.add(next);
}
}
}
return Collections.emptyList(); // 无解
}
4. 优化策略与注意事项
4.1 时间离散化处理
将连续时间离散化为固定时间步长（如0.1秒），需要注意：
java复制double timeStep = 0.1;
for (double t = 0; t < T; t += timeStep) {
// 更新所有炮弹位置
projectiles.forEach(p -> p.move(timeStep));
// 执行路径搜索
updatePath();
}
4.2 动态规划备选方案
当A*算法性能不足时，可采用动态规划：
java复制// dp[t][x][y] 表示t时刻能否到达(x,y)
boolean[][][] dp = new boolean[T+1][M][M];
dp[0][startX][startY] = true;
for (int t = 1; t <= T; t++) {
for (int x = 0; x < M; x++) {
for (int y = 0; y < M; y++) {
if (!isSafe(x, y, t)) continue;
// 检查上一时刻的四个邻接位置
for (int[] dir : directions) {
int px = x - dir[0];
int py = y - dir[1];
if (isValid(px, py) && dp[t-1][px][py]) {
dp[t][x][y] = true;
break;
}
}
}
}
}
4.3 常见踩坑点
-
浮点数精度问题：
比较位置时使用Math.abs(x1-x2) < 1e-6而非直接==比较
-
边界条件处理：
java复制// 移动后位置修正 nx = Math.max(0, Math.min(M-1, nx)); -
性能优化技巧：
- 预计算炮弹轨迹（若运动规律简单）
- 使用位图代替二维数组存储安全区域
- 并行计算不同时间步的碰撞检测
5. 完整代码框架示例
java复制import java.util.*;
import java.awt.Point;
public class DodgeShells {
static int M, T;
static List<Projectile> projectiles = new ArrayList<>();
static class Projectile { /* 如前定义 */ }
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 读取输入
int N = sc.nextInt();
M = sc.nextInt();
T = sc.nextInt();
for (int i = 0; i < N; i++) {
projectiles.add(new Projectile(
sc.nextDouble(), sc.nextDouble(),
sc.nextDouble(), sc.nextDouble()));
}
Point start = new Point(sc.nextInt(), sc.nextInt());
List<Point> path = findSafePath(start);
// 输出结果
System.out.println(path.size());
for (Point p : path) {
System.out.println(p.x + " " + p.y);
}
}
static List<Point> findSafePath(Point start) {
// 实现路径搜索算法
return new ArrayList<>();
}
}
6. 测试用例设计建议
有效测试应包含以下场景：
-
简单直线炮弹：验证基础碰撞检测
code复制输入： 1 10 5 5 5 1 0 0 0 预期输出：路径应避开x=5的列 -
交叉火力：测试路径规划能力
code复制输入： 2 10 10 2 2 0 1 8 8 0 -1 5 5 -
性能边界：大规模输入测试
code复制输入： 1000 1000 100 (随机生成1000个炮弹) 500 500 -
无解情况：验证程序鲁棒性
code复制输入： 4 10 5 0 5 1 0 10 5 -1 0 5 0 0 1 5 10 0 -1 5 5 预期输出：0 (表示无解)
在实际比赛中，建议先手工计算小规模用例验证算法正确性，再逐步扩展到复杂场景。对于Java实现，要特别注意堆内存设置（-Xmx）避免超出限制。