Maximum Value Sum by Placing Three Rooks I

Maximum Value Sum by Placing Three Rooks I - Problem

You are given an m x n 2D array board representing a chessboard, where board[i][j] represents the value of the cell (i, j).

Rooks in the same row or column attack each other. You need to place three rooks on the chessboard such that the rooks do not attack each other.

Return the maximum sum of the cell values on which the rooks are placed.

Input & Output

Example 1 — Basic 3×3 Board

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

› Output: 15

💡 Note: Place rooks at (0,0), (1,1), (2,2): values 1+5+9=15. This is optimal since rooks are on different rows and columns.

Example 2 — Negative Values

$ Input: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]

› Output: 4

💡 Note: Place rooks at (0,1), (1,3), (2,1): values 1+1+2=4. Avoid negative values (-3) when possible.

Example 3 — All Same Values

$ Input: board = [[5,5,5],[5,5,5],[5,5,5]]

› Output: 15

💡 Note: Any valid placement gives the same sum: 5+5+5=15 since all cells have value 5.

Constraints

3 ≤ m, n ≤ 100
-10⁶ ≤ board[i][j] ≤ 10⁶
It's guaranteed that a solution exists

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 A Amazon 8 f Meta 6

The key insight is that three non-attacking rooks must be placed on different rows AND different columns. The brute force approach tries all possible cell combinations while the optimized approach first selects row and column combinations, then finds the optimal assignment. Best approach: Row-Column Selection with Time: O(m³n³), Space: O(1).

Common Approaches

✓ Brute Force Enumeration

⏱️ Time: O((mn)³) Space: O(1)

Generate all possible combinations of 3 cells from the board. For each combination, check if the rooks don't attack each other (different rows and columns). Track the maximum sum found.

Row Selection with Column Optimization

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

Instead of trying all cell combinations, first select 3 different rows, then for each row combination, find the best way to assign 3 different columns to maximize the sum.

Brute Force Enumeration — Algorithm Steps

Generate all combinations of 3 cells from m×n board
For each combination, verify no two rooks share same row or column
Calculate sum and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all combinations of 3 positions

Validate

Check if rooks don't attack each other

Track Max

Keep maximum valid sum found

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int solution(int** board, int m, int n) {
    int maxSum = INT_MIN;
    
    // Try all combinations of 3 cells
    for (int i1 = 0; i1 < m; i1++) {
        for (int j1 = 0; j1 < n; j1++) {
            for (int i2 = 0; i2 < m; i2++) {
                for (int j2 = 0; j2 < n; j2++) {
                    for (int i3 = 0; i3 < m; i3++) {
                        for (int j3 = 0; j3 < n; j3++) {
                            // Check if rooks don't attack each other
                            if (i1 != i2 && i1 != i3 && i2 != i3 &&
                                j1 != j2 && j1 != j3 && j2 != j3) {
                                int currentSum = board[i1][j1] + board[i2][j2] + board[i3][j3];
                                if (currentSum > maxSum) {
                                    maxSum = currentSum;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    return maxSum;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    // Parse 2D array
    int board[100][100];
    int* boardPtrs[100];
    int m = 0;
    
    // Remove outer brackets
    char* start = strchr(line, '[');
    if (start) start++;
    char* end = strrchr(line, ']');
    if (end) *end = '\0';
    
    char* rowStart = start;
    while (rowStart && *rowStart) {
        // Find next '['
        while (*rowStart && *rowStart != '[') rowStart++;
        if (!*rowStart) break;
        
        // Find matching ']'
        char* rowEnd = rowStart + 1;
        while (*rowEnd && *rowEnd != ']') rowEnd++;
        if (!*rowEnd) break;
        
        // Extract row string
        char rowStr[1000];
        int len = rowEnd - rowStart + 1;
        strncpy(rowStr, rowStart, len);
        rowStr[len] = '\0';
        
        // Parse this row
        int rowSize;
        parseArray(rowStr, board[m], &rowSize);
        boardPtrs[m] = board[m];
        m++;
        
        rowStart = rowEnd + 1;
    }
    
    int n = 0;
    if (m > 0) {
        // Count columns in first row
        char* firstRow = strchr(start, '[');
        if (firstRow) {
            firstRow++;
            char* firstRowEnd = strchr(firstRow, ']');
            if (firstRowEnd) {
                char firstRowStr[1000];
                int len = firstRowEnd - firstRow;
                strncpy(firstRowStr, firstRow, len);
                firstRowStr[len] = '\0';
                
                // Count commas + 1
                n = 1;
                for (int i = 0; firstRowStr[i]; i++) {
                    if (firstRowStr[i] == ',') n++;
                }
            }
        }
    }
    
    printf("%d\n", solution(boardPtrs, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((mn)³)

Generate C(mn,3) combinations, each taking O(1) to validate

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current combination and maximum

✓ Linear Space

8.9K Views

Medium Frequency

~25 min Avg. Time

245 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 Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler