Select Cells in Grid With Maximum Score

Select Cells in Grid With Maximum Score - Problem

You're given a 2D grid filled with positive integers, and your goal is to become a strategic treasure hunter! 🏆

Your mission: Select cells from the grid to maximize your score (sum of selected values), but there are two crucial rules:

No two cells from the same row - each row can contribute at most one treasure
All selected values must be unique - no duplicates allowed in your collection

Think of it as choosing the best representatives from each row, where each representative must have a unique value that hasn't been chosen before.

Example: In grid [[1,2,3],[4,3,2],[1,1,1]], you could select 3 from row 0 and 4 from row 1 for a score of 7, but you can't select another 3 since values must be unique!

Input & Output

example_1.py — Basic Grid

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

› Output: 8

💡 Note: Select 3 from row 0 (index [0,2]), 4 from row 1 (index [1,0]), and skip row 2 (all values are 1, but 1 hasn't been used yet, so we could pick 1 for a total of 3+4+1=8). Actually, the optimal is to pick 2 from row 0, 4 from row 1, and 1 from row 2 for total 2+4+1=7, or pick 3 from row 0 and 4 from row 1 for 3+4=7. Wait, let me recalculate: pick 3 from row 0, 4 from row 1, 1 from row 2 = 8 total.

example_2.py — Duplicate Values

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

› Output: 17

💡 Note: From row 0, select 9 (highest value). From row 1, select 8 (highest available value that's different from 9). Total: 9 + 8 = 17.

example_3.py — Single Row

$ Input: grid = [[8,7,6]]

› Output: 8

💡 Note: With only one row, select the maximum value which is 8.

Constraints

1 ≤ grid.length, grid[i].length ≤ 10
1 ≤ grid[i][j] ≤ 100
All values in the grid are positive integers
You must select at least one cell to get a non-zero score

Visualization

Tap to expand

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses Dynamic Programming with Bitmask to efficiently track which values have been selected while processing each row. This approach has time complexity O(rows × 2^unique_values × cols) and guarantees the maximum score by exploring all valid combinations without redundant calculations.

Common Approaches

✓ Brute Force (Try All Combinations)

⏱️ Time: O((max_cols)^rows) Space: O(rows)

Try every possible way to select at most one cell from each row, checking if values are unique and calculating the score for each valid combination.

Dynamic Programming with Bitmask

⏱️ Time: O(rows × 2^unique_values × cols) Space: O(rows × 2^unique_values)

This approach uses dynamic programming with bitmask to efficiently solve the problem. We track which values have been used with a bitmask and which rows we've processed, avoiding redundant calculations through memoization.

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible combinations of selecting 0 or 1 cell from each row
For each combination, check if all selected values are unique
If valid, calculate the sum and track the maximum
Return the maximum score found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Row 0

Consider all cells in first row plus option to skip

Branch for Each Choice

For each valid choice, create a new branch

Check Uniqueness

Verify selected values don't conflict

Calculate Score

Sum up values when reaching leaf nodes

Code -

solution.c — C

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

static bool used[10001];
static char input[100000];

int backtrack(int row, int** grid, int* gridColSize, int gridSize, int score) {
    if (row == gridSize) {
        return score;
    }
    
    // Option 1: Skip this row
    int maxScore = backtrack(row + 1, grid, gridColSize, gridSize, score);
    
    // Option 2: Pick a cell from this row
    for (int col = 0; col < gridColSize[row]; col++) {
        int val = grid[row][col];
        if (!used[val]) {
            used[val] = true;
            int newScore = backtrack(row + 1, grid, gridColSize, gridSize, score + val);
            if (newScore > maxScore) {
                maxScore = newScore;
            }
            used[val] = false;
        }
    }
    
    return maxScore;
}

int main() {
    fgets(input, sizeof(input), stdin);
    
    int** grid = (int**)malloc(1000 * sizeof(int*));
    int* gridColSize = (int*)malloc(1000 * sizeof(int));
    int gridSize = 0;
    
    memset(used, false, sizeof(used));
    
    if (strcmp(input, "[]\n") == 0 || strcmp(input, "[]") == 0) {
        printf("%d\n", backtrack(0, grid, gridColSize, 0, 0));
        return 0;
    }
    
    int len = strlen(input);
    if (input[len-1] == '\n') input[len-1] = '\0';
    
    // Remove outer brackets
    char* str = input + 1;
    str[strlen(str)-1] = '\0';
    
    int i = 0;
    while (i < strlen(str)) {
        if (str[i] == '[') {
            grid[gridSize] = (int*)malloc(1000 * sizeof(int));
            gridColSize[gridSize] = 0;
            i++; // skip '['
            
            char* numStart = NULL;
            while (i < strlen(str) && str[i] != ']') {
                if (str[i] >= '0' && str[i] <= '9') {
                    if (numStart == NULL) numStart = str + i;
                } else if (str[i] == ',' || str[i] == ']') {
                    if (numStart != NULL) {
                        char temp = str[i];
                        str[i] = '\0';
                        grid[gridSize][gridColSize[gridSize]] = atoi(numStart);
                        gridColSize[gridSize]++;
                        str[i] = temp;
                        numStart = NULL;
                    }
                }
                i++;
            }
            
            if (numStart != NULL) {
                grid[gridSize][gridColSize[gridSize]] = atoi(numStart);
                gridColSize[gridSize]++;
            }
            
            gridSize++;
            i++; // skip ']'
        } else {
            i++;
        }
    }
    
    printf("%d\n", backtrack(0, grid, gridColSize, gridSize, 0));
    
    for (int i = 0; i < gridSize; i++) {
        free(grid[i]);
    }
    free(grid);
    free(gridColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((max_cols)^rows)

For each row, we try all possible column choices, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(rows)

Recursion stack depth and space to track current selection

⚡ Linearithmic Space

52.0K Views

Medium-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

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler