|
| 1 | +// https://leetcode.com/problems/path-with-minimum-effort |
| 2 | +// T: O(m * n * log(m * n)) |
| 3 | +// S: O(m * n) |
| 4 | + |
| 5 | +import java.util.ArrayList; |
| 6 | +import java.util.Arrays; |
| 7 | +import java.util.Comparator; |
| 8 | +import java.util.List; |
| 9 | +import java.util.PriorityQueue; |
| 10 | +import java.util.Queue; |
| 11 | + |
| 12 | +public class PathWithMinimumEffort { |
| 13 | + private record Position(int x, int y) {} |
| 14 | + |
| 15 | + private record Info(Position position, int effort) {} |
| 16 | + |
| 17 | + private static final int[][] Directions = new int[][] {{1, 0}, {0, 1}, {-1, 0}, {0, -1}}; |
| 18 | + |
| 19 | + // T: O(m * n * log(m * n)) S: O(m * n) |
| 20 | + public int minimumEffortPath(int[][] heights) { |
| 21 | + final int[][] minEffort = initialiseMinEfforts(heights.length, heights[0].length); |
| 22 | + final Queue<Info> queue = new PriorityQueue<>(Comparator.comparingInt(a -> a.effort)); |
| 23 | + queue.add(new Info(new Position(0, 0), 0)); |
| 24 | + |
| 25 | + while (!queue.isEmpty()) { |
| 26 | + final Info info = queue.poll(); |
| 27 | + if (info.effort >= minEffort[info.position.x][info.position.y]) { |
| 28 | + continue; |
| 29 | + } |
| 30 | + minEffort[info.position.x][info.position.y] = info.effort; |
| 31 | + |
| 32 | + for (Position position : validPositions(heights, info.position)) { |
| 33 | + queue.add(new Info(position, Math.max(info.effort, absDiff(info.position, position, heights)))); |
| 34 | + } |
| 35 | + } |
| 36 | + |
| 37 | + return minEffort[heights.length - 1][heights[0].length - 1]; |
| 38 | + } |
| 39 | + |
| 40 | + // T: O(m * n), S: O(m * n) |
| 41 | + private static int[][] initialiseMinEfforts(int rows, int columns) { |
| 42 | + final int[][] result = new int[rows][columns]; |
| 43 | + for (int[] row : result) { |
| 44 | + Arrays.fill(row, Integer.MAX_VALUE); |
| 45 | + } |
| 46 | + return result; |
| 47 | + } |
| 48 | + |
| 49 | + // T: O(1), S: O(1) |
| 50 | + private static int absDiff(Position p1, Position p2, int[][] heights) { |
| 51 | + return Math.abs(heights[p1.x][p1.y] - heights[p2.x][p2.y]); |
| 52 | + } |
| 53 | + |
| 54 | + // T: O(1), S: O(1) |
| 55 | + private static List<Position> validPositions(int[][] heights, Position position) { |
| 56 | + final List<Position> result = new ArrayList<>(); |
| 57 | + for (int[] direction : Directions) { |
| 58 | + final int row = position.x + direction[0], column = position.y + direction[1]; |
| 59 | + if (row >= 0 && row < heights.length && column >= 0 && column < heights[0].length) { |
| 60 | + result.add(new Position(row, column)); |
| 61 | + } |
| 62 | + } |
| 63 | + return result; |
| 64 | + } |
| 65 | +} |
0 commit comments