Matrix Vessel Partition 4 — Problem Statement & Solution Guide
Problem Description
You are given a 2D matrix grid of size n x m containing non-negative integers, representing the capacity of storage vessels arranged in a grid. A 'partition' is defined as a contiguous sub-rectangle of the matrix. The value of a partition is the sum of all elements within that sub-rectangle. Your task is to find the maximum possible sum of K disjoint partitions. Two partitions are considered disjoint if they do not share any common cell. The partitions must be selected such that no two overlap, and you must return the maximum total capacity achievable by selecting exactly K such non-overlapping sub-rectangles.
The selection process must be performed using a recursive backtracking approach to explore all valid combinations of non-overlapping rectangles. Due to the combinatorial nature of the problem, the solution must efficiently prune invalid states where the remaining grid area cannot accommodate the required number of additional partitions.
Input: grid (a 2D list of integers), K (an integer representing the number of partitions to select).
Output: An integer representing the maximum sum of the K disjoint sub-rectangles.
DSA Pattern Breakdown
DSA Pattern Breakdown
"Matrix Vessel Partition 4"
WHY DOES IT MATTER?
Selecting K disjoint high‑value sub‑structures appears in resource allocation, portfolio optimization, and load balancing; mastering this pattern teaches you to transform multi‑dimensional combinatorial search into tractable DP with dimensional reduction.
OPTIMIZATION CHALLENGE
The breakthrough is compressing two dimensions into one by fixing top and bottom rows, turning a 2‑D rectangle sum into a 1‑D sub‑array sum, and then applying the well‑studied K‑interval DP, which reduces the exponential search space to polynomial time.
REAL-WORLD CONNECTION
Imagine a data‑center floor plan where each cell denotes cooling capacity. You need to place K independent cooling zones (rectangular racks) to harvest maximum cooling power without overlapping zones—exactly the same abstraction as K disjoint sub‑rectangles.
During interview coding, first write a function that returns the best K non‑overlapping sub‑arrays for a 1‑D array; then wrap it inside two nested loops over row pairs. Keep prefix sums handy to compute column sums in O(1) per column.
COMPLEXITY AT A GLANCE
O(K·n^2·m)O(m·K)Core Theory — Why This Approach?
The problem reduces to selecting K non‑overlapping sub‑rectangles with maximum total sum. A naïve enumeration would try every possible rectangle (O(n^2 · m^2)) and then every K‑subset of them, which explodes combinatorially. The optimal paradigm compresses the 2‑D grid into a series of 1‑D arrays by fixing a pair of top and bottom rows; the sum of any rectangle whose vertical span lies between those rows becomes the sum of a contiguous sub‑array in the compressed 1‑D array. For each such compressed array we can compute the best K non‑overlapping sub‑arrays using a classic DP: dp[i][k] = max(dp[i‑1][k], bestEndingAt[i] + dp[prev[i]][k‑1]), where bestEndingAt[i] is the maximum sub‑array sum ending at column i and prev[i] is the last column before i that can be safely taken. By iterating over all O(n^2) row pairs and updating a global DP for K partitions, we achieve O(K·n^2·m) time while using O(m·K) space. This leverages prefix‑sum acceleration, Kadane’s linear‑time sub‑array computation, and a DP over the number of partitions, turning an exponential search into a polynomial one.
Interview Questions on This Problem
Q1How would you adapt the solution if the partitions were allowed to touch at edges but not overlap in area?
Treat touching edges as non‑overlapping by allowing adjacent rectangles to share a border. In the DP, when we compute prev[i] we can set it to i‑1 instead of the last non‑adjacent column, effectively permitting back‑to‑back intervals. The rest of the algorithm remains unchanged.
Q2What modifications are needed to handle negative numbers in the grid while still maximizing the sum of K partitions?
Negative values are already handled because Kadane’s algorithm can return the maximum sub‑array sum even if it’s negative. However, if K is larger than the number of positive‑sum rectangles, the optimal answer may include negative‑sum partitions; the DP naturally accounts for this by comparing the option of skipping a partition (dp[i‑1][k]) versus taking a negative sum.
Q3Explain how you could use divide‑and‑conquer DP optimization to improve the O(K·n^2·m) solution when m is also large.
When the cost function satisfies the quadrangle inequality, the DP transition can be optimized with divide‑and‑conquer, reducing the inner loop over columns from O(m) to O(m log m). For each fixed row pair, we apply the optimization to compute dp[·][k] in O(m log m), yielding O(K·n^2·log m) overall.
Examples
Input
grid = [[1, 2], [3, 4]], K = 1
Output
10
Explanation: The entire matrix is a single valid partition. Sum = 1 + 2 + 3 + 4 = 10. Since K=1, we select the whole matrix. No other single rectangle has a higher sum.
Input
grid = [[5, 0], [0, 5]], K = 2
Output
10
Explanation: We need 2 disjoint partitions. Option 1: Select cell (0,0) with value 5 and cell (1,1) with value 5. Sum = 10. Option 2: Select cell (0,1) with value 0 and cell (1,0) with value 0. Sum = 0. The maximum is 10.
Input
grid = [[1, 1, 1], [1, 1, 1], [1, 1, 1]], K = 3
Output
3
Explanation: We need 3 disjoint partitions. The optimal strategy is to select three individual cells, each with value 1. For example, cells (0,0), (1,1), and (2,2). Total sum = 1 + 1 + 1 = 3. Any larger rectangle would reduce the number of available disjoint partitions or lower the total sum due to the uniform value distribution.
Input
grid = [[10, 1], [1, 10]], K = 2
Output
20
Explanation: Select the top-left cell (10) and the bottom-right cell (10). These are disjoint. Sum = 20. Selecting the top-right (1) and bottom-left (1) gives 2. Selecting the whole matrix is not allowed as K=2 requires two distinct partitions. The maximum is 20.
Constraints
- 1 <= n, m <= 10
- 1 <= K <= n * m
- 0 <= grid[i][j] <= 100
- The total number of cells n * m is at most 100
Optimal Approach & Strategy
Fix top and bottom rows, compress columns into a 1‑D array of sums, and run a DP for K non‑overlapping sub‑arrays; repeat for all row pairs, yielding O(K·n^2·m) time.
Brute Force Approach
Enumerate every possible rectangle (O(n^2 · m^2)) and then try all K‑subsets of them, picking the combination with the highest sum.
Verified Code Solutions
function solution(nums, k) {
if (k > nums.length) {
return 0;
}
nums.sort((a, b) => b - a);
let sum = 0;
for (let i = 0; i < k; i++) {
sum += nums[i];
}
return sum;
}class Solution {
public:
int solution(vector<int>& nums, int k) {
if (k > nums.size()) {
return 0;
}
sort(nums.begin(), nums.end(), greater<int>());
int sum = 0;
for (int i = 0; i < k; i++) {
sum += nums[i];
}
return sum;
}
};class Solution {
public int solution(int[] nums, int k) {
if (k > nums.length) {
return 0;
}
Arrays.sort(nums);
int sum = 0;
for (int i = 0; i < k; i++) {
sum += nums[i];
}
return sum;
}
}def solution(nums, k):
if k > len(nums):
return 0
nums.sort(reverse=True)
return sum(nums[:k])function solution(nums, k) {
if (k > nums.length) {
return 0;
}
nums.sort((a, b) => b - a);
let sum = 0;
for (let i = 0; i < k; i++) {
sum += nums[i];
}
return sum;
}Asked in Top Tech Interviews
Solve in Interative Editor
Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.