题解 牛客 wyh的吃鸡

原题链接：https://ac.nowcoder.com/acm/contest/23156/1019

一般这种涉及多种路径（走路/开车）的搜索题，我的思路一般是：开一个数组num, num[i][j]记录的是从起点到点（i， j）需要的最小步数，在bfs中，不断地更新这个数组。初始化时，可以将 num[i][j]全部初始化为-1，值为-1就代表点（i，j）还没有来过。需要注意的是，在bfs过程中，只有当 num[i][j] = -1或者当前步数小于 num[i][j]时，才将当前节点加入队列，并更新num数组的值。因为当 num[i][j]小于等于当前步数时，就说明在之前，你已经搜索到了一种更优的方案，那么当前这个节点就完全没必要继续搜索了。最后，根据终点的坐标值，去访问num数组，即可得到答案。

这里放另一道例题，用我上述的思路完全可以解决https://ac.nowcoder.com/acm/contest/23156/1018

但是这个题（wyh的吃鸡）稍有不同，如果完全按照上述思路解，是错误的。为什么会错误呢？因为本题是有两种状态（走路，开车），他们的速度或者说走一步路需要的时长是不同的，这就导致不能将两种状态看作一种状态去处理。举个例子，如果我是开车到达一个点的，但是我发现当前点的num数组记录的值要比我当前的步数更小，按上述思路，当前的状态被认为不会更优，不会加入队列，不会进行进一步搜索。但是，我是开着车到当前节点的，如果我之前到这个节点是走路到达的，那么即使我开车到达当前节点所需时间更长，也不能说明当前的搜索一定不会更优，毕竟开车比走路快，完全有可能在后续超过走路的，并更早到达终点。

所以这个题，需要对num数组进行一个小小的修改，由二维改为三维，num[i][j][0] 记录的是，以走路的状态到达点（i，j）所需要的最小时间。num[i][j][1]记录的就是以开车的状态到达点（i，j）所需要的最小时间。那么怎么判断是以怎样的状态到达当前点的呢？我们可以在用一个变量time记录走一步路需要花费的时间，那么time等于2就是走路的状态，time等于1就是开车的状态。

本题有一个坑点，就是注意题干中说了终点X是一个连通块，意味着X可能有不止一个。所以按我讲述的思路，最后遍历一下图，如果遇到X就更新一下答案，然后最后输出即可。

#include<bits/stdc++.h>

struct Ele {
    int x, y, time;
    long long step;
};

char map[105][105];
bool vis[105][105];
long long num[105][105][2];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int sx, sy, n, k;

bool check(int x, int y) {
    return x >= 1 && x <= n && y >= 1 && y <= n && map[x][y] != 'O';
}

void bfs() {
    std::queue<Ele> que;
    Ele pre, nex;
    pre.x = sx;
    pre.y = sy;
    pre.step = 0;
    pre.time = 2;
    num[sx][sy][0] = 0;
    que.push(pre);

    while (!que.empty()) {
        pre = que.front();
        que.pop();

        for (int i = 0; i < 4; ++i) {
            int state;
            if (pre.time == 2) state = 0;
            else state = 1;
            nex.x = pre.x + dx[i];
            nex.y = pre.y + dy[i];
            nex.step = pre.step + pre.time;

            if (check(nex.x, nex.y)) {
                if (num[nex.x][nex.y][state] == -1 || num[nex.x][nex.y][state] > nex.step) {
                    num[nex.x][nex.y][state] = nex.step;
                    if (map[nex.x][nex.y] == 'C') nex.time = 1;
                    else nex.time = pre.time;
                    que.push(nex);
                }
            }
        }
    }
}

void solve() {
    std::cin >> n >> k;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            num[i][j][0] = -1;
            num[i][j][1] = -1;
        }
    }
    
    for (int i = 1; i <= n; ++i) { 
        for (int j = 1; j <= n; ++j) {
            std::cin >> map[i][j];
            if (map[i][j] == 'S') {
                sx = i;
                sy = j;
            }
        }
    }

    bfs();

    long long ans = 1e18;
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (map[i][j] == 'X') {
                if (num[i][j][0] == -1 && num[i][j][1] == -1) continue;
                if (num[i][j][0] != -1) ans = std::min(ans, num[i][j][0]);
                if (num[i][j][1] != -1) ans = std::min(ans, num[i][j][1]);
            }
        }
    }

    if (ans > k) std::cout << "NO\n";
    else std::cout << "YES\n" << ans << '\n';
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}