Minimum Cost Homecoming of a Robot in a Grid

Minimum Cost Homecoming of a Robot in a Grid - Problem

Array Greedy Medium

Imagine you have a robot on a grid that needs to get home! 🤖

You're given an m × n grid where (0, 0) is the top-left corner and (m-1, n-1) is the bottom-right. Your robot starts at position startPos = [startrow, startcol] and needs to reach its home at homePos = [homerow, homecol].

The robot can move in four directions: up, down, left, or right (but can't go outside the grid boundaries). However, each move has a cost:

Vertical moves (up/down) into row r cost rowCosts[r]
Horizontal moves (left/right) into column c cost colCosts[c]

Your goal is to find the minimum total cost for the robot to reach home. Think of it like navigating through a city where different streets and avenues have different toll costs!

Input & Output

example_1.py — Basic Case

$ Input: startPos = [1, 0], homePos = [2, 3], rowCosts = [5, 4, 3], colCosts = [8, 2, 6, 7]

› Output: 18

💡 Note: Robot starts at (1,0) and needs to reach (2,3). It moves down to row 2 (cost 3), then right through columns 1,2,3 (costs 2+6+7=15). Total: 3+15=18.

example_2.py — Same Position

$ Input: startPos = [0, 0], homePos = [0, 0], rowCosts = [5], colCosts = [26]

› Output: 0

💡 Note: Robot is already at home, no movement needed, so cost is 0.

example_3.py — Only Vertical Movement

$ Input: startPos = [1, 2], homePos = [3, 2], rowCosts = [2, 3, 4, 5], colCosts = [1, 6, 1]

› Output: 9

💡 Note: Robot moves down from row 1 to row 3, passing through rows 2 and 3. Costs: 4 + 5 = 9. No column movement needed.

Constraints

m == rowCosts.length
n == colCosts.length
1 ≤ m, n ≤ 10⁵
0 ≤ rowCosts[r], colCosts[c] ≤ 10⁴
startPos.length == 2
homePos.length == 2
0 ≤ startrow, homerow < m
0 ≤ startcol, homecol < n

Visualization

Tap to expand

Understanding the Visualization

Analyze Movement

Determine required row and column movements to reach home

Calculate Path Costs

Sum costs for each row and column cell entered

Verify Optimality

Any detour would add positive costs unnecessarily

Key Takeaway

🎯 Key Insight: Since all movement costs are positive, the direct path minimizing Manhattan distance is always optimal - any detour only adds unnecessary positive costs!

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The key insight is that since all movement costs are positive, any detour from the direct path only increases the total cost. Therefore, the optimal solution is greedy: move directly from start to home by calculating the sum of costs for all rows and columns traversed along the Manhattan distance path.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Direct Path (Optimal)	O(max(\|Δr\|, \|Δc\|))	O(1)	Move directly to home - any detour only increases cost
Dynamic Programming (Brute Force)	O(m × n × 4)	O(m × n)	Use DP to explore all possible paths from start to home

Greedy Direct Path (Optimal) — Algorithm Steps

Determine the direction needed for row movement (up or down)
Calculate total cost for all row movements needed
Determine the direction needed for column movement (left or right)
Calculate total cost for all column movements needed
Return the sum of row and column movement costs

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Path

Determine direct row and column movements needed

Calculate Costs

Sum up costs for each cell entered along the path

Return Total

Add row movement costs and column movement costs

Code -

solution.c — C

int minCost(int* startPos, int startPosSize, int* homePos, int homePosSize, int* rowCosts, int rowCostsSize, int* colCosts, int colCostsSize) {
    int startRow = startPos[0], startCol = startPos[1];
    int homeRow = homePos[0], homeCol = homePos[1];
    
    int totalCost = 0;
    
    // Calculate cost for row movement
    if (startRow < homeRow) {
        // Moving down: sum costs from startRow+1 to homeRow
        for (int r = startRow + 1; r <= homeRow; r++) {
            totalCost += rowCosts[r];
        }
    } else if (startRow > homeRow) {
        // Moving up: sum costs from startRow-1 to homeRow
        for (int r = startRow - 1; r >= homeRow; r--) {
            totalCost += rowCosts[r];
        }
    }
    
    // Calculate cost for column movement
    if (startCol < homeCol) {
        // Moving right: sum costs from startCol+1 to homeCol
        for (int c = startCol + 1; c <= homeCol; c++) {
            totalCost += colCosts[c];
        }
    } else if (startCol > homeCol) {
        // Moving left: sum costs from startCol-1 to homeCol
        for (int c = startCol - 1; c >= homeCol; c--) {
            totalCost += colCosts[c];
        }
    }
    
    return totalCost;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(|Δr|, |Δc|))

We need to sum costs for each row and column we traverse, which is the Manhattan distance

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current position and accumulate costs

✓ Linear Space

25.4K Views

Medium Frequency

~15 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Direct Path (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler