# Leetcode Max Sum of Rectangle No Larger Than K

Leetcode Max Sum of Rectangle No Larger Than K。本题使用常规方法，需要`O(m^2 * n^2)`的时间复杂度，但是经过仔细的计设，可以使时间复杂度降低到`O(smaller(n, n)^2 * larger(n, m) * log(larger(n, m))`。相关步骤如下：
1. 设数组中较大的维度为`dim_max`, 较小的`dim_min`.
2. 针对较大的维度，我们求出其所有项前缀和，即：如果`row <col`，则针对每一列求出前缀和。
3. 针对较小的维度，我们生成`(i, j): i <= j`项，针对每一项，我们找到不大于K子项和。即：如果`row<col`，则生成行数不同子矩阵，然后求得最大且不大于k的子项和。

``````#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;
struct Node {
int val;
struct Node* left;
struct Node* right;
Node(int val): val(val), left(nullptr), right(nullptr) {}
};
class Solution {
public:
int maxSumSubmatrix(vector<vector<int> >& matrix, int k) {
if (matrix.size() == 0) {
return 0;
}
int max = 0;
int tmp = 0;
int flag = 0;
int row1, row2, col1, col2;

vector<vector<int> > tmpValue(matrix.size(),
vector<int>(matrix[0].size(), 0));
// Get the prefix sum of the maximum dimension
getTmpVlaue(tmpValue, matrix);

if (matrix.size() <= matrix[0].size()) {
// row <= col
// Get each [i, j] (i <= j, i,j belongs row) sub matrix maximum value
for (row1 = 0; row1 < matrix.size(); ++row1) {
for (row2 = row1; row2 < matrix.size(); ++row2) {
getResultByRow(tmpValue, row1, row2, k, max, flag);
if (max == k) {
return k;
}
}
}
} else {
// row > col
// Get each [i, j] (i < j, i,j belongs col) sub matrix maximum value
for (col1 = 0; col1 < matrix[0].size(); ++col1) {
for (col2 = col1; col2 < matrix[0].size(); ++col2) {
getResultByCol(tmpValue, col1, col2, k, max, flag);
if (max == k) {
return k;
}
}
}
}
return max;
}
/** * Get the prefix sum for the maximum dimension */
void getTmpVlaue(vector<vector<int> >& tmpValue,
vector<vector<int> >& matrix) {
int row_a = 0;
int col_a = 0;
// Judge which dimension is larger
if (matrix.size() <= matrix[0].size()) {
row_a = 1;
} else {
col_a = 1;
}
for (int row = 0; row < matrix.size(); ++row) {
for (int col = 0; col < matrix[row].size(); ++col) {
if ((row == 0 && row_a == 1) || (col == 0 && col_a == 1)) {
tmpValue[row][col] = matrix[row][col];
} else {
tmpValue[row][col] = tmpValue[row - row_a][col - col_a]
+ matrix[row][col];
}
}
}
}
/** * Get the row major sub matrix maximum value */
void getResultByRow(vector<vector<int> >& tmpValue, int row1, int row2,
int k, int& max, int& flag) {
int value = 0;
int start = 0;
int cur = 0;
Node* ptr = nullptr;
Node* root = new Node(0);
for (cur = 0; cur < tmpValue[0].size(); ++cur) {
if (row1 == 0) {
value += tmpValue[row2][cur];
} else {
value += tmpValue[row2][cur] - tmpValue[row1 - 1][cur];
}
if (value == k) {
max = k;
return;
}
// Search the binary tree find the maximum approriately prefix sum
ptr = getMinNodeGreaterThan(root, value - k);
if (ptr && (value - ptr->val > max || flag == 0)) {
max = value - ptr->val;
flag = 1;
}
// Add the node to the binary search tree
}
// Free the binary search tree
freeTree(root);
}
/** * Get the column major sub matrix maximum value */
void getResultByCol(vector<vector<int> >& tmpValue, int col1, int col2,
int k, int& max, int& flag) {
int value = 0;
int start = 0;
int cur = 0;
Node* ptr = nullptr;
Node* root = new Node(0);
for (cur = 0; cur < tmpValue.size(); ++cur) {
if (col1 == 0) {
value += tmpValue[cur][col2];
} else {
value += tmpValue[cur][col2] - tmpValue[cur][col1 - 1];
}
if (value == k) {
max = k;
return;
}
// Search the binary tree find the maximum approriately prefix sum
ptr = getMinNodeGreaterThan(root, value - k);
if (ptr && (value - ptr->val > max || flag == 0)) {
max = value - ptr->val;
flag = 1;
}
// Add the node to the binary search tree
}
// Free the binary search tree
freeTree(root);
}
/** * Add the value the binary search tree with the given root */
void addNode(Node* root, int val) {
if (val == root->val) {
return;
}
if (val < root->val) {
if (root->left == nullptr) {
root->left = new Node(val);
} else {
}
} else {
if (root->right == nullptr) {
root->right = new Node(val);
} else {
}
}
}
/** * Search the binary search tree get the minimum element which greater than * the given val. */
Node* getMinNodeGreaterThan(Node* root, int val) {
Node* cur = root;
Node* re = nullptr;
while (cur) {
if (cur->val == val) {
return cur;
} else if (cur->val > val) {
if (re == nullptr || cur->val < re->val) {
re = cur;
}
cur = cur->left;
} else if (cur->val < val) {
cur = cur->right;
}
}
return re;
}
/** * Free the binary search tree with the given root */
void freeTree(Node* root) {
queue<Node*> leftElement;
leftElement.push(root);
Node* ptr = root;
while (!leftElement.empty()) {
ptr = leftElement.front();
leftElement.pop();
if (ptr->left) {
leftElement.push(ptr->left);
}
if (ptr->right) {
leftElement.push(ptr->right);
}
delete ptr;
}
}
};

/** * Test */
int main(int argc, char* argv[]) {
Solution so;
vector<vector<int> > matrix {{27,5,-20,-9,1,26,1,12,7,-4,8,7,-1,5,8},{16,28,8,3,16,28,-10,-7,-5,-13,7,9,20,-9,26},{24,-14,20,23,25,-16,-15,8,8,-6,-14,-6,12,-19,-13},{28,13,-17,20,-3,-18,12,5,1,25,25,-14,22,17,12},{7,29,-12,5,-5,26,-5,10,-5,24,-9,-19,20,0,18},{-7,-11,-8,12,19,18,-15,17,7,-1,-11,-10,-1,25,17},{-3,-20,-20,-7,14,-12,22,1,-9,11,14,-16,-5,-12,14},{-20,-4,-17,3,3,-18,22,-13,-1,16,-11,29,17,-2,22},{23,-15,24,26,28,-13,10,18,-6,29,27,-19,-19,-8,0},{5,9,23,11,-4,-20,18,29,-6,-4,-11,21,-6,24,12},{13,16,0,-20,22,21,26,-3,15,14,26,17,19,20,-5},{15,1,22,-6,1,-9,0,21,12,27,5,8,8,18,-1},{15,29,13,6,-11,7,-6,27,22,18,22,-3,-9,20,14},{26,-6,12,-10,0,26,10,1,11,-10,-16,-18,29,8,-8},{-19,14,15,18,-10,24,-9,-7,-19,-14,23,23,17,-5,6}};
int max = so.maxSumSubmatrix(matrix, -100);
cout << "maximum is: " << max << endl;
return 0;
}``````