hdu 5433 Xiao Ming climbing （BFS+dp）

题意：

小明因为受到大魔王的诅咒，被困到了一座荒无人烟的山上并无法脱离。这座山很奇怪:
这座山的底面是矩形的，而且矩形的每一小块都有一个特定的坐标$(x,y)$和一个高度$H$。
为了逃离这座山，小明必须找到大魔王，并消灭它以消除诅咒。
小明一开始有一个斗志值$k$，如果斗志为0则无法与大魔王战斗，也就意味着失败。
小明每一步都能从他现在的位置走到他的$(N,E,S,W)$四个位置中的一个,会消耗$(abs(H​1​​−H​2​​))/k$的体力，每走一步消耗一点斗志。
大魔王很强大，为了留下尽可能多的体力对付大魔王，小明需要找到一条消耗体力最少的路径。
你能帮助小明算出最少需要消耗的体力吗。

解析：

直接BFS，用$dp[x][y][d]$表示到达$(x,y)$通过$K-d$步所需要消耗的最少体力
到达任意一点$(x,y)$，且活力值为dd时，仅当消耗体力小于$dp[x][y][d]$时继续更新
注意当$K = 0$时，无论如何都是No Answer
同时，起点和终点可以重合，当$K != 0$时 消耗体力为$0.00$

$my$ $code$

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
#include <cstdlib>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int INF = (1<<31) - 1;
const double eps = 1e-9;
const int N = 55;
char grid[N][N];
int n, m, K;

struct Node {
    int x, y;
    double val;
    int k;
    bool operator < (const Node& rhs) const {
        return val > rhs.val;
    }
};

bool bound(int x, int y) {
    if(x >= 0 && x < n && y >= 0 && y < m && grid[x][y] != '#')
        return true;
    return false;
}

double d[N][N][N];
double bfs(int x1, int y1, int x2, int y2) {
    if(x1 == x2 && y1 == y2) {
        if(K == 0) return INF;
        else return 0;
    }

    for(int i = 0; i < n; i++)
        for(int j = 0; j < m; j++)
            for(int k = 0; k <= K; k++) {
                d[i][j][k] = INF;
            }

    d[x1][y1][K] = 0;
    priority_queue<Node> que;
    que.push((Node){x1, y1, 0, K});

    int x, y, nx, ny, k;
    while(!que.empty()) {
        Node node = que.top(); que.pop();
        if(node.k <= 0)
            continue;
        x = node.x, y = node.y, k = node.k;
        for(int i = 0; i < 4; i++) {
            nx = x + dx[i], ny = y + dy[i];
            if(bound(nx, ny)) {
                int h1 = (grid[x][y] - '0');
                int h2 = (grid[nx][ny] - '0');
                double val = abs(h1 - h2) * 1.0 / k;
                if(d[nx][ny][k-1] > d[x][y][k] + val) {
                    d[nx][ny][k-1] = d[x][y][k] + val;
                    que.push((Node){nx, ny, d[nx][ny][k], k - 1});
                }
            }
        }
    }

    double ret = INF;
    for(int i = 1; i <= K; i++)
        ret = min(d[x2][y2][i], ret);
    return ret;
}

int main() {
    int T;
    int x1, y1, x2, y2;
    scanf("%d", &T);
    while(T--) {
        scanf("%d%d%d", &n, &m, &K);
        for(int i = 0; i < n; i++)
            scanf("%s", grid[i]);

        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        x1--, y1--; x2--, y2--;

        double ans = bfs(x1, y1, x2, y2);
        if(fabs(ans - INF) < eps) puts("No Answer");
        else printf("%.2lf\n", ans);
    }
    return 0;
}