We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Maximum Score From Grid Operations

Difficulty: Hard

Problem Description

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 jth column starting from the top row down to the ith 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.

Key Insights

  • The operations can be performed on any cell, affecting an entire column from the top to that cell.
  • The score depends on how many white cells can be adjacent to black cells after performing column operations.
  • Selecting the optimal cells to color based on their values and positions can maximize the score.
  • A systematic approach to track which cells can contribute to the score is required.

Space and Time Complexity

Time Complexity: O(n^2) - We may need to evaluate each cell and its impact on the score. Space Complexity: O(n) - We can use an auxiliary array to track column operations.

Solution

To solve the problem, we can follow these steps:

  1. Initialize a variable to keep track of the maximum score.
  2. For each column, we can iterate through each row from the last row to the first, checking the potential score gained by coloring up to that row.
  3. Use a set or an array to keep track of which columns have been colored and which rows can contribute to the score.
  4. Calculate the score based on the rows that are adjacent to the black cells in the columns that have been colored.
  5. Return the maximum score obtained.

We will utilize a greedy approach to evaluate the best rows to color for maximizing the score.

Code Solutions

def maxScore(grid):
    n = len(grid)
    max_score = 0
    colored = [0] * n  # To track which columns are colored

    for j in range(n):
        current_score = 0
        for i in range(n):
            if colored[j] == 0:  # If the column is not yet colored
                for k in range(i + 1):
                    if k < n - 1:  # Check for horizontally adjacent white cell
                        current_score += grid[k][j]
                colored[j] = 1  # Mark the column as colored
            # Sum up the scores of adjacent cells
            if j > 0 and grid[i][j-1] == 0:  # Check left cell
                current_score += grid[i][j]
            if j < n - 1 and grid[i][j+1] == 0:  # Check right cell
                current_score += grid[i][j]

        max_score = max(max_score, current_score)

    return max_score
← Back to All Questions