Watch 10 video solutions for Minimum Cost Path with Teleportations, a hard level problem involving Array, Dynamic Programming, Matrix. This walkthrough by Sanyam IIT Guwahati has 6,526 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
You are given a m x n 2D integer array grid and an integer k. You start at the top-left cell (0, 0) and your goal is to reach the bottomâright cell (m - 1, n - 1).
There are two types of moves available:
Normal move: You can move right or down from your current cell (i, j), i.e. you can move to (i, j + 1) (right) or (i + 1, j) (down). The cost is the value of the destination cell.
Teleportation: You can teleport from any cell (i, j), to any cell (x, y) such that grid[x][y] <= grid[i][j]; the cost of this move is 0. You may teleport at most k times.
Return the minimum total cost to reach cell (m - 1, n - 1) from (0, 0).
Example 1:
Input: grid = [[1,3,3],[2,5,4],[4,3,5]], k = 2
Output: 7
Explanation:
Initially we are at (0, 0) and cost is 0.
| Current Position | Move | New Position | Total Cost |
|---|---|---|---|
(0, 0) |
Move Down | (1, 0) |
0 + 2 = 2 |
(1, 0) |
Move Right | (1, 1) |
2 + 5 = 7 |
(1, 1) |
Teleport to (2, 2) |
(2, 2) |
7 + 0 = 7 |
The minimum cost to reach bottom-right cell is 7.
Example 2:
Input: grid = [[1,2],[2,3],[3,4]], k = 1
Output: 9
Explanation:
Initially we are at (0, 0) and cost is 0.
| Current Position | Move | New Position | Total Cost |
|---|---|---|---|
(0, 0) |
Move Down | (1, 0) |
0 + 2 = 2 |
(1, 0) |
Move Right | (1, 1) |
2 + 3 = 5 |
(1, 1) |
Move Down | (2, 1) |
5 + 4 = 9 |
The minimum cost to reach bottom-right cell is 9.
Constraints:
2 <= m, n <= 80m == grid.lengthn == grid[i].length0 <= grid[i][j] <= 1040 <= k <= 10Problem Overview: You are given a cost matrix where moving through cells accumulates cost, but certain cells allow teleportation to other positions. The goal is to reach the destination with the minimum possible total cost while accounting for both normal moves and teleport transitions.
Approach 1: Brute Force DFS with Backtracking (Exponential Time, O(2^(mn)) time, O(mn) space)
The most direct approach explores every possible path from the start cell to the destination. From each cell you recursively try all valid directions and any teleportation options. You maintain the running path cost and track the minimum cost found. This approach demonstrates the full search space but quickly becomes infeasible because the number of paths grows exponentially with grid size. Space complexity is O(mn) due to the recursion stack and visited tracking.
Approach 2: DFS with Memoization (Top-Down Dynamic Programming) (O(mn * k) time, O(mn) space)
You can eliminate repeated work by caching results for each cell. Instead of recomputing the minimum cost from the same position multiple times, store the result in a DP table. When recursion revisits that cell, return the cached value immediately. Teleportation transitions are handled as additional edges in the recursion. This turns the brute force search into a dynamic programming problem over the grid state space. The complexity becomes O(mn * k), where k represents teleport destinations associated with a cell.
Approach 3: DP with Teleport Mapping and Dijkstra (Optimal) (O(mn log(mn)) time, O(mn) space)
The grid can be modeled as a weighted graph where each cell is a node. Adjacent moves add cost equal to the destination cell, and teleportation creates additional edges connecting distant cells. Running Dijkstraâs algorithm from the start ensures the minimum cost to each cell is processed in increasing order. A priority queue always expands the cheapest state first. To keep teleport operations efficient, group teleport cells using a hash map keyed by teleport identifier stored in an array or grid structure. Each teleport group is processed once to avoid redundant edges.
This approach works well because every grid transition becomes a simple edge relaxation. The algorithm iterates through neighbors in the matrix, pushes candidate states into the priority queue, and updates the distance table when a cheaper path is discovered. The final DP table stores the minimum cost for every cell.
Recommended for interviews: Interviewers usually expect the graph-based dynamic programming solution. Modeling the grid as a weighted graph and applying Dijkstra shows strong understanding of dynamic programming and shortest path techniques. Mentioning the brute force search first demonstrates you understand the problem space, while the optimized DP/priority-queue solution shows practical algorithm design.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force DFS | O(2^(mn)) | O(mn) | Conceptual baseline or very small grids |
| DFS + Memoization (Top-Down DP) | O(mn * k) | O(mn) | When teleport groups are small and recursion is acceptable |
| Dijkstra with Teleport Mapping | O(mn log(mn)) | O(mn) | General case with weighted cells and teleport edges |