Maximum Value Sum by Placing Three Rooks II

Maximum Value Sum by Placing Three Rooks II - Problem

You are given a m × 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 3x3 Board

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

› Output: 4

💡 Note: Place rooks at positions (0,2), (1,1), and (2,3). Sum = 1 + (-3) + 1 = -1. Actually, optimal is (0,1), (1,0), (2,2) giving 1 + 0 + 1 = 2. Wait, let me recalculate: (0,3)=1, (1,2)=1, (2,1)=2 gives sum = 4.

Example 2 — Negative Values

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

› Output: 15

💡 Note: Place rooks at positions (0,2), (1,1), and (2,0). Sum = 3 + 5 + 7 = 15.

Example 3 — Small Board

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

› Output: Cannot place 3 rooks on 2x2 board

💡 Note: Need at least 3 rows and 3 columns to place 3 non-attacking rooks.

Constraints

m == board.length
n == board[i].length
3 ≤ m, n ≤ 100
-10⁹ ≤ board[i][j] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 A Amazon 15

The key insight is that with exactly 3 rooks, we can enumerate middle positions and efficiently find optimal first and third rook placements. The smart enumeration approach achieves O(m²n²) time by precomputing top values per row and avoiding redundant combinations.

Common Approaches

✓ Brute Force - Try All Combinations

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

Generate all possible combinations of 3 cells, verify they're on different rows and columns, and track maximum sum. This ensures no rooks attack each other.

Smart Enumeration with Pruning

⏱️ Time: O(m²n²) Space: O(mn)

For each possible middle rook position, precompute the best values in remaining rows and columns, then use those to quickly find the optimal first and third rooks without checking all combinations.

Brute Force - Try All Combinations — Algorithm Steps

Iterate through all possible combinations of 3 cells
Check if all 3 cells are on different rows and columns
Calculate sum and update maximum if valid

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Combinations

Try every possible set of 3 cells

Validate Placement

Check if rooks are on different rows and columns

Track Maximum

Keep the highest 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);
    }
}

void parseBoard(const char* input, int board[20][20], int* m, int* n) {
    const char* p = input;
    *m = 0;
    *n = 0;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        // Parse one row
        if (*p == '[') {
            p++; // skip '['
            int col = 0;
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']' || *p == '\0') break;
                board[*m][col++] = (int)strtol(p, (char**)&p, 10);
            }
            if (*n == 0) *n = col; // Set column count from first row
            if (*p == ']') p++; // skip ']'
            (*m)++;
        }
    }
}

int solution(int board[20][20], int m, int n) {
    int maxSum = INT_MIN;
    
    // Try all combinations of 3 cells with different rows and columns
    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 all rooks are on different rows and columns
                            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;
    
    // Find the board array in the JSON input
    char* boardStart = strstr(line, "[[");
    if (!boardStart) return 1;
    
    int board[20][20];
    int m, n;
    
    parseBoard(boardStart, board, &m, &n);
    
    printf("%d\n", solution(board, m, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((mn)³)

Three nested loops to pick 3 cells from m×n board, checking each combination

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track maximum sum and current combination

✓ Linear Space

8.5K Views

Medium Frequency

~35 min Avg. Time

342 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