UVa 10794 The Deadly Olympic Returns

题目描述

现在是公元 $10000$ 年。在本题中，我们将讨论一个名为"奥林匹克"的全球性游戏节的恢复，该活动很久以前（二十世纪）曾经举办过。新成立的国际奥林匹克委员会 ($\text{IOC}$) 引入了一种类似狗斗的战争格式：双方将带来各自国家空军提供的最佳战机，并装载导弹。在某个时刻，一方会向另一方发射导弹。同时，另一方也会发射导弹以拦截对方的导弹。解说员想在比赛发生前预测结果，他们需要计算两枚导弹之间的最小可能距离。

输入格式：

• 第一行：整数 $T$ ($1\le T\le 500$) 表示测试用例数量
• 每个测试用例有三行：
  1. 正整数 $time$
  2. 六个整数 $x_1$, $y_1$, $z_1$, $x_2$, $y_2$, $z_2$ - 第一枚导弹的起点和终点
  3. 六个整数 $x_3$, $y_3$, $z_3$, $x_4$, $y_4$, $z_4$ - 第二枚导弹的起点和终点

输出格式：

• 每个测试用例输出一行：Case i: distance，其中 distance 保留四位小数

样例：

输入：
2
1
0 0 0 1 0 0
0 -1 0 0 -2 0
4
0 0 0 1 0 0
-1 0 0 -2 0 0

输出：
Case 1: 1.0000
Case 2: 1.0000

题目分析

问题本质

本题要求计算两枚在三维空间中匀速直线运动的导弹之间的最小距离。这是计算几何中的一个经典问题：求两条线段之间的最小距离。

每枚导弹的运动可以用参数方程表示：

• 第一枚导弹：$\mathbf{A}(t)={\mathbf{P}}_1+{\mathbf{v}}_1\cdot t$
• 第二枚导弹：$\mathbf{B}(t)={\mathbf{P}}_2+{\mathbf{v}}_2\cdot t$

其中：

• ${\mathbf{P}}_1=(x_1,y_1,z_1)$, ${\mathbf{P}}_2=(x_3,y_3,z_3)$ 是起点
• ${\mathbf{v}}_1=\frac{(x_2-x_1,y_2-y_1,z_2-z_1)}{time}$, ${\mathbf{v}}_2=\frac{(x_4-x_3,y_4-y_3,z_4-z_3)}{time}$ 是速度向量
• $t\in [0,time]$ 是时间参数

我们需要计算：$\underset{t\in [0,time]}{\min }\Vert \mathbf{A}(t)-\mathbf{B}(t)\Vert$

数学推导

设相对位置向量为：
$\mathbf{R}(t)=\mathbf{B}(t)-\mathbf{A}(t)=({\mathbf{P}}_2-{\mathbf{P}}_1)+({\mathbf{v}}_2-{\mathbf{v}}_1)\cdot t$

距离的平方为：
$D^2(t)=\Vert \mathbf{R}(t){\Vert }^2=\Vert \mathbf{P}+\mathbf{V}\cdot t{\Vert }^2$

其中：

• $\mathbf{P}={\mathbf{P}}_2-{\mathbf{P}}_1$（初始相对位置）
• $\mathbf{V}={\mathbf{v}}_2-{\mathbf{v}}_1$（相对速度）

展开得：
$D^2(t)=(\mathbf{V}\cdot \mathbf{V})t^2+2(\mathbf{P}\cdot \mathbf{V})t+(\mathbf{P}\cdot \mathbf{P})$

这是一个关于 $t$ 的二次函数，开口向上（因为 $\mathbf{V}\cdot \mathbf{V}\ge 0$）。最小值可能出现在：

1. 区间内部：$t_0=-\frac{\mathbf{P}\cdot \mathbf{V}}{\mathbf{V}\cdot \mathbf{V}}$（当 $\mathbf{V}\cdot \mathbf{V}\ne 0$）
2. 区间端点：$t=0$ 或 $t=time$

更巧妙的解法：相对运动参考系

AC 代码使用了一个更巧妙的解法：变换参考系。

如果让第一枚导弹变为静止，那么问题就转化为：求一个固定点（第一枚导弹）到一条动直线（第二枚导弹的相对轨迹）的最短距离。

在新的参考系中：

• 第一枚导弹位置为原点 $(0,0,0)$
• 第二枚导弹的轨迹为：$\mathbf{R}(t)=\mathbf{P}+\mathbf{V}\cdot t$
• 其中 $\mathbf{P}={\mathbf{P}}_2-{\mathbf{P}}_1$，$\mathbf{V}={\mathbf{v}}_2-{\mathbf{v}}_1$

这样，最小距离就等于原点到直线 $\mathbf{R}(t)$ 的距离。

点到直线的距离公式为：
$d=\frac{\Vert \mathbf{P}\times \mathbf{V}\Vert }{\Vert \mathbf{V}\Vert }$

其中 $\times$ 表示向量叉积。

推导：
点到直线上任意点的向量为 $\mathbf{P}+\mathbf{V}t$，其长度平方为：
$f(t)=\Vert \mathbf{P}+\mathbf{V}t{\Vert }^2=\Vert \mathbf{P}{\Vert }^2+2(\mathbf{P}\cdot \mathbf{V})t+\Vert \mathbf{V}{\Vert }^2{t}^2$

最小值在 $t_0=-\frac{\mathbf{P}\cdot \mathbf{V}}{\Vert \mathbf{V}{\Vert }^2}$ 处取得，此时：
$f(t_0)=\Vert \mathbf{P}{\Vert }^2-\frac{(\mathbf{P}\cdot \mathbf{V}{)}^2}{\Vert \mathbf{V}{\Vert }^2}$

根据向量恒等式 $\Vert \mathbf{a}\times \mathbf{b}{\Vert }^2=\Vert \mathbf{a}{\Vert }^2\Vert \mathbf{b}{\Vert }^2-(\mathbf{a}\cdot \mathbf{b}{)}^2$，得：
$f(t_0)=\frac{\Vert \mathbf{P}\times \mathbf{V}{\Vert }^2}{\Vert \mathbf{V}{\Vert }^2}$

所以 $d=\sqrt{f(t_0)}=\frac{\Vert \mathbf{P}\times \mathbf{V}\Vert }{\Vert \mathbf{V}\Vert }$

特殊情况处理

1. 相对速度为零（$\mathbf{V}=0$）：两导弹相对静止，距离为常数 $\Vert \mathbf{P}\Vert$
2. 点在直线上：距离为 $0$
3. 投影点在直线起点之前（$t_0\le 0$）：最小距离出现在 $t=0$，即 $\Vert \mathbf{P}\Vert$
4. 投影点在直线终点之后（$t_0\ge time$）：需要考虑 $t=time$ 的情况

在实际实现中，我们只需要使用点到直线的距离公式，它会自动处理这些情况。

解题思路

算法步骤

1. 读取输入：对于每个测试用例，读取时间 $time$ 和两枚导弹的起点终点坐标
2. 计算速度向量：
   • ${\mathbf{v}}_1=({\mathbf{P}}_1^{\mathbf{end}}-{\mathbf{P}}_1^{\mathbf{start}})/time$
   • ${\mathbf{v}}_2=({\mathbf{P}}_2^{\mathbf{end}}-{\mathbf{P}}_2^{\mathbf{start}})/time$
3. 计算相对向量：
   • $\mathbf{P}={\mathbf{P}}_2^{\mathbf{start}}-{\mathbf{P}}_1^{\mathbf{start}}$（初始相对位置）
   • $\mathbf{V}={\mathbf{v}}_2-{\mathbf{v}}_1$（相对速度）
4. 计算点到直线的距离：
   • 如果 $\Vert \mathbf{V}{\Vert }^2$ 接近 $0$，返回 $\Vert \mathbf{P}\Vert$
   • 否则，计算 $d=\frac{\Vert \mathbf{P}\times \mathbf{V}\Vert }{\Vert \mathbf{V}\Vert }$
5. 输出结果，保留四位小数

时间复杂度

每个测试用例只需常数次向量运算，时间复杂度为 $O(1)$，总复杂度为 $O(T)$，其中 $T\le 500$，完全可行。

空间复杂度

只需存储几个三维向量，空间复杂度为 $O(1)$。

注意事项

1. 精度问题：使用 double 类型，比较时使用适当的 epsilon（如 $10^{-12}$）
2. 除以零：当相对速度为零时，需要特殊处理
3. 输出格式：严格按照要求输出，包括 "Case i: " 和四位小数

代码实现

// The Deadly Olympic Returns
// UVa ID: 10794
// Verdict: Accepted
// Submission Date: 2025-12-17
// UVa Run Time: 0.000s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

// 三维点/向量结构体
struct Point3D {
    double x, y, z;
    Point3D(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
    
    // 从输入读取坐标
    void read() { cin >> x >> y >> z; }
    
    // 向量加法
    Point3D operator+(const Point3D& other) const {
        return Point3D(x + other.x, y + other.y, z + other.z);
    }
    
    // 向量减法
    Point3D operator-(const Point3D& other) const {
        return Point3D(x - other.x, y - other.y, z - other.z);
    }
    
    // 向量数乘
    Point3D operator*(double scalar) const {
        return Point3D(x * scalar, y * scalar, z * scalar);
    }
    
    // 向量数除
    Point3D operator/(double scalar) const {
        return Point3D(x / scalar, y / scalar, z / scalar);
    }
};

// 计算向量的点积
double dotProduct(const Point3D& a, const Point3D& b) {
    return a.x * b.x + a.y * b.y + a.z * b.z;
}

// 计算向量的叉积
Point3D crossProduct(const Point3D& a, const Point3D& b) {
    return Point3D(
        a.y * b.z - a.z * b.y,   // x分量
        a.z * b.x - a.x * b.z,   // y分量
        a.x * b.y - a.y * b.x    // z分量
    );
}

// 计算向量长度的平方
double lengthSquared(const Point3D& v) {
    return dotProduct(v, v);
}

// 计算向量长度
double length(const Point3D& v) {
    return sqrt(lengthSquared(v));
}

// 计算点p到通过点a方向为dir的直线的距离
double pointToLineDistance(const Point3D& p, const Point3D& a, const Point3D& dir) {
    // 如果方向向量长度为0，退化为点到点的距离
    if (lengthSquared(dir) < 1e-12) {
        return length(p - a);
    }
    
    // 向量ap = p - a
    Point3D ap = p - a;
    
    // 计算投影长度比例 t = (ap·dir) / (dir·dir)
    // 但这里我们不需要计算t，直接使用距离公式
    // 距离² = |ap|² - (ap·dir)²/|dir|²
    double distSquared = lengthSquared(ap) - pow(dotProduct(ap, dir), 2) / lengthSquared(dir);
    
    // 防止由于浮点误差导致的负数
    return sqrt(max(0.0, distSquared));
}

int main() {
    // 优化输入输出
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int t;
    cin >> t;
    
    // 设置输出精度：保留4位小数
    cout << fixed << setprecision(4);
    
    for (int caseNo = 1; caseNo <= t; caseNo++) {
        double time;
        cin >> time;
        
        // 读取两枚导弹的起点和终点
        Point3D p1Start, p1End, p2Start, p2End;
        p1Start.read(); p1End.read();
        p2Start.read(); p2End.read();
        
        // 计算速度向量 = (终点 - 起点) / 时间
        Point3D v1 = (p1End - p1Start) / time;
        Point3D v2 = (p2End - p2Start) / time;
        
        // 相对运动：让第一枚导弹静止
        // 相对速度 = v2 - v1
        // 初始相对位置 = p2Start - p1Start
        Point3D relativeVelocity = v2 - v1;
        Point3D relativeStart = p2Start - p1Start;
        
        // 现在问题转化为：求原点(0,0,0)到直线的距离
        // 直线方程：L(t) = relativeStart + relativeVelocity * t
        double minDistance = pointToLineDistance(
            Point3D(0, 0, 0),  // 原点（第一枚导弹位置）
            relativeStart,      // 直线的起点
            relativeVelocity    // 直线的方向
        );
        
        // 输出结果
        cout << "Case " << caseNo << ": " << minDistance << endl;
    }
    
    return 0;
}

总结

本题是一个典型的三维计算几何问题，关键在于：

1. 理解相对运动：通过参考系变换，将动态问题转化为静态问题
2. 掌握向量运算：点积、叉积、向量长度等基本操作
3. 应用点到直线距离公式：$\frac{\Vert \mathbf{a}\times \mathbf{b}\Vert }{\Vert \mathbf{b}\Vert }$

算法的时间复杂度和空间复杂度都很低，适合处理 $T\le 500$ 的测试数据。代码实现时需要注意浮点数精度和特殊情况处理。