Maximum Number of Points with Cost

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

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

✓ Dynamic Programming (Basic)

⏱️ Time: O(m×n²) Space: O(m×n)

Create a 2D DP table where each cell represents the maximum points achievable when ending at that position. For each cell, check all possible previous positions and calculate the optimal transition cost.

Optimized Dynamic Programming (Optimal)

⏱️ Time: O(m×n) Space: O(n)

Instead of checking every previous position for each cell, use two auxiliary arrays (left and right) to precompute the maximum achievable scores when moving from left-to-right and right-to-left directions. This reduces the time complexity significantly.

Dynamic Programming (Basic) — Algorithm Steps

Initialize DP table with first row values
For each subsequent row, calculate max points for each column
For each cell, check all columns from previous row
Add current cell value minus transition penalty
Return maximum value from last row

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize First Row

Copy values from first row of points matrix to DP table

Fill Each Row

For each cell, check all positions in the previous row

Calculate Transitions

Add previous value plus current points minus movement penalty

Find Maximum

The answer is the maximum value in the last row

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.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** dp = (long long**)malloc(rows * sizeof(long long*));
    for (int i = 0; i < rows; i++) {
        dp[i] = (long long*)malloc(cols * sizeof(long long));
    }
    
    // Initialize first row
    for (int j = 0; j < cols; j++) {
        dp[0][j] = points[0][j];
    }
    
    // Fill DP table
    for (int i = 1; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            dp[i][j] = LLONG_MIN;
            for (int k = 0; k < cols; k++) {
                long long penalty = abs(j - k);
                long long score = dp[i-1][k] + points[i][j] - penalty;
                if (score > dp[i][j]) {
                    dp[i][j] = score;
                }
            }
        }
    }
    
    long long result = LLONG_MIN;
    for (int j = 0; j < cols; j++) {
        if (dp[rows-1][j] > result) {
            result = dp[rows-1][j];
        }
    }
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

int main() {
    char input[1000000];
    fgets(input, sizeof(input), stdin);
    
    // Simple parser for matrix format [[1,2,3],[4,5,6]]
    int rows = 0, cols = 0;
    int** points = NULL;
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first [
    ptr++; // Skip first [
    
    // Count rows first
    char* temp = ptr;
    while (*temp) {
        if (*temp == '[') rows++;
        temp++;
    }
    
    points = (int**)malloc(rows * sizeof(int*));
    
    int row = 0;
    while (*ptr && row < rows) {
        if (*ptr == '[') {
            ptr++;
            // Count columns in first row
            if (row == 0) {
                char* temp2 = ptr;
                cols = 1;
                while (*temp2 && *temp2 != ']') {
                    if (*temp2 == ',') cols++;
                    temp2++;
                }
            }
            
            points[row] = (int*)malloc(cols * sizeof(int));
            
            int col = 0;
            char num_str[20];
            int num_idx = 0;
            
            while (*ptr && *ptr != ']' && col < cols) {
                if (*ptr >= '0' && *ptr <= '9') {
                    num_str[num_idx++] = *ptr;
                } else if (*ptr == ',' || *ptr == ']') {
                    num_str[num_idx] = '\0';
                    points[row][col++] = atoi(num_str);
                    num_idx = 0;
                }
                ptr++;
            }
            if (num_idx > 0) {
                num_str[num_idx] = '\0';
                points[row][col] = atoi(num_str);
            }
            row++;
        }
        ptr++;
    }
    
    printf("%lld\n", maxPoints(points, rows, cols));
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(points[i]);
    }
    free(points);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n²)

For each of m×n cells, we check n previous positions

⚠ Quadratic Growth

Space Complexity

O(m×n)

DP table stores maximum points for each position

⚡ 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

Dynamic Programming (Basic) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler