洛谷P2802 回家

P2802 回家

原题连接：https://www.luogu.com.cn/problem/P2802

题目描述：

小 H 在一个划分成了 n \times mn×m 个方格的长方形封锁线上。 每次他能向上下左右四个方向移动一格（当然小 H 不可以静止不动）， 但不能离开封锁线，否则就被打死了。 刚开始时他有满血 66 点，每移动一格他要消耗 11 点血量。一旦小 H 的血量降到 00， 他将死去。 他可以沿路通过拾取鼠标（什么鬼。。。）来补满血量。只要他走到有鼠标的格子，他不需要任何时间即可拾取。格子上的鼠标可以瞬间补满，所以每次经过这个格子都有鼠标。就算到了某个有鼠标的格子才死去， 他也不能通过拾取鼠标补满 HP。 即使在家门口死去， 他也不能算完成任务回到家中。

地图上有五种格子：

0：障碍物。

1：空地， 小 H 可以自由行走。

2：小 H 出发点， 也是一片空地。

3：小 H 的家。

4：有鼠标在上面的空地。

小 H 能否安全回家？如果能， 最短需要多长时间呢？

输入格式：

第一行两个整数 n,mn,m， 表示地图的大小为 n \times mn×m。

下面 nn 行， 每行 mm 个数字来描述地图。

输出格式：

一行， 若小 H 不能回家， 输出 -1，否则输出他回家所需最短时间。

输入输出样例：

输入：
3 3
2 1 1
1 1 0
1 1 3
输出：
4

说明/提示：

对于所有数据，1 \le n,m \le 91≤n,m≤9。

2021.9.2 增添一组 hack 数据 by @囧仙

自我理解：

起初有6滴血，每走一步就会减1滴，（当减道还有1滴的时候，就不会在继续走了，因为当血量为0的时候就已经死了，不代表走到）；因为有鼠标，可以使血量立即回满，所以，每个点又可能遍历好几遍，那么就有可能会重复走，那么如何判重，怎么确定最优解呢？而此题又难以直接用是否到过一点判重，就要使用贪心的思维，我们可以将vis数组从bool型转为int型，存储目前到达它的路径中，到达它时血量最多的一次的血量。因为是bfs，所以简单的证明可以知道，如果一条路径到达一个已经到达过的点，且血量还小于等于visit时，那么即使完成了任务，其步数也不会时最优的。反之，如果到达一个点，其血量值可以更大，那么这就一种可能的路径，并不是重复到达。这样，就可以既保证了答案得正确性，又保证了不会TLE。

代码：

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

typedef pair<int, int> PII;

const int N = 10;

int n, m, x, y;
int a, b;
int d[N][N], v[N][N], g[N][N]; // g是各个点，v是血量，d是这个点离出发地的最短距离
bool flag = false; // 判断是否到达家

void bfs()
{
    queue<PII> q;
    memset(d, -1, sizeof d);
    d[x][y] = 0;
    v[x][y] = 6;
    q.push({x, y});
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    while (q.size() && !flag)
    {
        auto t = q.front();
        q.pop();
        if (v[t.first][t.second] == 1) continue; // 如果血量已经是还有1滴了，就代表不能在走了
        for (int i = 0; i < 4 ; i ++ )
        {
            int tx = dx[i] + t.first, ty = dy[i] + t.second;
            if (tx > n || tx < 1 || ty > m || ty < 1 || !g[tx][ty]) continue;
            if (v[tx][ty] < v[t.first][t.second] - 1) // 贪心思想
            {
                v[tx][ty] = v[t.first][t.second] - 1;
                d[tx][ty] = d[t.first][t.second] + 1;
                if (g[tx][ty] == 4) v[tx][ty] = 6;
                if (g[tx][ty] == 3) flag = true;
                q.push({tx, ty});
            }
        }
    }
}

int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n ; i ++ )
    {
        for (int j = 1; j <= m ; j ++ )
        {
            scanf("%d", &g[i][j]);
            if (g[i][j] == 2) x = i, y = j;
            if (g[i][j] == 3) a = i, b = j;
        }
    }
    
    bfs();
    
    if (flag) cout << d[a][b] << endl;
    else cout << "-1" << endl;
    
    return 0;
}

再来一份参考的代码：

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

typedef pair<int, int> PII;

const int N = 10;

int n, m, x, y;
int a, b;
int d[N][N], g[N][N];
bool tf = false;
int vis[N][N];

struct node
{
    int x, y, bs, hp;
}fr;

void bfs()
{
    queue<node> q;
    memset(d, -1, sizeof d);
    d[x][y] = 0;
    q.push({x, y, 0, 6});
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    vis[x][y] = 6;
    while (q.size() && !tf)
    {
        auto t = q.front();
        q.pop();
        if (t.hp == 1) continue;
        for (int i = 0; i < 4 && !tf ; i ++ )
        {
            int tx = dx[i] + t.x, ty = dy[i] + t.y;
            if (tx > n || tx < 1 || ty > m || ty < 1 || !g[tx][ty]) continue;
            if (vis[tx][ty] < t.hp - 1)
            {
                fr.x = tx;
                fr.y = ty;
                fr.bs = t.bs + 1;
                fr.hp = g[fr.x][fr.y] == 4 ? 6 : t.hp - 1;
                vis[fr.x][fr.y] = t.hp - 1;
                if (g[fr.x][fr.y] == 3) tf = true;
                q.push(fr);
            }
        }
    }
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n ; i ++ )
    {
        for (int j = 1; j <= m ; j ++ )
        {
            cin >> g[i][j];
            if (g[i][j] == 2) x = i, y = j;
            if (g[i][j] == 3) a = i, b = j;
        }
    }
    
    bfs();
    if (tf) cout << fr.bs << endl;
    else cout <<"-1" << endl;
    
    return 0;
}

太菜了，慢慢肖习！