Codeforces 769C 贪心 + BFS + DFS

题意

传送门 Code forces 769C Cycle In Maze

题解

采用贪心策略尽可能地取字典序最小的方向。问题在于如何判断能否最终 $k$ 步后返回起点，容易发现这个条件在时间序上具备单调性。

那么 $BFS$ 求起点至各点的最短路，同时记录逆向返回前驱节点的字典序最小的方向。最后 $DFS$ 求解即可。总时间复杂度 $O(NM+K)$。

#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for (int i = l, _ = r; i < _; ++i)
#define pb push_back
typedef long long ll;
const int MAXN = 1E3 + 5;
const int dx[4] = {1, 0, 0, -1}, dy[4] = {0, -1, 1, 0};
int N, M, K, ds[MAXN][MAXN], pred[MAXN][MAXN];
string mat[MAXN], res;
string dir = "DLRU", rdir = "URLD";

bool judge(int x, int y) { return 0 <= x && x < N && 0 <= y && y < M; }

void bfs(int sx, int sy)
{
    memset(ds, -1, sizeof(ds));
    queue<pair<int, int>> q;
    q.push({sx, sy}), ds[sx][sy] = 0;
    while (q.size())
    {
        int x = q.front().first, y = q.front().second;
        q.pop();
        rep(i, 0, 4)
        {
            int nx = x + dx[i], ny = y + dy[i];
            if (judge(nx, ny) && mat[nx][ny] != '*')
            {
                if (ds[nx][ny] == -1)
                {
                    pred[nx][ny] = i;
                    ds[nx][ny] = ds[x][y] + 1;
                    q.push({nx, ny});
                }
                else if (ds[nx][ny] == ds[x][y] + 1)
                    pred[nx][ny] = max(pred[nx][ny], i);
            }
        }
    }
}

void dfs(int x, int y, int d)
{
    rep(i, 0, 4)
    {
        int nx = x + dx[i], ny = y + dy[i];
        if (judge(nx, ny) && mat[nx][ny] != '*')
        {
            if (d + ds[nx][ny] > K)
            {
                while (mat[x][y] != 'X')
                {
                    int k = pred[x][y];
                    res += rdir[k];
                    x -= dx[k], y -= dy[k];
                }
                return;
            }
            res += dir[i];
            dfs(nx, ny, d + 1);
            break;
        }
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M >> K;
    rep(i, 0, N) cin >> mat[i];
    int sx = -1, sy = -1;
    rep(i, 0, N) rep(j, 0, M) if (mat[i][j] == 'X')
    {
        sx = i, sy = j;
        break;
    }
    bool can_move = 0;
    rep(i, 0, 4)
    {
        int nx = sx + dx[i], ny = sy + dy[i];
        if (judge(nx, ny) && mat[nx][ny] != '*')
            can_move = 1;
    }
    if (!can_move || (K & 1))
    {
        cout << "IMPOSSIBLE\n";
        return 0;
    }
    bfs(sx, sy);
    dfs(sx, sy, 0);
    cout << res << '\n';
    return 0;
}