Shortest Increasing Path to a Target

Start at the top-left cell of grid. You may move up, down, left, or right only to a cell whose value is strictly greater than the current cell's value.
Return a shortest path ending at any cell whose value equals target. Encode a cell as row * columnCount + column. If multiple shortest paths exist, return the lexicographically smallest encoded path. Return an empty array if the target is unreachable.

Function
shortestIncreasingPath(grid: int[][], target: int) → int[]

Examples
Example 1
grid = [[1,2,9],[4,5,3],[7,6,8]]
target = 5
return = [0,1,4]
Paths [0,1,4] and [0,3,4] both use two moves. The first is lexicographically smaller.
Example 2
grid = [[5,4],[3,6]]
target = 6
return = []
Neither neighbor of the starting value 5 is greater, so no move is possible.

Constraints
1 <= grid.length, grid[i].length <= 300.
Every row has the same length.
Every value and target fits a signed 32-bit integer.

Strictly increasing moves mean the graph is a DAG, so no cell repeats on a path and you don't need a visited set for correctness. BFS from cell 0 gives shortest distance in moves. The trap is the lexicographic tie-break. Don't store whole paths in the queue, that blows memory on a 300 by 300 grid. Instead, compute distances with BFS, then find the target cells at minimum distance. Rebuild the path by walking forward from the start, at each step picking the smallest encoded neighbor that is on a shortest route to a target. That needs a backward reachability pass from the best targets. Another option is processing neighbors in sorted order and keeping the first parent, but check it carefully against the encoded-path ordering across levels. Edge cases: start cell already equals target returns [0], and no valid move returns []. StealthCoder is your hedge if the reconstruction logic falls apart live.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.