【Leetcode】1810. Minimum Path Cost in a Hidden Grid

题目地址：

https://leetcode.com/problems/minimum-path-cost-in-a-hidden-grid/

给定一个未知的迷宫，提供一个类GridMaster的对象master，其能实现以下操作：
1、boolean canMove(char direction)返回能否走这个方向，方向一共有四种，'U', 'D', 'L', 'R'；
2、int move(char direction)朝这个方向走一步，并返回花费值，如果这个方向不能走（即遇到了障碍物），则停留在原地，并返回$-1$；花费值只与到达的位置有关，与其他因素无关；
3、boolean isTarget()返回当前是否在目标位置。
一开始的位置是起点位置，题目保证起点和目标都不是障碍物。问从起点到目标点的最短距离。每一步走的距离视为$1$。

与https://blog.csdn.net/qq_46105170/article/details/119288792类似，先用DFS把整个图构建出来，并且将每个位置的花费值也得到，接着用Dijkstra算法求一下最短路径即可（两个点之间可以看成有一对有向边，边权即为边的指向点的花费）。代码如下：

import java.util.*;

public class Solution {
    
    class Pair {
        int x, y, cost;
        
        public Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
        
        @Override
        public boolean equals(Object o) {
            Pair pair = (Pair) o;
            return x == pair.x && y == pair.y;
        }
        
        @Override
        public int hashCode() {
            return Objects.hash(x, y);
        }
    }
    
    private Pair target;
    
    public int findShortestPath(GridMaster master) {
        char[] dir = {'U', 'R', 'D', 'L'};
        int[] d = {-1, 0, 1, 0, -1};
        Map<Pair, int[]> map = new HashMap<>();
        Pair start = new Pair(0, 0);
        dfs(start, map, master, d, dir);
        return target == null ? -1 : bfs(start, map, d);
    }
    
    private int bfs(Pair start, Map<Pair, int[]> map, int[] d) {
        PriorityQueue<Pair> minHeap = new PriorityQueue<>((p1, p2) -> Integer.compare(p1.cost, p2.cost));
        minHeap.offer(start);
        Map<Pair, Integer> cost = new HashMap<>();
        cost.put(start, 0);
        Set<Pair> vis = new HashSet<>();
        vis.add(start);
        
        while (!minHeap.isEmpty()) {
            Pair cur = minHeap.poll();
            if (cur.equals(target)) {
                return cost.get(cur);
            }
            
            vis.add(cur);
            for (int i = 0; i < 4; i++) {
                Pair next = new Pair(cur.x + d[i], cur.y + d[i + 1]);
                int[] to = map.get(next);
                if (to[0] != 0 && !vis.contains(next)) {
                    if (!cost.containsKey(next) || cost.get(next) > cost.get(cur) + to[1]) {
                        next.cost = cur.cost + to[1];
                        cost.put(next, cost.get(cur) + to[1]);
                        minHeap.offer(next);
                    }
                }
            }
        }
        
        return -1;
    }
    
    private void dfs(Pair cur, Map<Pair, int[]> map, GridMaster master, int[] d, char[] dir) {
        if (master.isTarget()) {
            target = cur;
            map.put(cur, new int[]{2, cur.cost});
        } else {
            map.put(cur, new int[]{1, cur.cost});
        }
        
        for (int i = 0; i < 4; i++) {
            Pair next = new Pair(cur.x + d[i], cur.y + d[i + 1]);
            if (map.containsKey(next)) {
                continue;
            }
            
            if (master.canMove(dir[i])) {
                next.cost = master.move(dir[i]);
                dfs(next, map, master, d, dir);
                master.move(dir[(i + 2) % 4]);
            } else {
                map.put(next, new int[]{0});
            }
        }
    }
}

时间复杂度$O(m\log n)$，$m$是边数，$n$是点数，空间$O(m+n)$。