Maximum Score From Grid Operations - Practice Coding Problems

Maximum Score From Grid Operations - Problem

Imagine you're a digital artist working with a special painting grid! You start with an n × n white canvas and have a unique brush that can paint entire columns from top to bottom.

Here's how your magical brush works: when you select any cell at position (i, j), it colors all cells black in column j from the top row (row 0) down to row i inclusive.

The scoring system is fascinating: You earn points equal to the value of each white cell that has at least one horizontally adjacent black cell (left or right neighbor).

Your mission: Maximize your total score by strategically choosing which cells to paint!

Input: A 2D matrix grid of size n × n containing positive integers
Output: The maximum possible score you can achieve

Input & Output

example_1.py — Basic Example

$ Input: grid = [[1,1,1],[1,1,1],[1,1,1]]

› Output: 4

💡 Note: Paint column 1 completely (height 3). This creates white cells at positions (0,0), (1,0), (2,0), (0,2), (1,2), (2,2) with black horizontal neighbors. Each contributes score 1, but we only count horizontal adjacencies, giving us a score of 4.

example_2.py — Strategic Painting

$ Input: grid = [[2,3,4],[5,6,7],[8,9,1]]

› Output: 22

💡 Note: Optimal strategy involves painting column 0 to height 2 and column 1 to height 1. This creates strategic boundaries that maximize the sum of white cells with black neighbors.

example_3.py — Single Column Edge Case

$ Input: grid = [[5]]

› Output: 0

💡 Note: With only one column, no cell can have a horizontal neighbor, so the maximum score is 0.

Constraints

1 ≤ n ≤ 100
1 ≤ grid[i][j] ≤ 10⁵
The grid is always square (n × n)
Time limit: 3 seconds

Visualization

Tap to expand

Understanding the Visualization

Choose Painting Heights

For each column, decide how far down to paint (0 to n rows)

Create Boundaries

White-black boundaries form horizontally between adjacent columns

Calculate Score

Sum values of white cells that have black horizontal neighbors

Optimize Configuration

Use DP to find the height combination that maximizes total score

Key Takeaway

🎯 Key Insight: The optimal solution balances creating valuable boundaries while maximizing the sum of white cells adjacent to black regions through strategic column height selection.

Asked in

G Google 45 f Meta 38

The optimal solution uses Dynamic Programming with state dp[col][height] representing maximum score for columns 0 to col where column col is painted to the given height. Key insight: only horizontal boundaries between white and black cells contribute to the score. Time complexity: O(n³), Space: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n³ × 2^n)	O(n × 2^n)	Use memoization to avoid recalculating scores for repeated subproblems
Optimized Dynamic Programming (Optimal)	O(n³)	O(n²)	Use state-space DP considering column interdependencies for optimal scoring
Brute Force (Try All Configurations)	O(n^(n+2))	O(n²)	Try every possible painting height for each column and calculate the maximum score

Dynamic Programming with Memoization — Algorithm Steps

Create a memoization table indexed by column and previous column's state
For each column, try all possible painting heights (0 to n)
Calculate the contribution of current column given previous column's height
Recursively solve for remaining columns with memoization
Return the maximum score achievable

Visualization

Tap to expand

Step-by-Step Walkthrough

State Representation

Each node represents (column, heights_so_far)

Memoization Check

Check if this state was already computed

Recursive Exploration

Try all heights for current column if not memoized

Store Result

Cache the result for future use

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_MEMO 10000

typedef struct {
    char key[200];
    int value;
} MemoEntry;

MemoEntry memo[MAX_MEMO];
int memoSize = 0;

int findMemo(const char* key) {
    for (int i = 0; i < memoSize; i++) {
        if (strcmp(memo[i].key, key) == 0) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(const char* key, int value) {
    if (memoSize < MAX_MEMO) {
        strcpy(memo[memoSize].key, key);
        memo[memoSize].value = value;
        memoSize++;
    }
}

int calculateFullScore(int** grid, int* heights, int n) {
    bool** painted = (bool**)malloc(n * sizeof(bool*));
    for (int i = 0; i < n; i++) {
        painted[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    for (int col = 0; col < n; col++) {
        for (int row = 0; row < heights[col]; row++) {
            painted[row][col] = true;
        }
    }
    
    int score = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (!painted[i][j]) {
                bool hasBlackNeighbor = false;
                if (j > 0 && painted[i][j-1]) hasBlackNeighbor = true;
                if (j < n-1 && painted[i][j+1]) hasBlackNeighbor = true;
                
                if (hasBlackNeighbor) {
                    score += grid[i][j];
                }
            }
        }
    }
    
    for (int i = 0; i < n; i++) {
        free(painted[i]);
    }
    free(painted);
    
    return score;
}

int dp(int** grid, int col, int* heightsSoFar, int heightsCount, int n) {
    if (col == n) {
        return calculateFullScore(grid, heightsSoFar, n);
    }
    
    char key[200];
    sprintf(key, "%d,", col);
    for (int i = 0; i < heightsCount; i++) {
        char temp[10];
        sprintf(temp, "%d,", heightsSoFar[i]);
        strcat(key, temp);
    }
    
    int memoResult = findMemo(key);
    if (memoResult != -1) {
        return memoResult;
    }
    
    int maxScore = 0;
    for (int height = 0; height <= n; height++) {
        heightsSoFar[heightsCount] = height;
        int score = dp(grid, col + 1, heightsSoFar, heightsCount + 1, n);
        if (score > maxScore) {
            maxScore = score;
        }
    }
    
    addMemo(key, maxScore);
    return maxScore;
}

int maxScoreFromGridOperations(int** grid, int gridSize, int* gridColSize) {
    memoSize = 0;
    int* heights = (int*)malloc(gridSize * sizeof(int));
    int result = dp(grid, 0, heights, 0, gridSize);
    free(heights);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × 2^n)

n columns, n² possible states per column, up to 2^n unique subproblems

⚠ Quadratic Growth

Space Complexity

O(n × 2^n)

Memoization table storing results for each column and state combination

⚠ Quadratic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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 with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler