Maximum Value Sum by Placing Three Rooks II

Maximum Value Sum by Placing Three Rooks II - Problem

Chess Optimization Challenge: You're given an m × n chessboard where each cell board[i][j] contains a numerical value. Your task is to place exactly three rooks on the board such that they don't attack each other (no two rooks can be in the same row or column).

The goal is to maximize the sum of the values in the cells where you place the rooks. This is a classic combinatorial optimization problem that tests your understanding of constraints and efficient enumeration.

Key Rules:
• Place exactly 3 rooks
• No two rooks in the same row
• No two rooks in the same column
• Maximize the sum of cell values

Input & Output

example_1.py — Python

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

› Output: 4

💡 Note: Place rooks at (0,2), (1,1), (2,3) with values 1+1+1=3, or at (0,3), (1,1), (2,1) with values 1+1+2=4. The maximum is 4.

example_2.py — Python

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

› Output: 15

💡 Note: Place rooks at (0,2), (1,1), (2,0) with values 3+5+7=15. This gives the maximum possible sum.

example_3.py — Python

$ Input: [[1,1],[1,1]]

› Output: 2

💡 Note: Only 2 rows available, so we can place at most 2 rooks. With exactly 3 rooks required, we need at least 3 rows. This case would be invalid for the problem constraints.

Constraints

3 ≤ m, n ≤ 100 (board dimensions)
-10⁵ ≤ board[i][j] ≤ 10⁵ (cell values)
You must place exactly 3 rooks
Each rook must be in a different row and different column

Visualization

Tap to expand

Understanding the Visualization

Analyze Board

Identify high-value positions and constraints

Fix First Position

Choose a strategic first rook placement

Optimize Remaining

Find optimal placement for remaining 2 rooks

Combine Results

Sum values and track maximum across all strategies

Key Takeaway

🎯 Key Insight: By systematically enumerating positions and using smart precomputation, we can solve this constraint optimization problem efficiently while guaranteeing the optimal solution.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses smart enumeration by fixing the first rook position and precomputing the best 2-rook placements for remaining rows. This reduces the time complexity from O(m³n³) brute force to O(m×n×m²×n²), making it feasible for the given constraints. The key insight is that once we fix one rook, the remaining problem becomes finding the maximum sum of 2 non-attacking rooks in a subgrid.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Enumeration with Precomputation	O(m × n × m² × n²)	O(m² × n²)	Fix one rook position and precompute best pairs for remaining rows
Brute Force (Triple Nested Loops)	O(m³ × n³)	O(1)	Try every possible combination of 3 positions with different rows and columns

Optimized Enumeration with Precomputation — Algorithm Steps

For each possible first rook position (i, j)
Precompute the best 2-rook placements in remaining rows (excluding column j)
Combine the first rook value with the best 2-rook value
Track the maximum sum across all first positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix First Rook

Place first rook at position (i,j)

Find Remaining Rows

Identify rows that don't contain the first rook

Compute Best Pair

For each pair of remaining rows, find best column assignment avoiding column j

Combine Results

Add first rook value to best pair value

Code -

solution.c — C

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

long long getBestTwoRooks(int** board, int r1, int r2, int excludedCol, int n) {
    long long best = LLONG_MIN;
    
    for (int c1 = 0; c1 < n; c1++) {
        if (c1 == excludedCol) continue;
        for (int c2 = 0; c2 < n; c2++) {
            if (c2 == excludedCol || c2 == c1) continue;
            long long current = board[r1][c1] + board[r2][c2];
            if (current > best) {
                best = current;
            }
        }
    }
    
    return best;
}

long long maximumValueSum(int** board, int m, int n) {
    long long maxSum = LLONG_MIN;
    
    // Try each position for first rook
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int remainingRows[m];
            int remainingCount = 0;
            
            for (int r = 0; r < m; r++) {
                if (r != i) {
                    remainingRows[remainingCount++] = r;
                }
            }
            
            // Try all pairs of remaining rows
            for (int r1_idx = 0; r1_idx < remainingCount; r1_idx++) {
                for (int r2_idx = r1_idx + 1; r2_idx < remainingCount; r2_idx++) {
                    int r1 = remainingRows[r1_idx];
                    int r2 = remainingRows[r2_idx];
                    long long bestTwo = getBestTwoRooks(board, r1, r2, j, n);
                    
                    if (bestTwo != LLONG_MIN) {
                        long long current = board[i][j] + bestTwo;
                        if (current > maxSum) {
                            maxSum = current;
                        }
                    }
                }
            }
        }
    }
    
    return maxSum;
}

int main() {
    int rows = 3, cols = 4;
    int** board = malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        board[i] = malloc(cols * sizeof(int));
    }
    
    int data[3][4] = {{-3,1,1,1},{-3,1,-3,1},{-3,2,1,1}};
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            board[i][j] = data[i][j];
        }
    }
    
    printf("%lld\n", maximumValueSum(board, rows, cols));
    
    for (int i = 0; i < rows; i++) {
        free(board[i]);
    }
    free(board);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × m² × n²)

For each of m×n first positions, we compute best pairs in O(m²×n²)

⚠ Quadratic Growth

Space Complexity

O(m² × n²)

Store precomputed best pairs for each row pair and available columns

⚠ Quadratic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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

Optimized Enumeration with Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler