You are given an `m x n` grid `heights` of **distinct** integers representing terrain heights. You start at the top-left cell `(0, 0)` and want to reach the bottom-right cell `(m-1, n-1)` by moving **4-directionally** (up, down, left, right) within the grid. The **cost** of a path is the **maximum height value** among all cells on that path (including both endpoints). Among all valid paths from `(0, 0)` to `(m-1, n-1)`, return the **minimum possible path cost** — i.e., minimize the maximum height encountered. **Example 1** ``` heights = [[1, 9], [8, 2]] ``` The path `1 -> 8 -> 2` has cost `max(1, 8, 2) = 8`; the path `1 -> 9 -> 2` has cost `9`. Answer: `8`. **Example 2** ``` heights = [[8, 4, 7], [6, 5, 9], [3, 2, 1]] ``` Every path must include the start cell `8`, so the cost is at least `8`, and `8` is achievable (e.g. `8 -> 6 -> 3 -> 2 -> 1`). Answer: `8`. **Approach.** Model it as a shortest-path variant where a path's "distance" is the running maximum of cell heights. Run Dijkstra from `(0, 0)`: the priority queue is ordered by the smallest max-so-far, and relaxing a neighbor uses `max(current_cost, neighbor_height)`. The first time the bottom-right cell is popped, its cost is the answer. **Follow-up (DFS).** A plain DFS that explores all paths is exponential. A practical DFS-based answer is **binary search on the answer + DFS/BFS reachability**: binary-search a threshold `T`, and check whether the bottom-right is reachable from the top-left using only cells with `height <= T` (and `start <= T`). That runs in `O(m*n*log(V))` where `V` is the number of distinct height values. DFS with memoization on `min-of-max` does not compose cleanly because the value depends on the whole path prefix, so binary search is the cleaner DFS-flavored solution.