Maximum Score From Grid Operations

Maximum Score From Grid Operations - Problem

You are given a 2D matrix grid of size n x n. Initially, all cells of the grid are colored white.

In one operation, you can select any cell of indices (i, j), and color black all the cells of the j-th column starting from the top row down to the i-th row.

The grid score is the sum of all grid[i][j] such that cell (i, j) is white and it has a horizontally adjacent black cell.

Return the maximum score that can be achieved after some number of operations.

Input & Output

Example 1 — Basic 3x3 Grid

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

› Output: 13

💡 Note: Color columns with heights [2,1,0]. White cells (2,0)=7 and (1,1)=5 are adjacent to black cells, giving score 7+5=12. Actually optimal is different configuration giving 13.

Example 2 — Small 2x2 Grid

$ Input: grid = [[1,2],[3,4]]

› Output: 4

💡 Note: With heights [1,0], cell (1,1)=4 is white and adjacent to black cell at (0,1), giving score 4.

Example 3 — All Same Values

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

› Output: 1

💡 Note: Best configuration gives score 1 from one white cell adjacent to black.

Constraints

1 ≤ n ≤ 10²
1 ≤ grid[i][j] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18

The key insight is that score comes from white cells adjacent to black boundaries created by column painting operations. Best approach uses dynamic programming with memoization to efficiently explore all column height combinations. Time: O(n³), Space: O(n²)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n^n) Space: O(n)

For each column, try all possible heights (0 to n-1) and recursively calculate the maximum score by considering all combinations.

Dynamic Programming with Memoization

⏱️ Time: O(n³) Space: O(n²)

Cache results of subproblems based on current column and previous column heights to avoid exponential recalculation.

Brute Force - Try All Combinations — Algorithm Steps

Try all possible heights for each column
For each combination, calculate the score
Return maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Heights

Try all possible heights for each column

Calculate Score

For each combination, calculate score from white cells adjacent to black

Find Maximum

Return the maximum score found

Code -

solution.c — C

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

int maxScore = 0;

int calculateScore(int* heights, int** grid, int n) {
    int score = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i >= heights[j]) {
                int hasAdjacentBlack = 0;
                if (j > 0 && i < heights[j-1]) {
                    hasAdjacentBlack = 1;
                }
                if (j < n-1 && i < heights[j+1]) {
                    hasAdjacentBlack = 1;
                }
                if (hasAdjacentBlack) {
                    score += grid[i][j];
                }
            }
        }
    }
    return score;
}

void generateHeights(int col, int* currentHeights, int** grid, int n) {
    if (col == n) {
        int score = calculateScore(currentHeights, grid, n);
        if (score > maxScore) {
            maxScore = score;
        }
        return;
    }
    
    for (int height = 0; height <= n; height++) {
        currentHeights[col] = height;
        generateHeights(col + 1, currentHeights, grid, n);
    }
}

int solution(int** grid, int n) {
    maxScore = 0;
    int* currentHeights = (int*)calloc(n, sizeof(int));
    generateHeights(0, currentHeights, grid, n);
    free(currentHeights);
    return maxScore;
}

int parseInput(char* line, int*** grid) {
    // Count dimensions first
    int n = 1;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && line[i+1] != '[') n++;
    }
    n--; // Adjust for overcounting
    
    if (n <= 0) return 0;
    
    *grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        (*grid)[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Simple parsing - find numbers
    int row = 0, col = 0;
    char* ptr = line;
    while (*ptr && row < n) {
        if (*ptr >= '0' && *ptr <= '9') {
            (*grid)[row][col] = atoi(ptr);
            col++;
            if (col == n) {
                col = 0;
                row++;
            }
            // Skip the number
            while (*ptr >= '0' && *ptr <= '9') ptr++;
        } else {
            ptr++;
        }
    }
    
    return n;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int** grid;
    int n = parseInput(line, &grid);
    
    if (n == 0) {
        printf("0\n");
        return 0;
    }
    
    printf("%d\n", solution(grid, n));
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^n)

For each of n columns, we try n different heights

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth up to n columns

⚡ Linearithmic Space

25.4K Views

Medium Frequency

~35 min Avg. Time

892 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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler