Maximum Value Sum by Placing Three Rooks I

Maximum Value Sum by Placing Three Rooks I - Problem

Maximum Value Sum by Placing Three Rooks I

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

In chess, rooks can attack any piece in the same row or column. Your task is to place exactly three rooks on the chessboard such that:
• No two rooks attack each other (they must be in different rows AND different columns)
• The sum of values on which the rooks are placed is maximized

Goal: Return the maximum possible sum of cell values where three non-attacking rooks can be placed.

Example: If you have a 3x3 board with values [[1,2,3],[4,5,6],[7,8,9]], you could place rooks at positions (0,2), (1,0), and (2,1) to get values 3+4+8=15.

Input & Output

example_1.py — Basic 3x3 Grid

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

› Output: 15

💡 Note: The optimal placement is rooks at positions (0,2), (1,0), (2,1) giving us values 3 + 4 + 8 = 15. No two rooks are in the same row or column.

example_2.py — 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) to get values 1 + 1 + 2 = 4. This avoids the negative values while satisfying the non-attacking constraint.

example_3.py — Large Values

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

› Output: 3

💡 Note: All values are the same, so any valid placement of 3 non-attacking rooks gives the same sum of 3. For example: (0,0), (1,1), (2,2).

Constraints

3 ≤ m, n ≤ 100
-10⁶ ≤ board[i][j] ≤ 10⁶
The board has at least 3 rows and 3 columns
Exactly 3 rooks must be placed

Visualization

Tap to expand

Understanding the Visualization

Identify Constraint

Rooks attack along rows and columns, so each rook must be in a different row and different column

Enumerate Combinations

Systematically try all ways to choose 3 rows and 3 columns from the available options

Optimize Assignment

For each row-column combination, find the best way to assign rows to columns to maximize sum

Track Maximum

Keep track of the highest sum found across all valid placements

Key Takeaway

🎯 Key Insight: Since we only need to place exactly 3 rooks, we can efficiently enumerate all combinations of 3 rows and 3 columns, then find the optimal assignment between them. This structured approach scales much better than naive brute force.

Asked in

G Google 28 a Amazon 22 f Meta 15 ⊞ Microsoft 12

The optimal approach for this problem is enumeration of row-column combinations. Since we only need to place 3 rooks, we can enumerate all ways to choose 3 rows from m rows and 3 columns from n columns, then find the optimal assignment of rows to columns. While the time complexity is still O(m³n³), this structured approach is cleaner than brute force and can be optimized with early pruning techniques. For the given constraints (m,n ≤ 100), this approach is efficient enough.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(m³n³)	O(1)	Try every possible combination of three cells with different rows and columns
Row-Column Enumeration with Sorting	O(m³n³)	O(mn)	First collect and sort all cell values, then enumerate valid row-column combinations

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through all possible first rook positions (i1, j1)
For each first position, iterate through all possible second rook positions (i2, j2) where i2 ≠ i1 and j2 ≠ j1
For each valid first-second combination, iterate through all possible third rook positions (i3, j3) where i3 ∉ {i1, i2} and j3 ∉ {j1, j2}
Calculate sum for each valid combination and track maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Place First Rook

Try every position (i1,j1) for the first rook

Place Second Rook

For each first position, try all valid second positions avoiding same row/column

Place Third Rook

For each valid pair, try all remaining valid third positions

Track Maximum

Calculate sum and update maximum found so far

Code -

solution.c — C

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

long long maximumValueSum(int** board, int m, int n) {
    long long maxSum = LLONG_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++) {
                    if (i2 == i1 || j2 == j1) continue;
                    for (int i3 = 0; i3 < m; i3++) {
                        for (int j3 = 0; j3 < n; j3++) {
                            if (i3 == i1 || i3 == i2 || j3 == j1 || j3 == j2) continue;
                            long long currentSum = (long long)board[i1][j1] + board[i2][j2] + board[i3][j3];
                            if (currentSum > maxSum) {
                                maxSum = currentSum;
                            }
                        }
                    }
                }
            }
        }
    }
    
    return maxSum;
}

int main() {
    int m = 3, n = 3;
    int** board = malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        board[i] = malloc(n * sizeof(int));
    }
    
    // Example board
    board[0][0] = 1; board[0][1] = 2; board[0][2] = 3;
    board[1][0] = 4; board[1][1] = 5; board[1][2] = 6;
    board[2][0] = 7; board[2][1] = 8; board[2][2] = 9;
    
    printf("%lld\n", maximumValueSum(board, m, n));
    
    for (int i = 0; i < m; i++) {
        free(board[i]);
    }
    free(board);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m³n³)

Three nested iterations over all board positions, checking each combination

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current maximum and positions

✓ Linear Space

47.3K Views

Medium 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 (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler