最小体力消耗路径 

 看见这题第一眼-动态规划，再看BFS。

用动态规划做的话不能一次保证当前位置能获得最小的最大值，因为需要周围的四个（或者两个）元素值。

这里我纯用的BFS，宽度优先搜索。类似于n皇后问题。见代码吧。

class Solution {
    static int dx[] = new int[]{1, -1, 0, 0};
    static int dy[] = new int[]{0, 0, 1, -1};
    public static int minimumEffortPath(int[][] heights) {
        int arr[][] = new int[heights.length][heights[0].length];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                arr[i][j] = Integer.MAX_VALUE;
            }
        }
        Queue<int[]> queue = new ArrayDeque<>();
        queue.add(new int[]{0, 0});
        arr[0][0] = 0;
        while (!queue.isEmpty()) {
            int t[] = queue.poll();
            for (int i = 0; i < 4; i++) {
                int x = t[0] + dx[i];
                int y = t[1] + dy[i];
                if (x >= 0 && x < heights.length && y >= 0 && y < heights[0].length) {
                    int ans = Math.max(Math.abs(heights[x][y] - heights[t[0]][t[1]]), arr[t[0]][t[1]]);
                    if (ans < arr[x][y]) {
                        arr[x][y] = ans;
                        queue.add(new int[]{x, y});
                    }
                }
            }
        }
        return arr[heights.length - 1][heights[0].length - 1];
    }
}

这里的注意点就是在判断边界值，找最大的最小值的时候，需要特判，再加入队列，否则队列会重复添加元素，导致超时。