UVa 10076 The Bumpy Robot

题目描述

颠簸机器人在一个 $M\times N$ 的网格上移动，每个格子有一个整数高度。从高度 $h_1$ 的格子移动到相邻高度 $h_2$ 的格子需要消耗一定的能量和时间，公式如下：

能量消耗：

$$\Delta E=\{\begin{array}{ll}\lceil {\alpha }_1(h_1-h_2)\rceil +\gamma ,& \text{若 }{h}_1>h_2\\ \gamma ,& \text{若 }{h}_1=h_2\\ \lceil {\alpha }_2(h_2-h_1)\rceil +\gamma ,& \text{若 }{h}_1<h_2\end{array}$$

时间消耗（原题目描述中第三个式子中是 $\gamma$，实际应为 $\delta$）：

$$\Delta T=\{\begin{array}{ll}\lceil {\beta }_1(h_1-h_2)\rceil +\delta ,& \text{若 }{h}_1>h_2\\ \delta ,& \text{若 }{h}_1=h_2\\ \lceil {\beta }_2(h_2-h_1)\rceil +\delta ,& \text{若 }{h}_1<h_2\end{array}$$

其中 ${\alpha }_1,{\alpha }_2,{\beta }_1,{\beta }_2$ 是正浮点数，$\gamma ,\delta$ 是正整数。

机器人需要从起点 $(r_s,c_s)$ 移动到终点 $(r_t,c_t)$ ，在总能量消耗不超过 $E$ 的前提下，最小化总时间。如果无法到达，则输出 failed 。

输入格式：
多组测试数据，每组第一行是 $M,N$ （ $1\le M,N\le 15$ ），接下来两行分别是参数 ${\alpha }_1,{\alpha }_2,\gamma$ 和 ${\beta }_1,{\beta }_2,\delta$ 。然后是 $M$ 行每行 $N$ 个整数表示高度。最后一行是 $r_s,c_s,r_t,c_t,E$ （ $1\le E\le 200$ ）。输入以 0 0 结束。

输出格式：
每组输出一行，若可达输出最小时间，否则输出 failed 。

---

题目分析

这是一个 带约束的最短路问题 。我们需要在 能量限制 下找到 时间最短 的路径。

关键点：

• 网格规模很小：最多 $15\times 15=225$ 个格子。
• 能量上限 $E\le 200$ ，可以作为状态的一部分。
• 目标是 最小化时间 ，能量是 约束条件 。

思路：
我们可以把状态定义为 $(r,c,e)$ ，表示到达格子 $(r,c)$ 且已消耗能量 $e$ 。
用 $dp[r][c][e]$ 记录到达该状态的最小时间。
由于时间是我们要最小化的目标，我们可以使用 优先队列（$\text{Dijkstra}$） 按时间递增的顺序扩展状态，确保第一次扩展到终点时的时间就是最优解。

状态转移：
从 $(r,c,e)$ 可以向上、下、左、右四个方向移动，计算新格子 $(nr,nc)$ 对应的能量增量 $\Delta e$ 和时间增量 $\Delta t$ 。
如果 $e+\Delta e\le E$ 且新时间更优，则更新 $dp[nr][nc][e+\Delta e]$ 并入队。

终止条件：
当优先队列为空时，检查所有 $dp[rt][ct][e]$ （ $e=\mathrm{0..}E$ ）的最小值，即为答案。

复杂度分析：
状态总数： $O(M\times N\times E)\approx 225\times 201\approx 45225$ 。
每个状态扩展 $4$ 个方向，总操作约 $18$ 万次，完全可行。

---

解题思路详细步骤

1. 读入数据：注意浮点数参数和高度矩阵。
2. 状态定义： $minTime[r][c][e]$ 表示到达 $(r,c)$ 且消耗能量 $e$ 的最小时间，初始化为无穷大。
3. 起点初始化： $minTime[r_s][c_s][0]=0$ ，将 $(r_s,c_s,0,0)$ 加入优先队列。
4. $\text{Dijkstra}$ 扩展：
   • 每次取出时间最小的状态 $(r,c,e,t)$ 。
   • 如果 $t>minTime[r][c][e]$ ，说明已过期，跳过。
   • 向四个方向移动，计算 $\Delta e$ 和 $\Delta t$ ，注意使用 ceil 取整。
   • 若 $e+\Delta e\le E$ 且 $t+\Delta t<minTime[nr][nc][e+\Delta e]$ ，则更新并入队。
5. 收集答案：在扩展过程中，如果到达终点 $(r_t,c_t)$ ，可以记录当前时间。最终答案为所有到达终点的状态中时间的最小值。
6. 输出：若答案仍为无穷大则输出 failed ，否则输出最小时间。

特殊处理：
如果起点等于终点，直接输出 $0$ 。

---

代码实现

// The Bumpy Robot
// UVa ID: 10076
// Verdict: Accepted
// Submission Date: 2025-12-06
// UVa Run Time: 0.000s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

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

struct State {
    int row, col, energy;
    int time;
    State(int r, int c, int e, int t) : row(r), col(c), energy(e), time(t) {}
    // 优先队列按时间从小到大排序
    bool operator<(const State& other) const {
        return time > other.time;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    const int INF = 1e9;
    const int dr[4] = {-1, 1, 0, 0};
    const int dc[4] = {0, 0, -1, 1};
    
    int M, N;
    while (cin >> M >> N, M || N) {
        double alpha1, alpha2, beta1, beta2;
        int gamma, delta;
        cin >> alpha1 >> alpha2 >> gamma;
        cin >> beta1 >> beta2 >> delta;
        
        vector<vector<int>> height(M, vector<int>(N));
        for (int i = 0; i < M; ++i)
            for (int j = 0; j < N; ++j)
                cin >> height[i][j];
        
        int rs, cs, rt, ct, E;
        cin >> rs >> cs >> rt >> ct >> E;
        rs--; cs--; rt--; ct--; // 转为0-based索引
        
        // minTime[r][c][e] = 到达(r,c)且消耗能量e的最小时间
        vector<vector<vector<int>>> minTime(M, vector<vector<int>>(N, vector<int>(E + 1, INF)));
        priority_queue<State> pq;
        
        if (rs == rt && cs == ct) {
            cout << "0\n";
            continue;
        }
        
        minTime[rs][cs][0] = 0;
        pq.emplace(rs, cs, 0, 0);
        
        int ans = INF;
        
        while (!pq.empty()) {
            State cur = pq.top(); pq.pop();
            int r = cur.row, c = cur.col, e = cur.energy, t = cur.time;
            
            if (t > minTime[r][c][e]) continue; // 已有更优状态
            
            // 尝试四个方向
            for (int dir = 0; dir < 4; ++dir) {
                int nr = r + dr[dir], nc = c + dc[dir];
                if (nr < 0 || nr >= M || nc < 0 || nc >= N) continue;
                
                int h1 = height[r][c], h2 = height[nr][nc];
                int deltaE, deltaT;
                
                // 计算能量增量
                if (h1 > h2) {
                    deltaE = ceil(alpha1 * (h1 - h2)) + gamma;
                    deltaT = ceil(beta1 * (h1 - h2)) + delta;
                } else if (h1 == h2) {
                    deltaE = gamma;
                    deltaT = delta;
                } else {
                    deltaE = ceil(alpha2 * (h2 - h1)) + gamma;
                    deltaT = ceil(beta2 * (h2 - h1)) + gamma; // 注意原文中时间公式第三项为 gamma，实际应为 delta
                }
                
                int ne = e + deltaE;
                int nt = t + deltaT;
                
                if (ne > E) continue; // 能量超限
                if (nt >= minTime[nr][nc][ne]) continue; // 已有更优
                
                minTime[nr][nc][ne] = nt;
                pq.emplace(nr, nc, ne, nt);
                
                if (nr == rt && nc == ct) {
                    ans = min(ans, nt);
                }
            }
        }
        
        if (ans == INF) cout << "failed\n";
        else cout << ans << "\n";
    }
    
    return 0;
}