Maximum Number of Points with Cost - Practice Coding Problems

Maximum Number of Points with Cost - Problem

Imagine you're a treasure hunter navigating through an ancient temple with m floors and n rooms per floor. Each room contains a treasure worth points[r][c] points. Your goal is to maximize your treasure collection while following these rules:

Must visit exactly one room per floor - you can't skip floors or visit multiple rooms on the same floor
Moving costs energy - if you pick room c1 on floor r and room c2 on floor r+1, you lose |c1 - c2| points due to the energy spent traveling horizontally

Given an m × n matrix where points[i][j] represents the treasure value in room j on floor i, return the maximum points you can collect on your journey from the top floor to the bottom floor.

Think strategically! Sometimes it's worth picking a room with fewer points if it positions you better for the floors below.

Input & Output

example_1.py — Basic Matrix

$ Input: points = [[1,2,3],[1,5,1],[3,1,1]]

› Output: 9

💡 Note: Optimal path: (0,1) → (1,1) → (2,0) = 2 + 5 + 3 - |1-1| - |1-0| = 10 - 0 - 1 = 9

example_2.py — Single Column

$ Input: points = [[1,5],[2,3],[4,2]]

› Output: 11

💡 Note: Optimal path: (0,1) → (1,0) → (2,0) = 5 + 2 + 4 - |1-0| - |0-0| = 11 - 1 - 0 = 10. Wait, let's recalculate: (0,1) → (1,1) → (2,0) = 5 + 3 + 4 - 0 - 1 = 11

example_3.py — Large Penalties

$ Input: points = [[1,2,3],[1,5,1],[3,1,1]]

› Output: 9

💡 Note: Even with potential high movement costs, the algorithm finds the optimal balance between high-value cells and movement penalties

Constraints

m == points.length
n == points[r].length
1 ≤ m, n ≤ 10⁵
1 ≤ m × n ≤ 10⁵
0 ≤ points[r][c] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Initialize First Floor

Start by noting treasure values in each room of the first floor

Left Pass Strategy

For each floor, calculate the best score achievable when approaching each room from the left

Right Pass Strategy

Similarly, calculate the best score when approaching each room from the right

Optimal Choice

For each room, choose the better of the two approaches and add the room's treasure value

Key Takeaway

🎯 Key Insight: By using auxiliary left and right arrays to precompute optimal transitions, we transform an O(m×n²) problem into an O(m×n) solution, making it efficient enough for large inputs while maintaining optimal results.

Asked in

G Google 42 a Amazon 38 f Meta 28 ⊞ Microsoft 25

The optimal solution uses dynamic programming with auxiliary left-right arrays to avoid checking every previous position. Instead of O(m×n²) naive DP, we achieve O(m×n) time complexity by precomputing the maximum achievable scores when transitioning from left and right directions, eliminating redundant calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Dynamic Programming (Optimal)	O(m×n)	O(n)	Use auxiliary arrays to optimize transition calculations from O(n²) to O(n) per row
Dynamic Programming (Basic)	O(m×n²)	O(m×n)	Use DP table where dp[i][j] represents max points achievable ending at position (i,j)

Optimized Dynamic Programming (Optimal) — Algorithm Steps

Initialize first row of DP table
For each subsequent row, create left and right auxiliary arrays
Fill left array: max score achievable coming from left or same position
Fill right array: max score achievable coming from right or same position
For each position, take max of left[j] and right[j] plus current points
Return maximum from final row

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Left Array

Compute max score achievable when coming from left direction

Create Right Array

Compute max score achievable when coming from right direction

Combine Results

For each position, take the better of left or right option

Optimization

Each position only needs to check adjacent positions in auxiliary arrays

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

long long max(long long a, long long b) {
    return a > b ? a : b;
}

long long maxPoints(int** points, int rows, int cols) {
    long long* prev = (long long*)malloc(cols * sizeof(long long));
    
    for (int j = 0; j < cols; j++) {
        prev[j] = points[0][j];
    }
    
    for (int i = 1; i < rows; i++) {
        long long* curr = (long long*)malloc(cols * sizeof(long long));
        long long* left = (long long*)malloc(cols * sizeof(long long));
        long long* right = (long long*)malloc(cols * sizeof(long long));
        
        // Fill left array
        left[0] = prev[0];
        for (int j = 1; j < cols; j++) {
            left[j] = max(left[j-1] - 1, prev[j]);
        }
        
        // Fill right array
        right[cols-1] = prev[cols-1];
        for (int j = cols-2; j >= 0; j--) {
            right[j] = max(right[j+1] - 1, prev[j]);
        }
        
        // Calculate current row
        for (int j = 0; j < cols; j++) {
            curr[j] = max(left[j], right[j]) + points[i][j];
        }
        
        free(prev);
        free(left);
        free(right);
        prev = curr;
    }
    
    long long result = prev[0];
    for (int j = 1; j < cols; j++) {
        if (prev[j] > result) {
            result = prev[j];
        }
    }
    
    free(prev);
    return result;
}

int main() {
    int rows = 3, cols = 3;
    int** points = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        points[i] = (int*)malloc(cols * sizeof(int));
    }
    
    int data[3][3] = {{1,2,3},{1,5,1},{3,1,1}};
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            points[i][j] = data[i][j];
        }
    }
    
    printf("%lld\n", maxPoints(points, rows, cols));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Three linear passes per row: left array, right array, and main calculation

✓ Linear Growth

Space Complexity

O(n)

Can use rolling arrays instead of full 2D DP table

⚡ Linearithmic Space

89.2K Views

High Frequency

~25 min Avg. Time

1.8K 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

Optimized Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler