LeetCode1631「最小体力消耗路径」

给一个二维 rows x columns 的地图 heights ，其中 heights[row][col] 表示格子 (row, col) 的高度。一开始你在最左上角的格子 (0, 0) ，且你希望去最右下角的格子 (rows-1, columns-1) （注意下标从 0 开始编号）。你每次可以往 上，下，左，右 四个方向之一移动，你想要找到耗费 体力 最小的一条路径。

一条路径耗费的 体力值 是路径上相邻格子之间 高度差绝对值 的 最大值 决定的。

请你返回从左上角走到右下角的最小 体力消耗值 。

思路：可以把此问题抽象成一个图，既然要计算每两个顶点高度差的绝对值，可以把这个高度差的绝对值看作是一条边的权重。另外创建一个辅助类来保存初始点到各个顶点的体力消耗值。

class  State{

        int x;
        int y;
        int height; // 初始点到该点的体力消耗值

        public State(int x, int y, int height) {
            this.x = x;
            this.y = y;
            this.height = height;
        }
}

代码：

public class Solution {

    class  State{

        int x;
        int y;
        int height; // 初始点到该点的体力消耗值

        public State(int x, int y, int height) {
            this.x = x;
            this.y = y;
            this.height = height;
        }
    }

    int m;
    int n;
    public int minimumEffortPath(int[][] heights) {

        m = heights.length;
        n = heights[0].length;

        List<int[]>[][] graph = new LinkedList[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                graph[i][j] = new LinkedList<>();
            }
        }
        // 构建图
        for (int k = 0; k < m; k++) {
            for (int l = 0; l < n; l++) {

                if (k - 1 >= 0) {
                    graph[k][l].add(new int[]{k - 1, l, Math.abs(heights[k - 1][l] - heights[k][l])});
                }
                if (k + 1 < m) {
                    graph[k][l].add(new int[]{k + 1, l, Math.abs(heights[k + 1][l] - heights[k][l])});
                }
                if (l - 1 >= 0) {
                    graph[k][l].add(new int[]{k, l - 1, Math.abs(heights[k][l - 1] - heights[k][l])});
                }
                if (l + 1 < n) {
                    graph[k][l].add(new int[]{k, l + 1, Math.abs(heights[k][l + 1] - heights[k][l])});
                }

            }
        }

        int ans = dijkstra(graph);
        return ans;
    }

    private int dijkstra(List<int[]>[][] graph) {
        // 优先级队列，height 较小的排在前面
        Queue<State> queue = new PriorityQueue<>((a, b) -> {
            return a.height - b.height;
        });

        queue.offer(new State(0, 0, 0));

        // 定义：probTo[x][y] 的值就是节点 (0,0) 到达节点 (x,y) 的最小体力消耗值
        int[][] probTo = new int[m][n];
        // 初始化为一个取不到的最大值
        for (int i = 0; i < m; i++) {
            Arrays.fill(probTo[i], Integer.MAX_VALUE);
        }

        probTo[0][0] = 0;

        while (!queue.isEmpty()) {

            State cur = queue.poll();

            int x = cur.x;
            int y = cur.y;
            int height = cur.height;

            if (x == m-1 && y == n-1) {
                return height;
            }

            if (height > probTo[x][y]) {
                continue;
            }

            for (int[] loc : graph[x][y]) {
                int next_x = loc[0];
                int next_y = loc[1];

                int next_h = Math.max(height, loc[2]);
                if(next_h < probTo[next_x][next_y]){
                    probTo[next_x][next_y] = next_h;
                    queue.offer(new State(next_x, next_y, next_h));
                }

            }
        }
        return -1;
    }


}